@tekyzinc/gsd-t 3.10.16 → 3.11.10

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [3.11.10] - 2026-04-16
+
+### Added — Universal Context Auto-Pause (M37)
+
+**Background**: The Context Meter (M34) correctly measures context window usage and emits an `additionalContext` signal at the configured threshold (default 75%). However, Claude consistently ignores the single-line suggestion format, continuing to work until hitting the runtime's ~95% `/compact` wall — which destroys context silently and loses work.
+
+### Changed
+- **`scripts/context-meter/threshold.js`** — `buildAdditionalContext()` now returns a 6-line MANDATORY STOP instruction instead of a single-line suggestion. The message starts with `🛑 MANDATORY STOP` and includes step-by-step instructions (pause → clear → resume) with explicit reference to the Destructive Action Guard enforcement weight.
+- **`.gsd-t/contracts/context-meter-contract.md`** — bumped to v1.2.0. New §"Universal Auto-Pause Rule" documents the mandatory behavioral requirement. Rule #8 added: `additionalContext` is a MANDATORY STOP signal with Destructive Action Guard enforcement weight.
+- **`templates/CLAUDE-global.md`** — new `## Universal Auto-Pause Rule (MANDATORY)` section added between Context Meter and API Documentation Guard sections. Same enforcement weight as the Destructive Action Guard.
+- **5 loop command files** (`gsd-t-execute`, `gsd-t-wave`, `gsd-t-integrate`, `gsd-t-quick`, `gsd-t-debug`) — Step 0.2 added: Universal Auto-Pause Rule enforcement. If `🛑 MANDATORY STOP` appears in `additionalContext` at any point, immediately halt, pause, and instruct clear+resume.
+- **Tests**: All 1228 tests pass (1224 unit + 4 e2e). `threshold.test.js` and `gsd-t-context-meter.e2e.test.js` updated for new multi-line format.
+
 ## [3.10.16] - 2026-04-15
 
 ### Fixed — unattended supervisor launch friction (3 bugs + UX improvements)

package/README.md

@@ -338,7 +338,7 @@ gsd-t unattended --hours=24
 **How it works:**
 
 - `gsd-t unattended` spawns `bin/gsd-t-unattended.js` as a fully detached OS process. The supervisor runs `claude -p` workers in a relay — one worker per iteration — each in a fresh context window. State is written atomically to `.gsd-t/.unattended/state.json` between iterations.
-- `/user:gsd-t-unattended` does the same from inside Claude Code, then calls `ScheduleWakeup(270, '/user:gsd-t-unattended-watch')` to start an in-session watch loop that ticks every 270 seconds and prints progress.
+- `/user:gsd-t-unattended` does the same from inside Claude Code, then calls `ScheduleWakeup(270, '/gsd-t-unattended-watch')` to start an in-session watch loop that ticks every 270 seconds and prints progress.
 - If you run `/clear` + `/user:gsd-t-resume` during a live run, the resume command auto-detects the running supervisor and re-attaches the watch loop — no re-launch needed.
 - The supervisor halts automatically when: the milestone reaches COMPLETED status, the `--hours` wall-clock cap expires, `--max-iterations` is reached, safety rails detect a stall or unrecoverable error, or the stop sentinel is touched.
 

package/bin/gsd-t-unattended-platform.cjs

