@tekyzinc/gsd-t 3.11.11 → 3.12.10

package/bin/gsd-t.js

@@ -433,8 +433,8 @@ function ensureGitignoreEntries(projectDir, entries) {
 
 // Install the Context Meter into a project directory.
 // Copies scripts/gsd-t-context-meter.js, scripts/context-meter/*.js (runtime
-// only — skips .test.js and test-injector.js), and the config template (if
-// missing). Also appends entries to .gitignore.
+// only — skips .test.js), and the config template (if missing). Also appends
+// entries to .gitignore.
 function installContextMeter(projectDir) {
   try {
     // 1. Copy gsd-t-context-meter.js → {projectDir}/scripts/
@@ -486,9 +486,7 @@ function installContextMeter(projectDir) {
         return false;
       }
       for (const fname of depFiles) {
-        // Skip test files and test-only infrastructure
         if (fname.includes(".test.")) continue;
-        if (fname === "test-injector.js") continue;
         const fsrc = path.join(depsSrcDir, fname);
         const fdest = path.join(depsDestDir, fname);
         try {
@@ -1970,8 +1968,7 @@ const PROJECT_BIN_TOOLS = [
   "archive-progress.cjs", "log-tail.cjs", "context-budget-audit.cjs",
   "context-meter-config.cjs", "token-budget.cjs",
   "gsd-t-unattended.cjs", "gsd-t-unattended-platform.cjs", "gsd-t-unattended-safety.cjs",
-  "handoff-lock.cjs", "headless-auto-spawn.cjs", "runway-estimator.cjs",
-  "token-telemetry.cjs", "token-optimizer.cjs",
+  "handoff-lock.cjs", "headless-auto-spawn.cjs",
 ];
 
 function copyBinToolsToProject(projectDir, projectName) {
@@ -2721,7 +2718,7 @@ function doHeadlessExec(command, cmdArgs, flags) {
   let processExitCode = 0;
 
   try {
-    const result = execFileSync("claude", ["-p", prompt], {
+    const result = execFileSync("claude", ["-p", "--dangerously-skip-permissions", prompt], {
       encoding: "utf8",
       timeout: timeoutMs,
       stdio: ["pipe", "pipe", "pipe"],
@@ -3245,117 +3242,10 @@ function showHeadlessHelp() {
   log(`  ${DIM}$${RESET} gsd-t headless query domains\n`);
 }
 
-// ─── Metrics (M35 token telemetry CLI) ────────────────────────────────────────
+// ─── Metrics (removed in v3.12 — M38 meter reduction) ─────────────────────────
 
-function parseMetricsByFlag(args) {
-  const byArg = args.find(a => a.startsWith("--by="));
-  if (!byArg) return [];
-  const raw = byArg.slice(5).trim();
-  if (!raw) return [];
-  return raw.split(",").map(s => s.trim()).filter(Boolean);
-}
-
-function formatPct(v) {
-  if (v === null || v === undefined || Number.isNaN(v)) return "—";
-  return `${Number(v).toFixed(1)}%`;
-}
-
-function formatInt(v) {
-  if (v === null || v === undefined || Number.isNaN(v)) return "—";
-  return String(Math.round(Number(v)));
-}
-
-function doMetrics(args) {
-  const projectDir = process.cwd();
-  let tt;
-  try {
-    tt = require(path.join(projectDir, "bin", "token-telemetry.js"));
-  } catch (e) {
-    error(`bin/token-telemetry.js not found in ${projectDir} — run gsd-t install first.`);
-    process.exit(1);
-  }
-
-  const records = tt.readAll(projectDir);
-  if (records.length === 0) {
-    log(`${DIM}No telemetry records yet — .gsd-t/token-metrics.jsonl is empty or missing.${RESET}`);
-    return;
-  }
-
-  const isTokens = args.includes("--tokens");
-  const isHalts = args.includes("--halts");
-  const isContextWindow = args.includes("--context-window");
-
-  if (!isTokens && !isHalts && !isContextWindow) {
-    log(`${YELLOW}Specify at least one of: --tokens, --halts, --context-window${RESET}`);
-    return;
-  }
-
-  if (isHalts) {
-    const halts = records.filter(r => r.halt_type);
-    log(`\n${BOLD}Halts — ${halts.length} record(s)${RESET}`);
-    if (halts.length === 0) {
-      log(`${DIM}  (no halts recorded — all spawns completed normally)${RESET}\n`);
-    } else {
-      const byType = {};
-      for (const r of halts) {
-        const key = String(r.halt_type);
-        byType[key] = (byType[key] || 0) + 1;
-      }
-      for (const [type, count] of Object.entries(byType).sort()) {
-        log(`  ${CYAN}${type.padEnd(24)}${RESET} ${count}`);
-      }
-      log("");
-    }
-  }
-
-  if (isTokens) {
-    const by = parseMetricsByFlag(args);
-    if (by.length === 0) {
-      const totalConsumed = records.reduce((a, r) => a + (Number(r.tokens_consumed) || 0), 0);
-      const totalDuration = records.reduce((a, r) => a + (Number(r.duration_s) || 0), 0);
-      log(`\n${BOLD}Tokens — ${records.length} spawn(s)${RESET}`);
-      log(`  total tokens consumed:  ${formatInt(totalConsumed)}`);
-      log(`  total duration (s):     ${formatInt(totalDuration)}`);
-      if (records.length > 0) {
-        log(`  mean tokens/spawn:      ${formatInt(totalConsumed / records.length)}`);
-      }
-      log("");
-    } else {
-      const groups = tt.aggregate(records, { by });
-      log(`\n${BOLD}Tokens by ${by.join(",")} — ${groups.length} group(s)${RESET}`);
-      const keyHeader = by.join("/");
-      log(`  ${keyHeader.padEnd(36)}  ${"count".padStart(7)}  ${"total".padStart(12)}  ${"mean".padStart(10)}  ${"median".padStart(10)}  ${"p95".padStart(10)}`);
-      log(`  ${"-".repeat(36)}  ${"-".repeat(7)}  ${"-".repeat(12)}  ${"-".repeat(10)}  ${"-".repeat(10)}  ${"-".repeat(10)}`);
-      for (const g of groups) {
-        const label = by.map(k => g.key[k] == null ? "—" : String(g.key[k])).join("/");
-        log(`  ${label.padEnd(36)}  ${formatInt(g.count).padStart(7)}  ${formatInt(g.total_tokens).padStart(12)}  ${formatInt(g.mean).padStart(10)}  ${formatInt(g.median).padStart(10)}  ${formatInt(g.p95).padStart(10)}`);
-      }
-      log("");
-    }
-  }
-
-  if (isContextWindow) {
-    log(`\n${BOLD}Context window trend — ${records.length} record(s)${RESET}`);
-    const withPct = records.filter(r => r.context_window_pct_after != null && !Number.isNaN(Number(r.context_window_pct_after)));
-    if (withPct.length === 0) {
-      log(`${DIM}  (no context-window measurements in records)${RESET}\n`);
-    } else {
-      const sorted = [...withPct].map(r => Number(r.context_window_pct_after)).sort((a, b) => a - b);
-      const min = sorted[0];
-      const max = sorted[sorted.length - 1];
-      const mean = sorted.reduce((a, b) => a + b, 0) / sorted.length;
-      const p95 = sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95))];
-      log(`  min:   ${formatPct(min)}`);
-      log(`  mean:  ${formatPct(mean)}`);
-      log(`  p95:   ${formatPct(p95)}`);
-      log(`  max:   ${formatPct(max)}`);
-      const atWarn = withPct.filter(r => Number(r.context_window_pct_after) >= 70).length;
-      const atStop = withPct.filter(r => Number(r.context_window_pct_after) >= 85).length;
-      log(`  spawns at warn band (≥70%):  ${atWarn}`);
-      log(`  spawns at stop band (≥85%):  ${atStop}`);
-      log("");
-    }
-  }
+function doMetrics(_args) {
+  log(`${DIM}metrics removed in v3.12 — context meter is no longer telemetry-instrumented${RESET}`);
 }
 
 function showHelp() {
@@ -3515,6 +3405,14 @@ if (require.main === module) {
     case "headless":
       doHeadless(args.slice(1));
       break;
+    case "unattended": {
+      const { spawnSync } = require("child_process");
+      const cjs = path.join(__dirname, "gsd-t-unattended.cjs");
+      const res = spawnSync(process.execPath, [cjs, ...args.slice(1)], {
+        stdio: "inherit",
+      });
+      process.exit(res.status == null ? 1 : res.status);
+    }
     case "metrics":
       doMetrics(args.slice(1));
       break;

package/bin/headless-auto-spawn.cjs

@@ -53,20 +53,54 @@ module.exports = {
  *   args?: string[],
  *   continue_from?: string,
  *   projectDir?: string,
- *   context?: object
+ *   context?: object,
+ *   sessionContext?: object,
+ *   sessionId?: string,
+ *   watch?: boolean,
+ *   spawnType?: 'primary' | 'validation'
  * }} opts
- * @returns {{ id: string, pid: number, logPath: string, timestamp: string }}
+ * @returns {{ id: string | null, pid: number | null, logPath: string | null, timestamp: string, mode: 'headless' | 'in-context' }}
  */
 function autoSpawnHeadless(opts) {
   const command = opts.command;
   const args = opts.args || [];
   const continue_from = opts.continue_from || ".";
   const projectDir = opts.projectDir || process.cwd();
-  const context = opts.context || null;
+  const context = opts.context || opts.sessionContext || null;
+  const watch = opts.watch === true;
+  const spawnType = opts.spawnType || "primary";
 
   if (!command || typeof command !== "string") {
     throw new Error("autoSpawnHeadless: `command` is required");
   }
+  if (spawnType !== "primary" && spawnType !== "validation") {
+    throw new Error(
+      `autoSpawnHeadless: \`spawnType\` must be 'primary' or 'validation' (got ${JSON.stringify(spawnType)})`,
+    );
+  }
+
+  // Propagation rules (headless-default-contract §2):
+  //   watch=true + primary    → signal in-context fallback (caller uses Task)
+  //   watch=true + validation → warn on stderr; proceed headless
+  //   watch=false             → headless (default behavior)
+  if (watch && spawnType === "primary") {
+    return {
+      id: null,
+      pid: null,
+      logPath: null,
+      timestamp: new Date().toISOString(),
+      mode: "in-context",
+    };
+  }
+  if (watch && spawnType === "validation") {
+    try {
+      process.stderr.write(
+        `[headless-default] --watch ignored for validation spawn type: ${spawnType}\n`,
+      );
+    } catch (_) {
+      /* best effort */
+    }
+  }
 
   const timestamp = new Date().toISOString();
   const id = makeSessionId(command, new Date());
@@ -145,7 +179,13 @@ function autoSpawnHeadless(opts) {
   // a detached approach that survives even after the parent's `unref()`.
   installCompletionWatcher({ projectDir, id, logPath, pid, startTimestamp: timestamp });
 
-  return { id, pid, logPath: path.relative(projectDir, logPath), timestamp };
+  return {
+    id,
+    pid,
+    logPath: path.relative(projectDir, logPath),
+    timestamp,
+    mode: "headless",
+  };
 }
 
 // ── makeSessionId ────────────────────────────────────────────────────────────

package/bin/headless-auto-spawn.js

@@ -53,20 +53,54 @@ module.exports = {
  *   args?: string[],
  *   continue_from?: string,
  *   projectDir?: string,
- *   context?: object
+ *   context?: object,
+ *   sessionContext?: object,
+ *   sessionId?: string,
+ *   watch?: boolean,
+ *   spawnType?: 'primary' | 'validation'
  * }} opts
- * @returns {{ id: string, pid: number, logPath: string, timestamp: string }}
+ * @returns {{ id: string | null, pid: number | null, logPath: string | null, timestamp: string, mode: 'headless' | 'in-context' }}
  */
 function autoSpawnHeadless(opts) {
   const command = opts.command;
   const args = opts.args || [];
   const continue_from = opts.continue_from || ".";
   const projectDir = opts.projectDir || process.cwd();
-  const context = opts.context || null;
+  const context = opts.context || opts.sessionContext || null;
+  const watch = opts.watch === true;
+  const spawnType = opts.spawnType || "primary";
 
   if (!command || typeof command !== "string") {
     throw new Error("autoSpawnHeadless: `command` is required");
   }
+  if (spawnType !== "primary" && spawnType !== "validation") {
+    throw new Error(
+      `autoSpawnHeadless: \`spawnType\` must be 'primary' or 'validation' (got ${JSON.stringify(spawnType)})`,
+    );
+  }
+
+  // Propagation rules (headless-default-contract §2):
+  //   watch=true + primary    → signal in-context fallback (caller uses Task)
+  //   watch=true + validation → warn on stderr; proceed headless
+  //   watch=false             → headless (default behavior)
+  if (watch && spawnType === "primary") {
+    return {
+      id: null,
+      pid: null,
+      logPath: null,
+      timestamp: new Date().toISOString(),
+      mode: "in-context",
+    };
+  }
+  if (watch && spawnType === "validation") {
+    try {
+      process.stderr.write(
+        `[headless-default] --watch ignored for validation spawn type: ${spawnType}\n`,
+      );
+    } catch (_) {
+      /* best effort */
+    }
+  }
 
   const timestamp = new Date().toISOString();
   const id = makeSessionId(command, new Date());
@@ -145,7 +179,13 @@ function autoSpawnHeadless(opts) {
   // a detached approach that survives even after the parent's `unref()`.
   installCompletionWatcher({ projectDir, id, logPath, pid, startTimestamp: timestamp });
 
-  return { id, pid, logPath: path.relative(projectDir, logPath), timestamp };
+  return {
+    id,
+    pid,
+    logPath: path.relative(projectDir, logPath),
+    timestamp,
+    mode: "headless",
+  };
 }
 
 // ── makeSessionId ────────────────────────────────────────────────────────────

package/bin/scan-data-collector.js

@@ -25,22 +25,50 @@ function parseTestCoverage(text) {
 function parseFilesAndLoc(text) {
   const m = text.match(/\|\s*\*?\*?(?:Grand\s+)?Total[^|]*\*?\*?\s*\|\s*\*?\*?(\d+)\s+files?\*?\*?\s*\|\s*\*?\*?([\d,]+)[^|]*\*?\*?\s*\|/i);
   if (m) return { filesScanned: parseInt(m[1], 10), totalLoc: parseInt(m[2].replace(/,/g, ''), 10) };
+  let files = 0;
+  let loc = 0;
+  const lineRe = /(\d+)\s+files?\s*\(\s*~?\s*([\d,]+)\s+LOC\s*\)/gi;
+  let match;
+  while ((match = lineRe.exec(text)) !== null) {
+    files += parseInt(match[1], 10);
+    loc += parseInt(match[2].replace(/,/g, ''), 10);
+  }
+  if (files > 0) return { filesScanned: files, totalLoc: loc };
   return { filesScanned: 0, totalLoc: 0 };
 }
 
 function parseComponents(text) {
   const sec = text.match(/## Component Inventory([\s\S]*?)(?=\n## |\n---|\n#[^#]|$)/);
-  if (!sec) return [];
-  return sec[1].split('\n')
-    .filter(l => /^\|/.test(l) && !/---/.test(l) && !/Component.*File/i.test(l))
-    .map(row => {
-      const cols = row.split('|').map(c => c.trim().replace(/\*\*/g, '').replace(/`/g, '')).filter(Boolean);
-      if (cols.length < 3) return null;
-      const name = cols[0];
-      if (!name || /^total/i.test(name)) return null;
-      return { name, filePath: cols[1] || '', size: cols[2] || '', purpose: cols[3] || '', files: 1, healthScore: 80 };
-    })
-    .filter(Boolean);
+  if (sec) {
+    const tableRows = sec[1].split('\n')
+      .filter(l => /^\|/.test(l) && !/---/.test(l) && !/Component.*File/i.test(l))
+      .map(row => {
+        const cols = row.split('|').map(c => c.trim().replace(/\*\*/g, '').replace(/`/g, '')).filter(Boolean);
+        if (cols.length < 3) return null;
+        const name = cols[0];
+        if (!name || /^total/i.test(name)) return null;
+        return { name, filePath: cols[1] || '', size: cols[2] || '', purpose: cols[3] || '', files: 1, healthScore: 80 };
+      })
+      .filter(Boolean);
+    if (tableRows.length > 0) return tableRows;
+  }
+  const structSec = text.match(/## Structure([\s\S]*?)(?=\n## |\n---|\n#[^#]|$)/);
+  if (!structSec) return [];
+  const entryRe = /^([a-zA-Z0-9_.\-]+\/)\s+(?:~?\s*)?(?:(\d+)\s+files?\s*)?\(?\s*~?\s*([\d,]+)\s+LOC\s*\)?\s*(.*)$/gm;
+  const out = [];
+  let m;
+  while ((m = entryRe.exec(structSec[1])) !== null) {
+    const name = m[1].replace(/\/$/, '');
+    out.push({
+      name,
+      filePath: m[1],
+      size: (m[2] ? m[2] + ' files, ' : '') + m[3] + ' LOC',
+      purpose: (m[4] || '').trim(),
+      files: m[2] ? parseInt(m[2], 10) : 1,
+      healthScore: 80,
+    });
+  }
+  return out;
 }
 
 function parseSeverityMap(text) {

package/bin/token-budget.cjs

@@ -1,22 +1,25 @@
 #!/usr/bin/env node
 
 /**
- * GSD-T Token Budget — Session-level token tracking (three-band model)
+ * GSD-T Token Budget — Session-level token tracking (single-band, v3.12)
  *
- * Reads .gsd-t/.context-meter-state.json (M34) for real context-window
- * readings, tracks session usage, and returns a three-band status signal
- * (normal / warn / stop) that callers use to decide whether to proceed,
- * log a warning, or halt cleanly.
+ * Reads .gsd-t/.context-meter-state.json (M34) for context-window readings
+ * and returns a single-band status signal (normal / threshold) that the
+ * orchestrator uses to decide whether the next subagent spawn must go
+ * through autoSpawnHeadless().
  *
- * v3.0.0 (M35 — clean break from v2.0.0):
- *   - The `downgrade` and `conserve` bands were REMOVED. Silent model
- *     degradation and silent phase-skipping are anti-features — they
- *     violate GSD-T's "quality is non-negotiable" principle.
- *   - `getDegradationActions()` now returns `{band, pct, message}` instead
- *     of `{threshold, actions, modelOverrides}`. No `modelOverride`, no
- *     `skipPhases`, no `checkpoint` side-channel.
- *   - `warn` threshold tightened from 60% → 70%. `stop` tightened from
- *     95% → 85% — keeps us clear of the runtime's native ~95% compact.
+ * v3.12.0 (M38 — meter reduction):
+ *   - Collapsed three-band model (normal/warn/stop) to single-band
+ *     (normal/threshold). The orchestrator makes the routing decision;
+ *     the meter reports a band, not a degradation policy.
+ *   - `getDegradationActions` export removed.
+ *   - Dead-meter detection, `stale` band, and `deadReason` removed.
+ *     Stale state transparently falls through to the heuristic — the
+ *     fail-open hook never raised a user-visible alarm anyway, and the
+ *     orchestrator's headless-by-default posture handles overflow
+ *     structurally rather than by trying to instruct Claude mid-session.
+ *   - Threshold default is `thresholdPct` from context-meter-config.json
+ *     (default 75%). There is no intermediate warn band.
  *
  * Zero external dependencies (Node.js built-ins only).
  */
@@ -40,17 +43,8 @@ const BASE_ESTIMATES = {
   default: 6000,
 };
 
-// v3.0.0 three-band thresholds. Lower-bound inclusive.
-//   pct <  70 → normal
-//   70 ≤ pct <  85 → warn (informational — log, proceed)
-//   pct ≥ 85 → stop  (halt cleanly, hand off to runway estimator)
-const WARN_THRESHOLD_PCT = 70;
-const STOP_THRESHOLD_PCT = 85;
-
-const THRESHOLDS = {
-  warn: WARN_THRESHOLD_PCT,
-  stop: STOP_THRESHOLD_PCT,
-};
+// v3.12 single-band default. Overridable via context-meter-config.json.
+const DEFAULT_THRESHOLD_PCT = 75;
 
 // ── Exports ──────────────────────────────────────────────────────────────────
 
@@ -58,7 +52,6 @@ module.exports = {
   estimateCost,
   getSessionStatus,
   recordUsage,
-  getDegradationActions,
   estimateMilestoneCost,
   getModelCostRatios,
 };
@@ -92,45 +85,34 @@ function estimateCost(model, taskType, options) {
 // ── getSessionStatus ─────────────────────────────────────────────────────────
 
 const STATE_FILE_REL = path.join(".gsd-t", ".context-meter-state.json");
+const CONFIG_FILE_REL = path.join(".gsd-t", "context-meter-config.json");
 const STATE_STALE_MS = 5 * 60 * 1000;
 
 /**
  * @param {string} [projectDir]
- * @returns {{ consumed: number, estimated_remaining: number, pct: number, threshold: string }}
+ * @returns {{ consumed: number, estimated_remaining: number, pct: number, threshold: 'normal'|'threshold' }}
  *
- * v2.0.0 (M34): reads `.gsd-t/.context-meter-state.json` produced by the
- * Context Meter PostToolUse hook. When that file is fresh (timestamp within
- * the last 5 minutes), real `input_tokens` drive the response. Otherwise we
- * fall back to a historical heuristic from `.gsd-t/token-log.md`, preserving
- * graceful degradation for projects without the hook installed.
+ * v3.12 (M38): reads `.gsd-t/.context-meter-state.json` produced by the
+ * Context Meter PostToolUse hook. When the state file is fresh (timestamp
+ * within 5 minutes), real `input_tokens` drive the response. Otherwise we
+ * fall back to a historical heuristic from `.gsd-t/token-log.md`. Stale or
+ * missing state is not a distinct band — the fail-open hook never raised
+ * a user-visible alarm, and the orchestrator's headless-by-default spawn
+ * path handles overflow structurally.
  */
 function getSessionStatus(projectDir) {
   const dir = projectDir || process.cwd();
+  const thresholdPct = resolveThresholdPct(dir);
   const real = readContextMeterState(dir);
   if (real) {
     const consumed = real.inputTokens;
     const window = real.modelWindowSize > 0 ? real.modelWindowSize : 200000;
     const estimated_remaining = Math.max(0, window - consumed);
     const pct = Math.round(real.pct * 10) / 10;
-    const threshold = resolveThreshold(pct);
+    const threshold = bandFor(pct, thresholdPct);
     return { consumed, estimated_remaining, pct, threshold };
   }
-  // Meter exists but is dead (file present, API key missing, parse/API error,
-  // or timestamp stale). Return a `stale` band so callers halt instead of
-  // silently running with a blind gate. This is the fix for the M36 /compact
-  // regression where checkCount=2102 but every hook call failed fail-open.
-  const dead = readContextMeterDead(dir);
-  if (dead) {
-    const window = dead.modelWindowSize > 0 ? dead.modelWindowSize : 200000;
-    return {
-      consumed: 0,
-      estimated_remaining: window,
-      pct: 0,
-      threshold: "stale",
-      deadReason: dead.reason,
-    };
-  }
-  return getSessionStatusHeuristic(dir);
+  return getSessionStatusHeuristic(dir, thresholdPct);
 }
 
 function readContextMeterState(dir) {
@@ -149,41 +131,25 @@ function readContextMeterState(dir) {
   }
 }
 
-// Return { reason, modelWindowSize } when the state file exists but the meter
-// is not producing a fresh, clean reading. Returns null when the file is
-// missing entirely (no meter installed — fall through to heuristic).
-function readContextMeterDead(dir) {
+function resolveThresholdPct(dir) {
   try {
-    const fp = path.join(dir, STATE_FILE_REL);
-    if (!fs.existsSync(fp)) return null;
+    const fp = path.join(dir, CONFIG_FILE_REL);
     const raw = fs.readFileSync(fp, "utf8");
-    const s = JSON.parse(raw);
-    if (!s || typeof s !== "object") {
-      return { reason: "state_file_corrupt", modelWindowSize: 0 };
-    }
-    const window = Number.isInteger(s.modelWindowSize) ? s.modelWindowSize : 0;
-    if (s.lastError && typeof s.lastError === "object" && typeof s.lastError.code === "string") {
-      return { reason: `meter_error:${s.lastError.code}`, modelWindowSize: window };
-    }
-    if (!s.timestamp) {
-      return { reason: "meter_never_measured", modelWindowSize: window };
-    }
-    const age = Date.now() - Date.parse(s.timestamp);
-    if (isNaN(age) || age < 0 || age > STATE_STALE_MS) {
-      return { reason: "meter_state_stale", modelWindowSize: window };
-    }
-    return null;
+    const c = JSON.parse(raw);
+    const pct = Number(c.thresholdPct);
+    if (Number.isFinite(pct) && pct > 0 && pct < 100) return pct;
   } catch (_) {
-    return { reason: "state_file_unreadable", modelWindowSize: 0 };
+    /* fall through */
   }
+  return DEFAULT_THRESHOLD_PCT;
 }
 
-function getSessionStatusHeuristic(dir) {
+function getSessionStatusHeuristic(dir, thresholdPct) {
   const window = 200000;
   const consumed = readSessionConsumed(dir);
   const estimated_remaining = Math.max(0, window - consumed);
   const pct = window > 0 ? Math.round((consumed / window) * 100 * 10) / 10 : 0;
-  const threshold = resolveThreshold(pct);
+  const threshold = bandFor(pct, thresholdPct);
   return { consumed, estimated_remaining, pct, threshold };
 }
 
@@ -205,22 +171,6 @@ function recordUsage(usage) {
   fs.appendFileSync(fp, line);
 }
 
-// ── getDegradationActions (v3.0.0 — three-band) ─────────────────────────────
-
-/**
- * v3.0.0 three-band response. The name is preserved for caller-identification
- * convenience; the return shape is a CLEAN BREAK from v2.0.0 — no
- * `modelOverrides`, no `actions` list, no `skipPhases`, no `checkpoint`
- * side-channel. Callers that relied on those fields MUST be updated.
- *
- * @param {string} [projectDir]
- * @returns {{ band: 'normal'|'warn'|'stop', pct: number, message: string }}
- */
-function getDegradationActions(projectDir) {
-  const { threshold, pct } = getSessionStatus(projectDir);
-  return buildBandResponse(threshold, pct);
-}
-
 // ── estimateMilestoneCost ─────────────────────────────────────────────────────
 
 /**
@@ -239,44 +189,11 @@ function estimateMilestoneCost(remainingTasks, projectDir) {
   return { estimatedTokens, estimatedPct, feasible };
 }
 
-// ── Internal: threshold resolution (v3.0.0 — three-band) ─────────────────────
+// ── Internal: single-band resolution ─────────────────────────────────────────
 
-function resolveThreshold(pct) {
+function bandFor(pct, thresholdPct) {
   if (!Number.isFinite(pct)) return "normal";
-  if (pct >= THRESHOLDS.stop) return "stop";
-  if (pct >= THRESHOLDS.warn) return "warn";
-  return "normal";
-}
-
-function buildBandResponse(band, pct) {
-  const safePct = Number.isFinite(pct) ? pct : 0;
-  switch (band) {
-    case "warn":
-      return {
-        band: "warn",
-        pct: safePct,
-        message: `Context ${safePct.toFixed(1)}% — warn band (≥${WARN_THRESHOLD_PCT}%). Informational only; proceed.`,
-      };
-    case "stop":
-      return {
-        band: "stop",
-        pct: safePct,
-        message: `Context ${safePct.toFixed(1)}% — stop band (≥${STOP_THRESHOLD_PCT}%). Halt cleanly; hand off to runway estimator / headless auto-spawn.`,
-      };
-    case "stale":
-      return {
-        band: "stale",
-        pct: safePct,
-        message: `Context meter is DEAD — no fresh measurements. Gate treats this as STOP. Run: gsd-t doctor. Fix the cause (usually missing ANTHROPIC_API_KEY) before running gated commands.`,
-      };
-    case "normal":
-    default:
-      return {
-        band: "normal",
-        pct: safePct,
-        message: `Context ${safePct.toFixed(1)}% — normal band. Proceed.`,
-      };
-  }
+  return pct >= thresholdPct ? "threshold" : "normal";
 }
 
 // ── Internal: token-log parsing ───────────────────────────────────────────────