@tekyzinc/gsd-t 3.12.10 → 3.12.13

package/bin/gsd-t-unattended.cjs

@@ -498,7 +498,7 @@ function doUnattended(argv, deps) {
     console.error(
       "[gsd-t-unattended] --watch is incompatible with unattended.\n" +
         "Unattended supervisor is detached by definition.\n" +
-        "Run /user:gsd-t-unattended-watch from your interactive session to see live activity.",
+        "Run /gsd-t-unattended-watch from your interactive session to see live activity.",
     );
     return {
       ok: false,
@@ -939,6 +939,17 @@ function runMainLoop(state, dir, opts, deps, ctx) {
     // Append the full worker output to run.log (never truncate).
     _appendRunLog(dir, state.iter, workerEnd, exitCode, stdout, stderr);
 
+    // Append to token-log.md (Fix 1, v3.12.12) — supervisor workers write rows
+    // so the log captures headless/unattended activity, not just interactive spawns.
+    _appendTokenLog(projectDir, {
+      dtStart: workerStart.toISOString().slice(0, 16).replace("T", " "),
+      dtEnd: workerEnd.toISOString().slice(0, 16).replace("T", " "),
+      command: "gsd-t-resume",
+      durationS: Math.round(elapsedMs / 1000),
+      exitCode,
+      iter: state.iter,
+    });
+
     // Post-spawn state update
     state.lastExit = exitCode;
     state.lastWorkerFinishedAt = workerEnd.toISOString();
@@ -1060,6 +1071,41 @@ function runMainLoop(state, dir, opts, deps, ctx) {
   return state;
 }
 
+// ── _appendTokenLog (Fix 1, v3.12.12) ───────────────────────────────────────
+
+const _TOKEN_LOG_HEADER =
+  "| Datetime-start | Datetime-end | Command | Step | Model | Duration(s) | Notes | Domain | Task | Ctx% |\n" +
+  "|---|---|---|---|---|---|---|---|---|---|\n";
+
+/**
+ * Append one row to {projectDir}/.gsd-t/token-log.md for a supervisor worker
+ * iteration. Matches the schema used by interactive command-file observability.
+ */
+function _appendTokenLog(projectDir, entry) {
+  try {
+    const logPath = path.join(projectDir, ".gsd-t", "token-log.md");
+    const note = entry.exitCode === 0
+      ? `supervisor iter=${entry.iter}: ok`
+      : `supervisor iter=${entry.iter}: exit ${entry.exitCode}`;
+    const row =
+      `| ${entry.dtStart} | ${entry.dtEnd} | ${entry.command} | supervisor-iter-${entry.iter} | unknown | ${entry.durationS}s | ${note} | - | - | unknown |\n`;
+    const gsdtDir = path.join(projectDir, ".gsd-t");
+    if (!fs.existsSync(gsdtDir)) fs.mkdirSync(gsdtDir, { recursive: true });
+    if (!fs.existsSync(logPath)) {
+      fs.writeFileSync(logPath, `# GSD-T Token Log\n\n${_TOKEN_LOG_HEADER}${row}`);
+    } else {
+      const existing = fs.readFileSync(logPath, "utf8");
+      if (!existing.includes("| Datetime-start |")) {
+        fs.writeFileSync(logPath, `# GSD-T Token Log\n\n${_TOKEN_LOG_HEADER}${existing}${row}`);
+      } else {
+        fs.appendFileSync(logPath, row);
+      }
+    }
+  } catch (_) {
+    /* best-effort — never halt the supervisor loop */
+  }
+}
+
 // ── _spawnWorker ────────────────────────────────────────────────────────────
 
 /**
@@ -1073,7 +1119,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" };
+  // Inject command/phase so event-stream tool_call entries are tagged in worker
+  // contexts (Fix 2, v3.12.12). Supervisor always runs gsd-t-resume workers;
+  // phase is inferred from state when available.
+  const workerEnv = {
+    ...process.env,
+    GSD_T_UNATTENDED_WORKER: "1",
+    GSD_T_COMMAND: "gsd-t-resume",
+    GSD_T_PHASE: (state && state.phase) || "execute",
+  };
   const res = platformSpawnWorker(opts.cwd, opts.timeout, {
     bin,
     args: [

package/bin/gsd-t-unattended.js

@@ -499,7 +499,7 @@ function doUnattended(argv, deps) {
     console.error(
       "[gsd-t-unattended] --watch is incompatible with unattended.\n" +
         "Unattended supervisor is detached by definition.\n" +
-        "Run /user:gsd-t-unattended-watch from your interactive session to see live activity.",
+        "Run /gsd-t-unattended-watch from your interactive session to see live activity.",
     );
     return {
       ok: false,

package/bin/gsd-t.js

@@ -388,8 +388,14 @@ const CONTEXT_METER_GITIGNORE_ENTRIES = [
   ".gsd-t/context-meter.log",
 ];
 const CONTEXT_METER_HOOK_MARKER = "gsd-t-context-meter";
+// Canonical global hook — runs the script from the globally-installed npm package.
+// Guarded so it silently exits 0 if the package is not present (non-GSD-T projects).
 const CONTEXT_METER_HOOK_COMMAND =
-  'node "$CLAUDE_PROJECT_DIR/scripts/gsd-t-context-meter.js"';
+  'bash -c \'[ -f "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-context-meter.js" ] && node "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-context-meter.js" || true\'';
+// Legacy command patterns that must be migrated on install/update/init.
+const CONTEXT_METER_STALE_PATTERNS = [
+  /node\s+"?\$CLAUDE_PROJECT_DIR\/scripts\/gsd-t-context-meter\.js"?/,
+];
 
 // Append entries to {projectDir}/.gitignore. Each entry added only if absent.
 // Idempotent. Returns true if any entries were added, false otherwise.
@@ -544,7 +550,9 @@ function installContextMeter(projectDir) {
 
 // Register the Context Meter PostToolUse hook in ~/.claude/settings.json.
 // Idempotent — if an existing hook references CONTEXT_METER_HOOK_MARKER the
-// command string is refreshed in-place. All other settings/hooks preserved.
+// command string is refreshed/migrated in-place to the canonical form.
+// Stale entries matching CONTEXT_METER_STALE_PATTERNS are migrated on the spot.
+// All other settings/hooks are preserved.
 // Returns { installed: bool, action: "added"|"updated"|"noop" }.
 function configureContextMeterHooks(settingsPath) {
   const targetPath = settingsPath || SETTINGS_JSON;
@@ -570,13 +578,17 @@ function configureContextMeterHooks(settingsPath) {
   for (const entry of settings.hooks.PostToolUse) {
     if (!entry || !Array.isArray(entry.hooks)) continue;
     for (const h of entry.hooks) {
-      if (h && typeof h.command === "string" && h.command.includes(CONTEXT_METER_HOOK_MARKER)) {
+      if (!h || typeof h.command !== "string") continue;
+      const isCurrentCanonical = h.command === cmd;
+      const isMarkerMatch = h.command.includes(CONTEXT_METER_HOOK_MARKER);
+      const isStaleMatch = !isCurrentCanonical &&
+        CONTEXT_METER_STALE_PATTERNS.some((re) => re.test(h.command));
+
+      if (isCurrentCanonical || isMarkerMatch || isStaleMatch) {
         found = true;
-        if (h.command !== cmd) {
+        if (!isCurrentCanonical) {
           h.command = cmd;
           action = "updated";
-        } else if (action === "noop") {
-          action = "noop";
         }
       }
     }
@@ -607,6 +619,46 @@ function configureContextMeterHooks(settingsPath) {
   return { installed: true, action };
 }
 
+// Remove any context meter PostToolUse hooks from settings.json.
+// Used during uninstall. Leaves all other hooks intact.
+function removeContextMeterHook(settingsPath) {
+  const targetPath = settingsPath || SETTINGS_JSON;
+  if (!fs.existsSync(targetPath)) return false;
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(targetPath, "utf8"));
+    if (!settings || typeof settings !== "object") return false;
+  } catch {
+    warn("settings.json has invalid JSON — cannot remove context meter hook");
+    return false;
+  }
+
+  if (!settings.hooks || !Array.isArray(settings.hooks.PostToolUse)) return false;
+
+  const before = settings.hooks.PostToolUse.length;
+  settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter((entry) => {
+    if (!entry || !Array.isArray(entry.hooks)) return true;
+    // Keep the entry only if NONE of its hooks reference the context meter
+    return !entry.hooks.some(
+      (h) => h && typeof h.command === "string" && h.command.includes(CONTEXT_METER_HOOK_MARKER)
+    );
+  });
+  const removed = before - settings.hooks.PostToolUse.length;
+  if (removed === 0) return false;
+
+  if (isSymlink(targetPath)) {
+    warn("Skipping settings.json write — target is a symlink");
+    return false;
+  }
+  try {
+    fs.writeFileSync(targetPath, JSON.stringify(settings, null, 2));
+    return true;
+  } catch (e) {
+    warn(`Failed to write settings.json: ${e.message}`);
+    return false;
+  }
+}
+
 // Interactive prompt for the Anthropic API key env var.
 // Skips if not a TTY or if the env var is already set.
 // Never writes the key anywhere — just prints the export command for the user
@@ -1242,9 +1294,9 @@ function showInstallSummary(gsdtCount, utilCount) {
   log(`${BOLD}Quick Start:${RESET}`);
   log(`  ${DIM}$${RESET} cd your-project`);
   log(`  ${DIM}$${RESET} claude`);
-  log(`  ${DIM}>${RESET} /user:gsd-t-init my-project`);
-  log(`  ${DIM}>${RESET} /user:gsd-t-milestone "First Feature"`);
-  log(`  ${DIM}>${RESET} /user:gsd-t-wave`);
+  log(`  ${DIM}>${RESET} /gsd-t-init my-project`);
+  log(`  ${DIM}>${RESET} /gsd-t-milestone "First Feature"`);
+  log(`  ${DIM}>${RESET} /gsd-t-wave`);
   log("");
   log(`${BOLD}Other commands:${RESET}`);
   log(`  ${DIM}$${RESET} npx @tekyzinc/gsd-t status      ${DIM}— check installation${RESET}`);
@@ -1292,7 +1344,7 @@ function initClaudeMd(projectDir, projectName, today) {
         info("CLAUDE.md already contains GSD-T section — skipping");
       } else {
         warn("CLAUDE.md exists but doesn't reference GSD-T");
-        info("Run /user:gsd-t-init inside Claude Code to add GSD-T section");
+        info("Run /gsd-t-init inside Claude Code to add GSD-T section");
       }
     } else { throw e; }
   }
@@ -1461,8 +1513,8 @@ function showInitTree(projectDir) {
   log(`${BOLD}Next steps:${RESET}`);
   log(`  1. Edit CLAUDE.md — add project overview and tech stack`);
   log(`  2. Start Claude Code: ${DIM}claude${RESET}`);
-  log(`  3. Run: ${DIM}/user:gsd-t-populate${RESET}  ${DIM}(if existing codebase)${RESET}`);
-  log(`     Or:  ${DIM}/user:gsd-t-project${RESET}   ${DIM}(if new project)${RESET}`);
+  log(`  3. Run: ${DIM}/gsd-t-populate${RESET}  ${DIM}(if existing codebase)${RESET}`);
+  log(`     Or:  ${DIM}/gsd-t-project${RESET}   ${DIM}(if new project)${RESET}`);
   log("");
 }
 
@@ -1635,7 +1687,7 @@ function showStatusProject() {
     }
   } else if (hasClaudeMd) {
     info("CLAUDE.md found but no .gsd-t/ directory");
-    info("Run /user:gsd-t-init inside Claude Code to set up");
+    info("Run /gsd-t-init inside Claude Code to set up");
   } else {
     info("Not in a GSD-T project directory");
     info(`Run 'npx @tekyzinc/gsd-t init' to set up this directory`);
@@ -1649,6 +1701,11 @@ function doUninstall() {
   removeInstalledCommands();
   removeVersionFile();
 
+  // Remove context meter PostToolUse hook from settings.json
+  if (removeContextMeterHook(SETTINGS_JSON)) {
+    success("Context meter PostToolUse hook removed from settings.json");
+  }
+
   warn("~/.claude/CLAUDE.md was NOT removed (may contain your customizations)");
   info("Remove manually if desired: delete the GSD-T section from ~/.claude/CLAUDE.md");
   info("Project files (.gsd-t/, docs/, CLAUDE.md) were NOT removed");
@@ -1888,6 +1945,19 @@ function exportUniversalRulesForNpm() {
 }
 
 async function doUpdateAll() {
+  // Step 1: Upgrade the globally-installed npm package FIRST. Without this,
+  // `update-all` would only propagate command files — but the global `gsd-t`
+  // binary itself could stay pinned to an older version (e.g., user stuck
+  // on v3.11.11 while npm registry has v3.12.12). See CHANGELOG v3.12.13.
+  // Guard with an env flag to prevent re-exec loops.
+  if (!process.env.GSDT_POST_UPGRADE) {
+    const upgraded = await upgradeGlobalBinary();
+    if (upgraded.reexec) {
+      reexecUpdateAll();
+      return;
+    }
+  }
+
   await updateGlobalCommands();
   heading("Updating registered projects...");
   log("");
@@ -1912,6 +1982,65 @@ async function doUpdateAll() {
   showUpdateAllSummary(projects.length, counts, playwrightMissing, swaggerMissing, syncCount);
 }
 
+// Upgrade the globally-installed @tekyzinc/gsd-t to @latest. Returns
+// { upgraded: bool, reexec: bool, error?: string }.
+// - reexec=true when the on-disk version after `npm install -g` is newer than
+//   the currently-running PKG_VERSION, meaning we need to hand off to the
+//   freshly-installed binary so the new code drives propagation.
+// - reexec=false when already at latest, or when the install failed (we
+//   continue with the current binary and still propagate command files).
+async function upgradeGlobalBinary() {
+  heading("Upgrading global @tekyzinc/gsd-t to latest...");
+  try {
+    execFileSync("npm", ["install", "-g", "@tekyzinc/gsd-t@latest"], {
+      stdio: "inherit",
+      env: process.env,
+    });
+  } catch (e) {
+    warn(`Global npm install failed: ${e.message || e}`);
+    info("Continuing with current binary — command files will still be propagated.");
+    return { upgraded: false, reexec: false, error: String(e.message || e) };
+  }
+
+  // Read the freshly-installed global package's version. If it's newer than
+  // the currently-running process, signal a re-exec.
+  let newVersion = null;
+  try {
+    const prefix = execFileSync("npm", ["prefix", "-g"], { encoding: "utf8" }).trim();
+    const globalPkgJson = path.join(prefix, "lib", "node_modules", "@tekyzinc", "gsd-t", "package.json");
+    if (fs.existsSync(globalPkgJson)) {
+      newVersion = JSON.parse(fs.readFileSync(globalPkgJson, "utf8")).version;
+    }
+  } catch {
+    // Best-effort; fall through.
+  }
+
+  if (newVersion && newVersion !== PKG_VERSION) {
+    success(`Global binary upgraded: v${PKG_VERSION} → v${newVersion}`);
+    info("Handing off to the newly-installed binary for propagation...");
+    return { upgraded: true, reexec: true };
+  }
+  success(`Global binary already at latest (v${PKG_VERSION})`);
+  return { upgraded: true, reexec: false };
+}
+
+// Hand execution to the newly-installed global `gsd-t update-all`. Sets the
+// GSDT_POST_UPGRADE env flag so the child does not recurse into another
+// upgrade attempt.
+function reexecUpdateAll() {
+  const env = Object.assign({}, process.env, { GSDT_POST_UPGRADE: "1" });
+  try {
+    execFileSync("gsd-t", ["update-all"], { stdio: "inherit", env });
+  } catch (e) {
+    // Surface the child's exit code; execFileSync throws with .status on
+    // non-zero exit. Fall through to re-throw so the caller exits cleanly.
+    if (e && typeof e.status === "number") {
+      process.exit(e.status);
+    }
+    throw e;
+  }
+}
+
 async function updateGlobalCommands() {
   if (getInstalledVersion() !== PKG_VERSION) {
     await doInstall({ update: true });
@@ -2600,6 +2729,39 @@ function doGraph(args) {
   }
 }
 
+// ─── Token-Log Writer (Fix 1, v3.12.12) ─────────────────────────────────────
+
+const _TL_HEADER =
+  "| Datetime-start | Datetime-end | Command | Step | Model | Duration(s) | Notes | Domain | Task | Ctx% |\n" +
+  "|---|---|---|---|---|---|---|---|---|---|\n";
+
+/**
+ * Append one row to {projectDir}/.gsd-t/token-log.md for a headless exec
+ * invocation. Best-effort — never throws.
+ */
+function appendHeadlessTokenLog(projectDir, entry) {
+  try {
+    const logPath = path.join(projectDir, ".gsd-t", "token-log.md");
+    const note = entry.exitCode === 0 ? "headless exec: ok" : `headless exec: exit ${entry.exitCode}`;
+    const row =
+      `| ${entry.dtStart} | ${entry.dtEnd} | ${entry.command} | headless | unknown | ${entry.durationS}s | ${note} | - | - | unknown |\n`;
+    const gsdtDir = path.join(projectDir, ".gsd-t");
+    if (!fs.existsSync(gsdtDir)) fs.mkdirSync(gsdtDir, { recursive: true });
+    if (!fs.existsSync(logPath)) {
+      fs.writeFileSync(logPath, `# GSD-T Token Log\n\n${_TL_HEADER}${row}`);
+    } else {
+      const existing = fs.readFileSync(logPath, "utf8");
+      if (!existing.includes("| Datetime-start |")) {
+        fs.writeFileSync(logPath, `# GSD-T Token Log\n\n${_TL_HEADER}${existing}${row}`);
+      } else {
+        fs.appendFileSync(logPath, row);
+      }
+    }
+  } catch (_) {
+    /* best-effort */
+  }
+}
+
 // ─── Headless Mode ────────────────────────────────────────────────────────────
 
 /**
@@ -2628,7 +2790,7 @@ function parseHeadlessFlags(args) {
  * Build the claude -p invocation string for a GSD-T command.
  *
  * Non-interactive `claude -p` mode requires the bare `/gsd-t-X` form — the
- * `/user:gsd-t-X` namespace prefix is rejected as "Unknown command" even
+ * `/gsd-t-X` namespace prefix is rejected as "Unknown command" even
  * though interactive mode accepts both. Verified by M36 Phase 0 Spike A
  * (2026-04-15). See .gsd-t/M36-spike-findings.md.
  */
@@ -2717,12 +2879,20 @@ function doHeadlessExec(command, cmdArgs, flags) {
   let output = "";
   let processExitCode = 0;
 
+  // Inject command/phase env vars so worker event-stream entries are tagged
+  // (Fix 2, v3.12.12).
+  const workerEnv = Object.assign({}, process.env, {
+    GSD_T_COMMAND: `gsd-t-${command}`,
+    GSD_T_PHASE: process.env.GSD_T_PHASE || "execute",
+  });
+
   try {
     const result = execFileSync("claude", ["-p", "--dangerously-skip-permissions", prompt], {
       encoding: "utf8",
       timeout: timeoutMs,
       stdio: ["pipe", "pipe", "pipe"],
-      cwd: process.cwd()
+      cwd: process.cwd(),
+      env: workerEnv,
     });
     output = result;
   } catch (e) {
@@ -2738,6 +2908,16 @@ function doHeadlessExec(command, cmdArgs, flags) {
   const gsdtExitCode = mapHeadlessExitCode(processExitCode, output);
   const duration = Date.now() - startTime;
 
+  // Append to token-log.md (Fix 1, v3.12.12) — headless exec writes a row so
+  // `gsd-t headless <command>` spawns are visible in the log.
+  appendHeadlessTokenLog(process.cwd(), {
+    dtStart: new Date(startTime).toISOString().slice(0, 16).replace("T", " "),
+    dtEnd: new Date(startTime + duration).toISOString().slice(0, 16).replace("T", " "),
+    command: `gsd-t-${command}`,
+    durationS: Math.round(duration / 1000),
+    exitCode: gsdtExitCode,
+  });
+
   // Write log file if requested
   if (logMode && logFile) {
     try {
@@ -3270,8 +3450,8 @@ function showHelp() {
   log(`  ${DIM}$${RESET} npx @tekyzinc/gsd-t init my-saas-app`);
   log(`  ${DIM}$${RESET} npx @tekyzinc/gsd-t update\n`);
   log(`${BOLD}After installing, use in Claude Code:${RESET}`);
-  log(`  ${DIM}>${RESET} /user:gsd-t-project "Build a task management app"`);
-  log(`  ${DIM}>${RESET} /user:gsd-t-wave\n`);
+  log(`  ${DIM}>${RESET} /gsd-t-project "Build a task management app"`);
+  log(`  ${DIM}>${RESET} /gsd-t-wave\n`);
   log(`${DIM}Docs: https://github.com/Tekyz-Inc/get-stuff-done-teams${RESET}\n`);
 }
 
@@ -3360,6 +3540,7 @@ module.exports = {
   ensureGitignoreEntries,
   installContextMeter,
   configureContextMeterHooks,
+  removeContextMeterHook,
   promptForApiKeyIfMissing,
   resolveApiKeyEnvVar,
   runTaskCounterRetirementMigration,

package/bin/headless-auto-spawn.cjs

@@ -135,11 +135,18 @@ function autoSpawnHeadless(opts) {
     const gsdtCli = path.join(projectDir, "bin", "gsd-t.js");
     const childArgs = [gsdtCli, "headless", stripGsdtPrefix(command), ...args, "--log"];
 
+    // Inject command/phase into worker env so event-stream entries are tagged
+    // (Fix 2, v3.12.12). GSD_T_PHASE defaults to "execute" for primary spawns.
+    const workerEnv = Object.assign({}, process.env, {
+      GSD_T_COMMAND: command,
+      GSD_T_PHASE: process.env.GSD_T_PHASE || "execute",
+    });
+
     const child = spawn("node", childArgs, {
       cwd: projectDir,
       detached: true,
       stdio: ["ignore", logFd, logFd],
-      env: process.env,
+      env: workerEnv,
     });
 
     child.unref();
@@ -291,6 +298,7 @@ function installCompletionWatcher(opts) {
   const POLL_MS = 2000;
   const MAX_WAIT_MS = 60 * 60 * 1000; // 1 hour safety cap
   const startMs = Date.now();
+  const dtStart = new Date(startTimestamp).toLocaleString("sv-SE", { hour12: false }).slice(0, 16);
 
   const timer = setInterval(() => {
     let alive = false;
@@ -305,9 +313,20 @@ function installCompletionWatcher(opts) {
       // Exit code is unknown from a signal-based probe. Best-effort: read
       // the log's last lines to guess, otherwise default to 0.
       const exitCode = guessExitCodeFromLog(projectDir, id);
+      const endTimestamp = new Date().toISOString();
       markSessionCompleted(projectDir, id, {
         exitCode,
-        endTimestamp: new Date().toISOString(),
+        endTimestamp,
+      });
+      // Append token-log row (Fix 1, v3.12.12)
+      const dtEnd = new Date(endTimestamp).toLocaleString("sv-SE", { hour12: false }).slice(0, 16);
+      const durationS = Math.round((Date.now() - startMs) / 1000);
+      appendTokenLog(projectDir, {
+        dtStart,
+        dtEnd,
+        command: extractCommand(id),
+        durationS,
+        exitCode,
       });
       fireMacNotification({ id, command: extractCommand(id), startTimestamp });
     } else if (Date.now() - startMs > MAX_WAIT_MS) {
@@ -356,6 +375,43 @@ function fireMacNotification({ id, command }) {
   }
 }
 
+// ── Token-Log Writer (Fix 1, v3.12.12) ───────────────────────────────────────
+
+const TOKEN_LOG_HEADER =
+  "| Datetime-start | Datetime-end | Command | Step | Model | Duration(s) | Notes | Domain | Task | Ctx% |\n" +
+  "|---|---|---|---|---|---|---|---|---|---|\n";
+
+/**
+ * Append one row to {projectDir}/.gsd-t/token-log.md matching the schema used
+ * by interactive command-file observability blocks.
+ *
+ * @param {string} projectDir
+ * @param {{ dtStart: string, dtEnd: string, command: string, durationS: number, exitCode: number }} entry
+ */
+function appendTokenLog(projectDir, entry) {
+  try {
+    const logPath = path.join(projectDir, ".gsd-t", "token-log.md");
+    const note = entry.exitCode === 0 ? "headless spawn: ok" : `headless spawn: exit ${entry.exitCode}`;
+    const row =
+      `| ${entry.dtStart} | ${entry.dtEnd} | ${entry.command} | headless | unknown | ${entry.durationS}s | ${note} | - | - | unknown |\n`;
+    if (!fs.existsSync(logPath)) {
+      // Create with header
+      ensureDir(path.dirname(logPath));
+      fs.writeFileSync(logPath, `# GSD-T Token Log\n\n${TOKEN_LOG_HEADER}${row}`);
+    } else {
+      // Check if header row exists; if not prepend it (migration for files created before this fix)
+      const existing = fs.readFileSync(logPath, "utf8");
+      if (!existing.includes("| Datetime-start |")) {
+        fs.writeFileSync(logPath, `# GSD-T Token Log\n\n${TOKEN_LOG_HEADER}${existing}${row}`);
+      } else {
+        fs.appendFileSync(logPath, row);
+      }
+    }
+  } catch (_) {
+    /* best-effort — never halt the completion watcher */
+  }
+}
+
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
 function ensureDir(d) {

package/commands/gsd-t-backlog-promote.md

@@ -13,14 +13,14 @@ Parse $ARGUMENTS to extract:
 - `<position>` — the entry number to promote
 
 If no position is provided, show an error:
-"Usage: `/user:gsd-t-backlog-promote <position>`"
+"Usage: `/gsd-t-backlog-promote <position>`"
 
 ## Step 2: Find and Display Entry
 
 Find the entry at the specified position in `.gsd-t/backlog.md`.
 
 If the position doesn't exist, show an error:
-"No backlog entry at position {position}. Run `/user:gsd-t-backlog-list` to see available entries."
+"No backlog entry at position {position}. Run `/gsd-t-backlog-list` to see available entries."
 
 Display the entry to the user:
 ```
@@ -88,10 +88,10 @@ After classification is confirmed:
 
 Based on the classification, present the command for the user to invoke:
 
-- **Milestone**: "Run `/user:gsd-t-milestone {refined description}`"
-- **Quick**: "Run `/user:gsd-t-quick {refined description}`"
-- **Debug**: "Run `/user:gsd-t-debug {refined description}`"
-- **Feature**: "Run `/user:gsd-t-feature {refined description}`"
+- **Milestone**: "Run `/gsd-t-milestone {refined description}`"
+- **Quick**: "Run `/gsd-t-quick {refined description}`"
+- **Debug**: "Run `/gsd-t-debug {refined description}`"
+- **Feature**: "Run `/gsd-t-feature {refined description}`"
 
 Display the full command with the refined description ready to copy.
 

package/commands/gsd-t-complete-milestone.md

@@ -3,8 +3,8 @@
 You are finalizing a completed milestone. Your job is to archive the milestone documentation, create a git tag, and prepare for the next milestone.
 
 This command is:
-- **Auto-invoked** by `/user:gsd-t-verify` (Step 8) after all quality gates pass — at ALL autonomy levels
-- **Auto-invoked** by `/user:gsd-t-wave` as part of the VERIFY+COMPLETE phase
+- **Auto-invoked** by `/gsd-t-verify` (Step 8) after all quality gates pass — at ALL autonomy levels
+- **Auto-invoked** by `/gsd-t-wave` as part of the VERIFY+COMPLETE phase
 - **Standalone** when user wants to manually close a milestone
 
 ## Step 1: Verify Completion
@@ -14,7 +14,7 @@ Read:
 2. `.gsd-t/verify-report.md` — confirm all checks passed
 
 If status is not VERIFIED:
-"⚠️ Milestone not yet verified. Run `/user:gsd-t-verify` first, or use `--force` to complete anyway."
+"⚠️ Milestone not yet verified. Run `/gsd-t-verify` first, or use `--force` to complete anyway."
 
 If `--force` flag provided, proceed with warning in archive.
 
@@ -76,7 +76,7 @@ Refer to `.gsd-t/contracts/goal-backward-contract.md` for the full verification
   {findings table}
 
   Options:
-  1. Fix the findings and re-run /user:gsd-t-verify
+  1. Fix the findings and re-run /gsd-t-verify
   2. Override with explicit acknowledgment: re-run this command with --force-goal-backward
 
   Proceed with option 1 (recommended) or acknowledge to force completion?
@@ -493,8 +493,8 @@ Summary:
 
 Next steps:
 - Push tags: git push origin v{version}
-- Start next milestone: /user:gsd-t-milestone "{next name}"
-- Or view roadmap: /user:gsd-t-status
+- Start next milestone: /gsd-t-milestone "{next name}"
+- Or view roadmap: /gsd-t-status
 ```
 
 ## Step 13: Update Roadmap (if exists)
@@ -510,7 +510,7 @@ If `.gsd-t/roadmap.md` exists:
 "Cannot complete — verification found issues. Address them first or use `--force`."
 
 ### If no milestone active:
-"No active milestone to complete. Run `/user:gsd-t-status` to see state."
+"No active milestone to complete. Run `/gsd-t-status` to see state."
 
 ### If git operations fail:
 - Still create archive

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

@@ -400,7 +400,7 @@ If ANY CRITICAL or HIGH deviations were found, automatically prompt the fix work
 The audit report at `.gsd-t/design-audit-{page-name}-{YYYY-MM-DD}.md`
 has the exact Figma values for each deviation.
 
-`/user:gsd-t-quick fix all CRITICAL and HIGH deviations from .gsd-t/design-audit-{page-name}-{YYYY-MM-DD}.md — use the Figma values in the report as the source of truth`
+`/gsd-t-quick fix all CRITICAL and HIGH deviations from .gsd-t/design-audit-{page-name}-{YYYY-MM-DD}.md — use the Figma values in the report as the source of truth`
 
 ───────────────────────────────────────────────────────────────
 ```
@@ -414,7 +414,7 @@ If ONLY MEDIUM or LOW deviations remain, show:
 
 **{N} MEDIUM + {N} LOW deviations.** These are minor — fix if you want pixel-perfect.
 
-`/user:gsd-t-quick fix MEDIUM and LOW deviations from .gsd-t/design-audit-{page-name}-{YYYY-MM-DD}.md`
+`/gsd-t-quick fix MEDIUM and LOW deviations from .gsd-t/design-audit-{page-name}-{YYYY-MM-DD}.md`
 
 ───────────────────────────────────────────────────────────────
 ```
@@ -427,7 +427,7 @@ After fixes are applied, **re-run the audit automatically** to verify. Loop unti
 
 ## Rules
 
-- **You write ZERO code during the audit phase (Steps 1-5).** Report only. Code changes happen in Step 6 via `/user:gsd-t-quick`.
+- **You write ZERO code during the audit phase (Steps 1-5).** Report only. Code changes happen in Step 6 via `/gsd-t-quick`.
 - **You do NOT "look close" at anything.** Every property gets an exact value from Figma and an exact value from the build. They match or they don't.
 - **You do NOT skip widgets.** Every widget in the Figma AND every widget in the build gets audited.
 - **You MUST call `get_design_context` per widget node — NOT `get_screenshot`.** `get_design_context` returns structured code, component properties, and design tokens. `get_screenshot` returns only a visual image that you cannot extract exact values from. Using `get_screenshot` for widget extraction defeats the entire purpose of structured comparison — you end up eyeballing instead of measuring. The ONLY acceptable use of `get_screenshot` is for the built page (Step 2) where you need to see what was actually rendered. For Figma source data, ALWAYS use `get_design_context`.

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

@@ -40,7 +40,7 @@ Pass any of these as `$ARGUMENTS`:
 ## Prerequisites
 
 - Design contracts must exist in `.gsd-t/contracts/design/` with an `INDEX.md`
-- If no contracts exist, run `/user:gsd-t-design-decompose` first
+- If no contracts exist, run `/gsd-t-design-decompose` first
 
 ## Why a JS Orchestrator?
 

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

@@ -471,7 +471,7 @@ This domain owns the following design contracts:
 - Pages: (none — pages owned by page-assembly domain)
 ```
 
-If `.gsd-t/domains/` does NOT exist yet, suggest the user run `/user:gsd-t-partition` next, with a note that design contracts should be partitioned into domains:
+If `.gsd-t/domains/` does NOT exist yet, suggest the user run `/gsd-t-partition` next, with a note that design contracts should be partitioned into domains:
 - **design-system domain** owns element contracts
 - **widgets domain** owns widget contracts
 - **pages domain** owns page assembly + routing
@@ -494,11 +494,11 @@ Display:
 
 **Design Build** — build UI from contracts with tiered review gates (elements → widgets → pages)
 
-`/user:gsd-t-design-build`
+`/gsd-t-design-build`
 
 **Also available:**
-- `/user:gsd-t-partition` — if you need domain boundaries before building
-- `/user:gsd-t-plan` — if you need task lists before building
+- `/gsd-t-partition` — if you need domain boundaries before building
+- `/gsd-t-plan` — if you need task lists before building
 
 ───────────────────────────────────────────────────────────────
 ```