@@ -178,8 +178,8 @@ function spawnWorker(projectDir, timeoutMs, opts = {}) {
  * state file, and relays `claude -p` workers until the milestone terminates.
  *
  * Spawn recipe:
- *   - `node {binPath} {...args}` — binPath should be the absolute path to
- *     `bin/gsd-t-unattended.cjs` (the supervisor entry point), NOT gsd-t.js.
+ *   - `node {binPath} unattended {...args}` — the `unattended` subcommand is
+ *     prepended automatically so callers pass only user-facing args.
  *   - `detached: true` — the child becomes a process-group leader on POSIX
  *     (darwin/linux) so it survives the parent closing its terminal. On win32
  *     the equivalent flag produces a separate process tree.
@@ -194,13 +194,13 @@ function spawnWorker(projectDir, timeoutMs, opts = {}) {
  *     `docs/unattended-windows-caveats.md` (Task 3).
  *
  * @param {object} params
- * @param {string} params.binPath  Absolute path to `bin/gsd-t-unattended.cjs`.
- * @param {string[]} params.args   CLI args passed directly to the supervisor.
+ * @param {string} params.binPath  Absolute path to `bin/gsd-t.js`.
+ * @param {string[]} params.args   Extra args appended after `unattended`.
  * @param {string} params.cwd      Project directory (supervisor's cwd).
  * @returns {{ pid: number }}      The detached child's PID.
  */
 function spawnSupervisor({ binPath, args, cwd }) {
-  const spawnArgs = [binPath, ...(args || [])];
+  const spawnArgs = [binPath, "unattended", ...(args || [])];
   const opts = {
     cwd,
     detached: true,

package/bin/gsd-t-unattended-safety.cjs

@@ -151,27 +151,6 @@ function loadConfig(projectDir) {
   return merged;
 }
 
-// ── saveConfig ─────────────────────────────────────────────────────────────
-//
-// Persists the given config object back to `.gsd-t/.unattended/config.json`.
-// Creates the directory if missing. Used by auto-whitelist to remember newly
-// whitelisted dirty-tree entries so subsequent launches don't re-warn.
-
-function saveConfig(projectDir, config) {
-  const configDir = path.join(projectDir, ".gsd-t", ".unattended");
-  const configPath = path.join(configDir, "config.json");
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
-  }
-  const serializable = {};
-  for (const key of Object.keys(DEFAULTS)) {
-    if (config[key] !== undefined) {
-      serializable[key] = config[key];
-    }
-  }
-  fs.writeFileSync(configPath, JSON.stringify(serializable, null, 2) + "\n");
-}
-
 // ── checkGitBranch ──────────────────────────────────────────────────────────
 //
 // Runs `git branch --show-current` in projectDir. An empty result indicates
@@ -766,7 +745,6 @@ function detectBlockerSentinel(runLogTail) {
 module.exports = {
   DEFAULTS,
   loadConfig,
-  saveConfig,
   checkGitBranch,
   checkWorktreeCleanliness,
   checkIterationCap,

package/bin/gsd-t-unattended.cjs

@@ -35,7 +35,6 @@ const { mapHeadlessExitCode } = require("./gsd-t.js");
 const {
   DEFAULTS: SAFETY_DEFAULTS,
   loadConfig,
-  saveConfig,
   checkGitBranch,
   checkWorktreeCleanliness,
   checkIterationCap,
@@ -494,7 +493,6 @@ function doUnattended(argv, deps) {
     releaseSleep: deps._releaseSleep || releaseSleep,
     notify: deps._notify || notify,
     loadConfig: deps._loadConfig || loadConfig,
-    saveConfig: deps._saveConfig || saveConfig,
   };
 
   // ── Load config (optional .gsd-t/.unattended/config.json) ────────────────
@@ -551,23 +549,7 @@ function doUnattended(argv, deps) {
     };
   }
   const treeRes = fn.checkWorktreeCleanliness(projectDir, config);
-  if (!treeRes.ok && treeRes.dirtyFiles && treeRes.dirtyFiles.length > 0) {
-    // Auto-whitelist: add the dirty files to the config and persist, then
-    // proceed instead of refusing. This keeps unattended launch frictionless.
-    for (const file of treeRes.dirtyFiles) {
-      if (!config.dirtyTreeWhitelist.includes(file)) {
-        config.dirtyTreeWhitelist.push(file);
-      }
-    }
-    try {
-      fn.saveConfig(projectDir, config);
-    } catch (_) { /* best effort — config dir may not exist yet */ }
-    // eslint-disable-next-line no-console
-    console.error(
-      `[gsd-t-unattended] auto-whitelisted ${treeRes.dirtyFiles.length} dirty file(s): ${treeRes.dirtyFiles.slice(0, 5).join(", ")}${treeRes.dirtyFiles.length > 5 ? ", …" : ""}`,
-    );
-  } else if (!treeRes.ok) {
-    // Non-file failure (e.g. git error) — still refuse.
+  if (!treeRes.ok) {
     // eslint-disable-next-line no-console
     console.error(
       `[gsd-t-unattended] preflight-refusal: ${treeRes.reason || "dirty worktree"}`,
@@ -1005,9 +987,15 @@ function runMainLoop(state, dir, opts, deps, ctx) {
  */
 function _spawnWorker(state, opts) {
   const bin = (state && state.claudeBin) || resolveClaudePath();
+  const workerEnv = { ...process.env, GSD_T_UNATTENDED_WORKER: "1" };
   const res = platformSpawnWorker(opts.cwd, opts.timeout, {
     bin,
-    args: ["-p", "/gsd-t-resume"],
+    args: [
+      "-p",
+      "You are an unattended worker iteration. CRITICAL: Do NOT check supervisor.pid, do NOT auto-reattach to a watch loop, do NOT schedule any ScheduleWakeup. You ARE the worker spawned by the supervisor. Skip Step 0 (auto-reattach) entirely and go directly to Step 0.1. Run /gsd-t-resume but skip the unattended supervisor auto-reattach check in Step 0.",
+      "--dangerously-skip-permissions",
+    ],
+    env: workerEnv,
   });
   return {
     status: typeof res.status === "number" ? res.status : null,

package/commands/gsd-t-debug.md

@@ -65,6 +65,16 @@ If `can_start === false`, the headless continuation has been spawned and the int
 
 **Contract**: `.gsd-t/contracts/runway-estimator-contract.md` v1.0.0; stop threshold (85%) mirrors `.gsd-t/contracts/token-budget-contract.md` v3.0.0.
 
+## Step 0.2: Universal Auto-Pause Rule (MANDATORY — context-meter-contract v1.2.0, M37)
+
+**If at ANY point during this command you see a `🛑 MANDATORY STOP` message in `additionalContext` (delivered by the Context Meter PostToolUse hook), you MUST:**
+1. Immediately stop all work — do NOT continue debugging, do NOT spawn the next subagent
+2. Run `/user:gsd-t-pause` to save exact position
+3. Tell the user to run `/clear` then `/user:gsd-t-resume`
+4. STOP — do not continue
+
+This has the same enforcement weight as the Destructive Action Guard. The signal means the context window is at or above the configured threshold (default 75%) and continuing risks hitting the runtime's ~95% `/compact` wall.
+
 ## Step 0.1: Launch via Subagent
 
 To give this debug session a fresh context window and prevent compaction, always execute via a Task subagent.

package/commands/gsd-t-execute.md

@@ -83,6 +83,16 @@ Use the returned `threshold` as the gate signal for the rest of this run. The ga
 
 Why: every `/user:gsd-t-execute` invocation is a fresh orchestrator session and needs a current reading of context utilization before spawning any subagents. The authoritative source is the Context Meter state file; the fallback keeps the gate functional on projects that haven't installed the hook yet.
 
+## Step 0.2: Universal Auto-Pause Rule (MANDATORY — context-meter-contract v1.2.0, M37)
+
+**If at ANY point during this command you see a `🛑 MANDATORY STOP` message in `additionalContext` (delivered by the Context Meter PostToolUse hook), you MUST:**
+1. Immediately stop all work — do NOT finish the current task, do NOT spawn the next subagent
+2. Run `/user:gsd-t-pause` to save exact position
+3. Tell the user to run `/clear` then `/user:gsd-t-resume`
+4. STOP — do not continue
+
+This has the same enforcement weight as the Destructive Action Guard. The signal means the context window is at or above the configured threshold (default 75%) and continuing risks hitting the runtime's ~95% `/compact` wall.
+
 ## Step 1: Load State
 
 Read:

package/commands/gsd-t-integrate.md

@@ -65,6 +65,16 @@ If `can_start === false`, the headless continuation has been spawned and the int
 
 **Contract**: `.gsd-t/contracts/runway-estimator-contract.md` v1.0.0; stop threshold (85%) mirrors `.gsd-t/contracts/token-budget-contract.md` v3.0.0.
 
+## Step 0.2: Universal Auto-Pause Rule (MANDATORY — context-meter-contract v1.2.0, M37)
+
+**If at ANY point during this command you see a `🛑 MANDATORY STOP` message in `additionalContext` (delivered by the Context Meter PostToolUse hook), you MUST:**
+1. Immediately stop all work — do NOT continue integration, do NOT spawn the next subagent
+2. Run `/user:gsd-t-pause` to save exact position
+3. Tell the user to run `/clear` then `/user:gsd-t-resume`
+4. STOP — do not continue
+
+This has the same enforcement weight as the Destructive Action Guard. The signal means the context window is at or above the configured threshold (default 75%) and continuing risks hitting the runtime's ~95% `/compact` wall.
+
 ## Step 1: Load Full State
 
 Read everything:

package/commands/gsd-t-quick.md

@@ -65,6 +65,16 @@ If `can_start === false`, the headless continuation has been spawned and the int
 
 **Contract**: `.gsd-t/contracts/runway-estimator-contract.md` v1.0.0; stop threshold (85%) mirrors `.gsd-t/contracts/token-budget-contract.md` v3.0.0.
 
+## Step 0.2: Universal Auto-Pause Rule (MANDATORY — context-meter-contract v1.2.0, M37)
+
+**If at ANY point during this command you see a `🛑 MANDATORY STOP` message in `additionalContext` (delivered by the Context Meter PostToolUse hook), you MUST:**
+1. Immediately stop all work — do NOT continue the task, do NOT spawn the next subagent
+2. Run `/user:gsd-t-pause` to save exact position
+3. Tell the user to run `/clear` then `/user:gsd-t-resume`
+4. STOP — do not continue
+
+This has the same enforcement weight as the Destructive Action Guard. The signal means the context window is at or above the configured threshold (default 75%) and continuing risks hitting the runtime's ~95% `/compact` wall.
+
 ## Step 0.1: Launch via Subagent
 
 To give this task a fresh context window and prevent compaction during consecutive quick runs, always execute via a Task subagent.

package/commands/gsd-t-resume.md

@@ -6,6 +6,8 @@ You are resuming work after an interruption. This handles both same-session paus
 
 **This step runs FIRST, before reading any docs, contracts, or continue-here files.**
 
+**Worker bypass**: If the environment variable `GSD_T_UNATTENDED_WORKER=1` is set, this resume is being invoked by the unattended supervisor as a worker iteration. **SKIP this entire Step 0** — do NOT check for supervisor.pid, do NOT auto-reattach, do NOT schedule a watch tick. Fall through directly to Step 0.1. The worker's job is to do actual work, not watch itself.
+
 Check whether an unattended supervisor is actively running for this project:
 
 1. Check if `.gsd-t/.unattended/supervisor.pid` exists.
@@ -22,7 +24,7 @@ Check whether an unattended supervisor is actively running for this project:
    - **Terminal status** (`done`, `failed`, `stopped`, `crashed`) → the supervisor has finished and is waiting for cleanup. Fall through to Step 0.1 so normal resume flow runs (it will see progress.md state and continue from where the supervisor left off).
    - **Non-terminal status** (`initializing`, `running`, or any unrecognized value) → **AUTO-REATTACH**:
      - Print the current watch status using the data in `state.json` (elapsed time, current iteration, milestone/wave/task, last worker exit code).
-     - Call `ScheduleWakeup(270, '/user:gsd-t-unattended-watch', reason='resumed watch')`.
+     - Call `ScheduleWakeup(270, '/gsd-t-unattended-watch', reason='resumed watch')`.
      - **STOP reading resume.md entirely. Do NOT proceed to Step 0.1 or any later step. Do NOT read docs, contracts, or continue-here files. Do NOT display a headless read-back banner.** The watcher will display the live status block and re-schedule itself. Return now.
 
 Contract reference: `unattended-supervisor-contract.md` §9 (Resume Auto-Reattach Handshake)

package/commands/gsd-t-unattended-stop.md

@@ -66,14 +66,16 @@ This is race-free, terminal-close-safe, and language-agnostic (per contract §10
 Output the confirmation block:
 
 ```
-🛑  Stop sentinel written. Supervisor will halt between next worker iterations (within ~5 minutes). State file will finalize with status=stopped.
+🛑  Stop sentinel written. Supervisor will halt after the current worker finishes (up to ~5 min).
 
    Session: {SESSION from Step 3}
    Iter:    {ITER from Step 3}
    Status:  {STATUS from Step 3}
 
-   The current worker will run to completion (up to ~1h). Stop is honored at the next pre-worker checkpoint.
-   No kill signal is sent — this is a clean cooperative halt.
+   The current worker runs to completion. Stop is honored at the next pre-worker checkpoint.
+   The watch loop (if running) will detect status=stopped on its next tick and stop itself.
+   If a watch tick fires before the supervisor processes the sentinel, it may reschedule once
+   more — this is expected. It will catch the terminal status on the following tick.
 ```
 
 ## Step 6: Return Immediately

package/commands/gsd-t-unattended-watch.md

@@ -20,7 +20,7 @@ See `unattended-supervisor-contract.md` §8 (Watch Tick Decision Tree), §4 (Sta
      - failed                      → failure summary,  STOP
      - stopped                     → user-stop confirm, STOP
      - initializing | running      → render watch block, go to 4
-4. ScheduleWakeup(270, '/user:gsd-t-unattended-watch', reason='unattended tick {iter}')
+4. ScheduleWakeup(270, '/gsd-t-unattended-watch', reason='unattended tick {iter}')
 ```
 
 **Critical**: Every branch except `initializing`/`running` is TERMINAL — do NOT reschedule. When you reach a terminal state, print the report and end the turn. Do not add a "Next Up" block — this is a self-rescheduling loop, not a phase workflow.
@@ -126,6 +126,72 @@ const last50 = tailLines.slice(-50);
 const last1 = tailLines.length > 0 ? tailLines[tailLines.length - 1] : '';
 out('LOG_TAIL_LAST1', last1);
 out('LOG_TAIL_LAST50', last50.join('\n'));
+
+// --- workflow progress from progress.md and domain task files ---
+let phase = 'unknown';
+let waveInfo = '';
+let waveCurrent = 0;
+let waveTotal = 0;
+let tasksDone = 0;
+let tasksTotal = 0;
+let domainSummary = [];
+try {
+  const prog = fs.readFileSync('.gsd-t/progress.md', 'utf8');
+  // Extract phase from Status line
+  const statusM = prog.match(/^## Status:.*?(\b(?:DEFINED|PARTITIONED|PLANNED|EXECUTING|EXECUTED|INTEGRATING|VERIFYING|VERIFIED|COMPLETE|IN.PROGRESS)\b)/mi);
+  if (statusM) phase = statusM[1].trim();
+  // Extract "Wave N of M" or latest "Wave N" from Decision Log
+  const waveOfM = prog.match(/Wave\s+(\d+)\s+(?:of|\/)\s+(\d+)/gi);
+  if (waveOfM && waveOfM.length > 0) {
+    const last = waveOfM[waveOfM.length - 1];
+    const parts = last.match(/(\d+)\s+(?:of|\/)\s+(\d+)/);
+    if (parts) { waveCurrent = parseInt(parts[1], 10); waveTotal = parseInt(parts[2], 10); }
+  } else {
+    const waveM = prog.match(/Wave\s+(\d+)/gi);
+    if (waveM && waveM.length > 0) {
+      const last = waveM[waveM.length - 1].match(/(\d+)/);
+      if (last) waveCurrent = parseInt(last[1], 10);
+    }
+  }
+} catch (_) {}
+
+// Read domain task files for completion counts and wave totals
+try {
+  const domainsDir = '.gsd-t/domains';
+  if (fs.existsSync(domainsDir)) {
+    const domains = fs.readdirSync(domainsDir).filter(d => {
+      try { return fs.statSync(path.join(domainsDir, d)).isDirectory(); } catch (_) { return false; }
+    });
+    let maxWave = 0;
+    for (const d of domains) {
+      const tasksFile = path.join(domainsDir, d, 'tasks.md');
+      if (!fs.existsSync(tasksFile)) continue;
+      const txt = fs.readFileSync(tasksFile, 'utf8');
+      const lines = txt.split('\n');
+      let done = 0, total = 0;
+      for (const line of lines) {
+        // Count wave headers to determine total waves
+        const wH = line.match(/^#+\s*Wave\s+(\d+)/i);
+        if (wH) { const w = parseInt(wH[1], 10); if (w > maxWave) maxWave = w; }
+        if (/^[-*]\s*\[x\]/i.test(line)) { done++; total++; }
+        else if (/^[-*]\s*\[\s?\]/.test(line)) { total++; }
+      }
+      if (total > 0) {
+        tasksDone += done;
+        tasksTotal += total;
+        domainSummary.push(d + ':' + done + '/' + total);
+      }
+    }
+    if (maxWave > 0 && waveTotal === 0) waveTotal = maxWave;
+  }
+} catch (_) {}
+if (waveCurrent > 0 && waveTotal > 0) waveInfo = 'Wave ' + waveCurrent + ' of ' + waveTotal;
+else if (waveCurrent > 0) waveInfo = 'Wave ' + waveCurrent;
+out('PHASE', phase);
+out('WAVE_INFO', waveInfo);
+out('TASKS_DONE', tasksDone);
+out('TASKS_TOTAL', tasksTotal);
+out('DOMAIN_SUMMARY', domainSummary.join(' | '));
 "
 ```
 
@@ -239,23 +305,31 @@ The supervisor is still alive but has transitioned to a terminal status on its l
 
 If `PID_FILE_EXISTS=true` AND `ALIVE=true` AND `STATUS` is `initializing` or `running`:
 
-Render the compact watch block below. Format rules:
+Render the enriched watch block below. The key insight: users need **workflow progress** (phase, wave, tasks done/remaining), not just supervisor mechanics (iter, PID, exit code).
+
+Format rules:
 - One extra space after each emoji (per CLAUDE.md markdown table rules — preserves alignment in terminal views).
 - Elapsed formatted as `{H}h{M}m` from `ELAPSED_MS`.
-- Last-tick age formatted as `{S}s` or `{M}m{S}s`. If age > 540s (2× tick cadence), append ` ⚠️  stale` as a soft warning (not a crash — per contract §3 write semantics).
-- `LAST_EXIT` duration from `LAST_ELAPSED_MS` rendered as seconds.
-- Wave/task lines are omitted when absent from state.
-- Last non-empty `run.log` line is truncated to 80 chars.
+- Last-tick age formatted as `{S}s` or `{M}m{S}s`. If age > 540s (2× tick cadence), append ` ⚠️  stale` as a soft warning.
+- Tasks progress bar: `[████████░░░░] 8/12` — filled blocks proportional to done/total.
+- Domain breakdown only shown if ≤6 domains (otherwise too noisy).
 
 ```
-⚙  Unattended — {MILESTONE}{ Wave {WAVE}}{ · Task {TASK}}
-⏱  Iter {ITER} / {MAX_ITER} · elapsed {Hh Mm} · last tick {tickAge}
-📊  Last exit: {LAST_EXIT} ({durationSec}s) · PID {PID} · session {SESSION}
-📝  {truncated last log line or "(no output yet)"}
+⚙  Unattended — {MILESTONE} · {PHASE}{ · {WAVE_INFO}}
+📋  Tasks: {TASKS_DONE}/{TASKS_TOTAL} [{progress bar}] · elapsed {Hh Mm}
+🔧  {DOMAIN_SUMMARY or "No domains yet (pre-partition)"}
+⏱  Iter {ITER}/{MAX_ITER} · last tick {tickAge} · last exit {LAST_EXIT} ({durationSec}s)
 ⏰  Next tick in 270s · Stop: /user:gsd-t-unattended-stop
 ```
 
-(5 lines — the contract §8 format allows up to 10. Keep it tight.)
+Progress bar rendering (8 chars wide):
+- If `TASKS_TOTAL > 0`: filled = round(TASKS_DONE / TASKS_TOTAL * 8), empty = 8 - filled. Use `█` for filled, `░` for empty.
+- If `TASKS_TOTAL == 0`: show `[░░░░░░░░]` (pre-partition, no tasks yet).
+
+Domain summary formatting:
+- Each domain: `{name}: {done}/{total}` separated by ` | `
+- If domains > 6, show top 3 incomplete + "... +{N} more"
+- If no domains exist, show phase-appropriate message: "Partitioning..." / "Planning..." / "No domains yet"
 
 ## Step 7: Reschedule via ScheduleWakeup (Non-Terminal Only)
 
@@ -264,7 +338,7 @@ Render the compact watch block below. Format rules:
 Call the harness `ScheduleWakeup` tool with these exact parameters:
 
 - `delaySeconds`: `270` (fixed — inside the 5-minute prompt-cache TTL)
-- `prompt`: `/user:gsd-t-unattended-watch`
+- `prompt`: `/gsd-t-unattended-watch`
 - `reason`: `unattended tick {ITER}` — substituting the integer `ITER` from Step 2
 
 Tool invocation pattern (make this real tool call, not a bash command):
@@ -272,7 +346,7 @@ Tool invocation pattern (make this real tool call, not a bash command):
 ```
 ScheduleWakeup(
   delaySeconds: 270,
-  prompt: "/user:gsd-t-unattended-watch",
+  prompt: "/gsd-t-unattended-watch",
   reason: "unattended tick {ITER}"
 )
 ```

package/commands/gsd-t-unattended.md

@@ -424,7 +424,7 @@ Print the launch confirmation block:
 Call the harness `ScheduleWakeup` tool with these exact parameters:
 
 - `delaySeconds`: `270` (fixed — inside the 5-minute prompt-cache TTL)
-- `prompt`: `/user:gsd-t-unattended-watch`
+- `prompt`: `/gsd-t-unattended-watch`
 - `reason`: `first unattended tick`
 
 Tool invocation pattern (make this a real tool call, not a bash command):
@@ -432,7 +432,7 @@ Tool invocation pattern (make this a real tool call, not a bash command):
 ```
 ScheduleWakeup(
   delaySeconds: 270,
-  prompt: "/user:gsd-t-unattended-watch",
+  prompt: "/gsd-t-unattended-watch",
   reason: "first unattended tick"
 )
 ```

package/commands/gsd-t-wave.md

@@ -74,6 +74,16 @@ node -e "const tb = require('./bin/token-budget.cjs'); const s = tb.getSessionSt
 
 This calls `getSessionStatus()` (v2.0.0) which reads `.gsd-t/.context-meter-state.json` produced by the Context Meter PostToolUse hook. The returned `threshold` drives the gate logic in the Phase Agent Spawn Pattern below — it enforces the three-band stop boundary (85%) so the wave orchestrator itself never runs out of context mid-wave. When the state file is absent or stale, the call falls back to a historical heuristic from `.gsd-t/token-log.md`. Band boundaries and `modelWindowSize` are configured in `.gsd-t/context-meter-config.json` and `bin/token-budget.cjs` (THRESHOLDS constant).
 
+## Step 0.2: Universal Auto-Pause Rule (MANDATORY — context-meter-contract v1.2.0, M37)
+
+**If at ANY point during this command you see a `🛑 MANDATORY STOP` message in `additionalContext` (delivered by the Context Meter PostToolUse hook), you MUST:**
+1. Immediately stop all work — do NOT advance to the next phase, do NOT spawn the next subagent
+2. Run `/user:gsd-t-pause` to save exact position
+3. Tell the user to run `/clear` then `/user:gsd-t-resume`
+4. STOP — do not continue
+
+This has the same enforcement weight as the Destructive Action Guard. The signal means the context window is at or above the configured threshold (default 75%) and continuing risks hitting the runtime's ~95% `/compact` wall.
+
 ## Step 1: Load State (Lightweight)
 
 Read ONLY:

package/docs/architecture.md

@@ -345,7 +345,7 @@ Closes the M35 parent/child race in `bin/headless-auto-spawn.js`. When the runwa
 
 ### Resume Auto-Reattach
 
-`/user:gsd-t-resume` Step 0 checks for a live supervisor before any other resume logic. If `supervisor.pid` exists and `kill -0` succeeds and `state.json.status` is non-terminal, the resume command skips normal resume flow entirely, prints the current watch block, and calls `ScheduleWakeup(270, '/user:gsd-t-unattended-watch', ...)`. The user transparently re-enters the watch loop without any manual step.
+`/user:gsd-t-resume` Step 0 checks for a live supervisor before any other resume logic. If `supervisor.pid` exists and `kill -0` succeeds and `state.json.status` is non-terminal, the resume command skips normal resume flow entirely, prints the current watch block, and calls `ScheduleWakeup(270, '/gsd-t-unattended-watch', ...)`. The user transparently re-enters the watch loop without any manual step.
 
 ---
 

package/docs/requirements.md

@@ -287,9 +287,9 @@
 
 **M36 Functional Requirements:**
 - **REQ-079**: `bin/gsd-t-unattended.js` implements the supervisor relay loop: spawn worker → await exit → post-worker safety check → next iter. State written atomically to `.gsd-t/.unattended/state.json`. Contract: `unattended-supervisor-contract.md` v1.0.0.
-- **REQ-080**: `commands/gsd-t-unattended.md` pre-flights branch + dirty tree, spawns supervisor detached, polls for PID readiness, displays initial watch block, and calls `ScheduleWakeup(270, '/user:gsd-t-unattended-watch')`.
+- **REQ-080**: `commands/gsd-t-unattended.md` pre-flights branch + dirty tree, spawns supervisor detached, polls for PID readiness, displays initial watch block, and calls `ScheduleWakeup(270, '/gsd-t-unattended-watch')`.
 - **REQ-081**: `commands/gsd-t-unattended-watch.md` implements the watch tick decision tree (§8 of contract): reads PID → liveness probe → reads state.json → reschedule or terminal report.
-- **REQ-082**: `commands/gsd-t-resume.md` Step 0 checks `supervisor.pid` before any other resume logic. If live + non-terminal: skip normal resume, print watch block, call `ScheduleWakeup(270, '/user:gsd-t-unattended-watch')`.
+- **REQ-082**: `commands/gsd-t-resume.md` Step 0 checks `supervisor.pid` before any other resume logic. If live + non-terminal: skip normal resume, print watch block, call `ScheduleWakeup(270, '/gsd-t-unattended-watch')`.
 - **REQ-083**: Supervisor relay architecture ensures each worker gets a fresh context window. No compaction state carries over between workers — only `.gsd-t/` milestone state files.
 - **REQ-084**: `bin/gsd-t-unattended-safety.js` exports: `checkGitBranch`, `checkWorktreeCleanliness`, `validateState`, `checkIterationCap`, `checkWallClockCap`, `detectBlockerSentinel`, `detectGutter`. Called at all 4 supervisor hook points.
 - **REQ-085**: `bin/gsd-t-unattended-platform.js` exports: `spawnSupervisor`, `preventSleep`, `releaseSleep`, `notify`, `resolveClaudePath`. Windows: `preventSleep` is a documented no-op. Windows caveats documented in `docs/unattended-windows-caveats.md`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "3.10.16",
+  "version": "3.11.10",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 61 slash commands with unattended supervisor relay, 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",

package/scripts/context-meter/threshold.js

@@ -71,8 +71,9 @@ function bandFor(pct) {
  * Build the `additionalContext` string the hook emits, or null if the
  * measured percentage is below the configured thresholdPct.
  *
- * Exact format (from .gsd-t/contracts/context-meter-contract.md line 139):
- *   ⚠️ Context window at {pct.toFixed(1)}% of {modelWindowSize}. Run /user:gsd-t-pause to checkpoint and clear before continuing.
+ * M37 (v1.2.0): This is a MANDATORY STOP instruction, not a suggestion.
+ * The multi-line format is designed to be unignorable — same enforcement
+ * weight as the Destructive Action Guard.
  *
  * `modelWindowSize` is emitted as the raw integer — no commas, no "K" suffix.
  *
@@ -82,7 +83,14 @@ function bandFor(pct) {
 function buildAdditionalContext({ pct, modelWindowSize, thresholdPct } = {}) {
   if (!Number.isFinite(pct) || !Number.isFinite(thresholdPct)) return null;
   if (pct < thresholdPct) return null;
-  return `⚠️ Context window at ${pct.toFixed(1)}% of ${modelWindowSize}. Run /user:gsd-t-pause to checkpoint and clear before continuing.`;
+  return [
+    `🛑 MANDATORY STOP — Context window at ${pct.toFixed(1)}% of ${modelWindowSize} (threshold: ${thresholdPct}%).`,
+    `You MUST stop what you are doing RIGHT NOW and execute these steps in order:`,
+    `1. Run /user:gsd-t-pause to save your exact position`,
+    `2. Tell the user to run /clear to free the context window`,
+    `3. Tell the user to run /user:gsd-t-resume to continue from the saved position`,
+    `Do NOT continue working, spawn subagents, or start new tasks. This has the same enforcement weight as the Destructive Action Guard — violating it risks losing work to context overflow.`,
+  ].join("\n");
 }
 
 module.exports = { computePct, bandFor, buildAdditionalContext, BANDS };

package/scripts/context-meter/threshold.test.js

@@ -154,7 +154,7 @@ test("buildAdditionalContext — below threshold returns null", () => {
   );
 });
 
-test("buildAdditionalContext — at threshold returns string", () => {
+test("buildAdditionalContext — at threshold returns multi-line MANDATORY STOP", () => {
   const result = buildAdditionalContext({
     pct: 75,
     modelWindowSize: 200000,
@@ -162,18 +162,28 @@ test("buildAdditionalContext — at threshold returns string", () => {
   });
   assert.ok(typeof result === "string");
   assert.ok(result.includes("75.0%"));
+  assert.ok(result.includes("MANDATORY STOP"));
+  assert.ok(result.includes("/user:gsd-t-pause"));
+  assert.ok(result.includes("/clear"));
+  assert.ok(result.includes("/user:gsd-t-resume"));
+  assert.ok(result.includes("Destructive Action Guard"));
+  assert.ok(result.includes("\n"), "must be multi-line");
 });
 
-test("buildAdditionalContext — above threshold exact contract string", () => {
+test("buildAdditionalContext — above threshold exact contract string (M37 multi-line)", () => {
   const result = buildAdditionalContext({
     pct: 76.2,
     modelWindowSize: 200000,
     thresholdPct: 75,
   });
-  assert.equal(
-    result,
-    "⚠️ Context window at 76.2% of 200000. Run /user:gsd-t-pause to checkpoint and clear before continuing."
-  );
+  const lines = result.split("\n");
+  assert.equal(lines.length, 6, "must have exactly 6 lines");
+  assert.equal(lines[0], "🛑 MANDATORY STOP — Context window at 76.2% of 200000 (threshold: 75%).");
+  assert.equal(lines[1], "You MUST stop what you are doing RIGHT NOW and execute these steps in order:");
+  assert.equal(lines[2], "1. Run /user:gsd-t-pause to save your exact position");
+  assert.equal(lines[3], "2. Tell the user to run /clear to free the context window");
+  assert.equal(lines[4], "3. Tell the user to run /user:gsd-t-resume to continue from the saved position");
+  assert.ok(lines[5].includes("Destructive Action Guard"));
 });
 
 test("buildAdditionalContext — decimal formatting rounds via toFixed(1)", () => {
@@ -195,7 +205,7 @@ test("buildAdditionalContext — modelWindowSize emitted raw (no commas)", () =>
     modelWindowSize: 200000,
     thresholdPct: 75,
   });
-  assert.ok(result.includes("of 200000."));
+  assert.ok(result.includes("of 200000"));
   assert.ok(!result.includes("200,000"));
   assert.ok(!result.includes("200K"));
 });
@@ -228,6 +238,7 @@ test("buildAdditionalContext — zero pct vs zero threshold emits", () => {
   });
   assert.ok(typeof result === "string");
   assert.ok(result.includes("0.0%"));
+  assert.ok(result.includes("MANDATORY STOP"));
 });
 
 test("buildAdditionalContext — pct over 100% still formats correctly", () => {
@@ -236,10 +247,8 @@ test("buildAdditionalContext — pct over 100% still formats correctly", () => {
     modelWindowSize: 200000,
     thresholdPct: 75,
   });
-  assert.equal(
-    result,
-    "⚠️ Context window at 102.3% of 200000. Run /user:gsd-t-pause to checkpoint and clear before continuing."
-  );
+  assert.ok(result.startsWith("🛑 MANDATORY STOP — Context window at 102.3% of 200000"));
+  assert.ok(result.includes("MANDATORY STOP"));
 });
 
 test("buildAdditionalContext — different modelWindowSize (1M)", () => {
@@ -248,8 +257,6 @@ test("buildAdditionalContext — different modelWindowSize (1M)", () => {
     modelWindowSize: 1000000,
     thresholdPct: 75,
   });
-  assert.equal(
-    result,
-    "⚠️ Context window at 80.0% of 1000000. Run /user:gsd-t-pause to checkpoint and clear before continuing."
-  );
+  assert.ok(result.startsWith("🛑 MANDATORY STOP — Context window at 80.0% of 1000000"));
+  assert.ok(result.includes("threshold: 75%"));
 });