@tekyzinc/gsd-t 3.10.15 → 3.11.10

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 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)
+
+**Background**: Users consistently failed to launch unattended sessions due to compounding pre-flight friction: the supervisor spawn targeted the wrong binary, the dirty-tree check refused on benign files, and missing milestone state caused hard refusals. These issues defeated the purpose of "unattended" mode.
+
+### Changed
+- **`bin/gsd-t-unattended-platform.{js,cjs}`** — `spawnSupervisor()` no longer prepends `"unattended"` as a subcommand. `binPath` now points to `bin/gsd-t-unattended.cjs` (the actual supervisor entry) instead of `bin/gsd-t.js` (which has no `unattended` subcommand and printed "Unknown command" on every launch).
+- **`bin/gsd-t-unattended.{js,cjs}`** — dirty worktree check changed from **refuse** to **auto-whitelist**. Non-whitelisted dirty files are automatically added to `.gsd-t/.unattended/config.json` and the supervisor proceeds. Only genuine git errors (not a repo, etc.) still refuse. Import of `saveConfig` added.
+- **`bin/gsd-t-unattended-safety.{js,cjs}`** — added `saveConfig(projectDir, config)` function to persist auto-whitelisted entries back to the config file. Exported for use by supervisor and tests.
+- **`bin/gsd-t.js`** `updateSingleProject()` — now calls `ensureUnattendedConfig()` (creates `.gsd-t/.unattended/config.json` with all defaults) and `ensureUnattendedGitignore()` (adds `bin/*.cjs`, `.gsd-t/.archive-migration-v1`, `.gsd-t/.task-counter-retired-v1` to `.gitignore`).
+- **`commands/gsd-t-unattended.md`** — Step 1c.1 "Readiness Bootstrap": if no active milestone found, auto-bootstraps from conversation context or `--milestone=` flag instead of refusing. Works from any workflow state. Step 2 dry-run display and binPath updated to reference `gsd-t-unattended.cjs`.
+- **`.gsd-t/contracts/unattended-supervisor-contract.md`** — spawn snippet and exit code 8 description updated.
+- **Tests**: `test/unattended-platform.test.js` shim updated (argv[2] not argv[3]). `test/unattended-supervisor.test.js` dirty-tree test now verifies auto-whitelist behavior + git-error refusal. 1136/1136 tests pass.
+
 ## [3.10.15] - 2026-04-15
 
 ### Fixed — bin tools not propagated to downstream projects (unattended launch fails)

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.js

@@ -178,8 +178,8 @@ function spawnWorker(projectDir, timeoutMs, opts = {}) {
  * state file, and relays `claude -p` workers until the milestone terminates.
  *
  * Spawn recipe:
- *   - `node {binPath} unattended {...args}` — the `unattended` subcommand is
- *     prepended automatically so callers pass only user-facing args.
+ *   - `node {binPath} {...args}` — binPath should be the absolute path to
+ *     `bin/gsd-t-unattended.cjs` (the supervisor entry point), NOT gsd-t.js.
  *   - `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.js`.
- * @param {string[]} params.args   Extra args appended after `unattended`.
+ * @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.cwd      Project directory (supervisor's cwd).
  * @returns {{ pid: number }}      The detached child's PID.
  */
 function spawnSupervisor({ binPath, args, cwd }) {
-  const spawnArgs = [binPath, "unattended", ...(args || [])];
+  const spawnArgs = [binPath, ...(args || [])];
   const opts = {
     cwd,
     detached: true,

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

@@ -151,6 +151,27 @@ 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
@@ -745,6 +766,7 @@ function detectBlockerSentinel(runLogTail) {
 module.exports = {
   DEFAULTS,
   loadConfig,
+  saveConfig,
   checkGitBranch,
   checkWorktreeCleanliness,
   checkIterationCap,

package/bin/gsd-t-unattended.cjs

@@ -987,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/bin/gsd-t-unattended.js

@@ -35,6 +35,7 @@ const { mapHeadlessExitCode } = require("./gsd-t.js");
 const {
   DEFAULTS: SAFETY_DEFAULTS,
   loadConfig,
+  saveConfig,
   checkGitBranch,
   checkWorktreeCleanliness,
   checkIterationCap,
@@ -493,6 +494,7 @@ 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) ────────────────
@@ -549,7 +551,23 @@ function doUnattended(argv, deps) {
     };
   }
   const treeRes = fn.checkWorktreeCleanliness(projectDir, config);
-  if (!treeRes.ok) {
+  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.
     // eslint-disable-next-line no-console
     console.error(
       `[gsd-t-unattended] preflight-refusal: ${treeRes.reason || "dirty worktree"}`,

package/bin/gsd-t.js

@@ -1964,7 +1964,9 @@ function updateSingleProject(projectDir, counts) {
   const binToolsCopied = copyBinToolsToProject(projectDir, projectName);
   const archiveRan = runProgressArchiveMigration(projectDir, projectName);
   const taskCounterRetired = runTaskCounterRetirementMigration(projectDir, projectName);
-  if (guardAdded || changelogCreated || binToolsCopied || archiveRan || taskCounterRetired) {
+  const unattendedConfigCreated = ensureUnattendedConfig(projectDir, projectName);
+  const gitignoreUpdated = ensureUnattendedGitignore(projectDir, projectName);
+  if (guardAdded || changelogCreated || binToolsCopied || archiveRan || taskCounterRetired || unattendedConfigCreated || gitignoreUpdated) {
     counts.updated++;
   } else {
     info(`${projectName} — already up to date`);
@@ -2104,6 +2106,55 @@ function runTaskCounterRetirementMigration(projectDir, projectName) {
   return true;
 }
 
+function ensureUnattendedConfig(projectDir, projectName) {
+  const configDir = path.join(projectDir, ".gsd-t", ".unattended");
+  const configPath = path.join(configDir, "config.json");
+  if (fs.existsSync(configPath)) return false;
+  if (!fs.existsSync(path.join(projectDir, ".gsd-t"))) return false;
+
+  try {
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+    const defaultConfig = {
+      protectedBranches: ["main", "master", "develop", "trunk", "release/*", "hotfix/*"],
+      dirtyTreeWhitelist: [
+        ".gsd-t/heartbeat-*.jsonl",
+        ".gsd-t/.context-meter-state.json",
+        ".gsd-t/events/*.jsonl",
+        ".gsd-t/token-metrics.jsonl",
+        ".gsd-t/token-log.md",
+        ".gsd-t/.unattended/*",
+        ".gsd-t/.handoff/*",
+        ".claude/settings.local.json",
+        ".claude/settings.local.json.bak*",
+      ],
+      maxIterations: 200,
+      hours: 24,
+    };
+    fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n");
+    info(`${projectName} — created .gsd-t/.unattended/config.json (edit to customize)`);
+    return true;
+  } catch (e) {
+    warn(`${projectName} — failed to create unattended config: ${e.message}`);
+    return false;
+  }
+}
+
+const UNATTENDED_GITIGNORE_ENTRIES = [
+  "bin/*.cjs",
+  ".gsd-t/.archive-migration-v1",
+  ".gsd-t/.task-counter-retired-v1",
+];
+
+function ensureUnattendedGitignore(projectDir, projectName) {
+  const added = ensureGitignoreEntries(projectDir, UNATTENDED_GITIGNORE_ENTRIES);
+  if (added) {
+    info(`${projectName} — added GSD-T entries to .gitignore`);
+  }
+  return added;
+}
+
 function showUpdateAllSummary(total, counts, playwrightMissing, swaggerMissing, syncCount) {
   log("");
   heading("Update All Complete");

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

@@ -112,6 +112,37 @@ try {
 "
 ```
 
+### 1c.1: Readiness Bootstrap (auto-complete pending state)
+
+**The unattended command must work from ANY workflow state.** If the user says "run unattended," that is an instruction to proceed — not an invitation to ask more questions. Regardless of where the project is in the GSD-T workflow (mid-discussion, pre-milestone, post-partition, between phases), the unattended supervisor should be able to pick up and continue.
+
+The `/gsd-t-resume` worker already knows how to chain through phases automatically. The only thing the unattended command needs is a milestone label in `progress.md` so the supervisor has a target.
+
+**If `MILESTONE=unknown`** (no active milestone found in progress.md):
+
+1. **Look for a milestone** — check in priority order:
+   a. `$ARGUMENTS` — if `--milestone=LABEL` was passed, use it.
+   b. Conversation context — if the user discussed a milestone, feature, or work goal in this session, extract the milestone label from that discussion.
+   c. `.gsd-t/progress.md` — check for any milestone mentioned anywhere (even if not in the standard "Current Milestone" format, e.g., a Decision Log entry like "created milestone M8").
+   d. `.gsd-t/domains/` — if domains exist, infer the milestone from directory names or scope files.
+
+2. **If a milestone is identifiable**:
+   - Ensure `.gsd-t/progress.md` has a `## Current Milestone` section with the label and status `IN PROGRESS`. If missing, add it.
+   - Run `gsd-t-init` silently to fill in any missing required files (it skips existing files).
+   - Print: `ℹ️  Auto-bootstrapped milestone {LABEL} — supervisor workers will continue from current phase.`
+   - Re-read the milestone label.
+
+3. **If no milestone is identifiable at all**:
+   - Print:
+     ```
+     ❌  No active milestone found and none identifiable from context.
+
+         Specify one explicitly: /user:gsd-t-unattended --milestone=M1
+     ```
+   - **STOP.** Do NOT spawn.
+
+**If `MILESTONE` was found but progress.md shows a pre-execution phase** (e.g., milestone was just created, no partition/plan/domains yet): that's fine — proceed with the spawn. The `/gsd-t-resume` worker will read the current state and advance through partition → plan → execute → ... automatically. The unattended command should never second-guess the resume logic or add pre-conditions beyond "a milestone exists."
+
 ### 1d: Check for Stale Stop Sentinel
 
 If `.gsd-t/.unattended/stop` exists from a previous run, remove it before spawning (per contract §10 — the launch command cleans the stale sentinel):
@@ -230,7 +261,7 @@ If `--dry-run` was specified, print:
 
 ```
 🔎  Dry-run mode — would spawn:
-    node bin/gsd-t.js unattended --hours={hours} --milestone={milestone} --max-iterations={maxIterations}
+    node bin/gsd-t-unattended.cjs --hours={hours} --milestone={milestone} --max-iterations={maxIterations}
     Project: {cwd}
 
     No supervisor launched. Remove --dry-run to proceed.
@@ -250,7 +281,7 @@ const hours = parseInt(process.env.GSD_T_HOURS || '24', 10) || 24;
 const milestone = process.env.GSD_T_MILESTONE || '';
 const maxIterations = parseInt(process.env.GSD_T_MAX_ITERATIONS || '200', 10) || 200;
 
-const binPath = path.resolve(__dirname, 'bin', 'gsd-t.js');
+const binPath = path.resolve(__dirname, 'bin', 'gsd-t-unattended.cjs');
 const cwd = process.cwd();
 
 const extraArgs = [];
@@ -393,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):
@@ -401,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.15",
+  "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",