gsd-lite 0.3.13 → 0.3.15

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
       "name": "gsd",
       "source": "./",
       "description": "AI orchestration tool — GSD management shell + Superpowers quality core. 5 commands, 4 agents, 5 workflows, MCP server, context monitoring.",
-      "version": "0.3.13",
+      "version": "0.3.15",
       "keywords": [
         "orchestration",
         "mcp",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "description": "AI orchestration tool for Claude Code — GSD management shell + Superpowers quality core",
   "author": {
     "name": "sdsrss",

package/README.md

@@ -228,7 +228,7 @@ gsd-lite/
 ├── workflows/              # 5 core workflows (TDD, review, debug, research, deviation)
 ├── references/             # 8 reference docs (execution loop, state diagram, evidence spec, ...)
 ├── hooks/                  # Context monitoring (StatusLine + PostToolUse)
-├── tests/                  # 575 tests (506 unit + 69 E2E)
+├── tests/                  # 674 tests (unit + simulation + E2E)
 ├── cli.js                  # Install/uninstall CLI entry
 ├── install.js              # Installation script
 └── uninstall.js            # Uninstall script
@@ -237,7 +237,7 @@ gsd-lite/
 ## Testing
 
 ```bash
-npm test                    # Run all 575 tests
+npm test                    # Run all 674 tests
 npm run test:coverage       # Tests + coverage report (94%+ lines, 81%+ branches)
 npm run lint                # Biome lint
 node --test tests/file.js   # Run a single test file

package/cli.js

@@ -8,6 +8,7 @@ Usage:
   gsd serve        # Start MCP stdio server (explicit)
   gsd install      # Install hooks/commands into Claude Code
   gsd uninstall    # Remove hooks/commands from Claude Code
+  gsd update       # Check for updates and install if available
   gsd help         # Show this help
 `);
 }
@@ -31,6 +32,20 @@ switch (command) {
     uninstall();
     break;
   }
+  case 'update': {
+    const { checkForUpdate } = await import('./hooks/gsd-auto-update.cjs');
+    const force = process.argv.includes('--force');
+    console.log('Checking for updates...');
+    const result = await checkForUpdate({ force, verbose: true, install: true });
+    if (result?.updated) {
+      console.log(`\n✓ Updated: v${result.from} → v${result.to}`);
+    } else if (result?.updateAvailable) {
+      console.log(`\n! Update available v${result.to} but install failed. Try manually.`);
+    } else if (!result) {
+      console.log('✓ Already up to date');
+    }
+    break;
+  }
   case 'help':
   case '--help':
   case '-h':

package/commands/prd.md

@@ -1,5 +1,5 @@
 ---
-description: Start project from requirements document or description text
+description: "Start project from requirements document or description text. Use when: (1) user provides a requirements doc, PRD, spec file, or design document, (2) user pastes a detailed feature description or task list, (3) user says '按这个需求做' or 'here\\'s what I need built', (4) user has a clear written specification ready to plan and execute"
 argument-hint: File path to requirements doc, or inline description text
 ---
 

package/commands/start.md

@@ -1,5 +1,5 @@
 ---
-description: Interactive project start — discuss requirements, research, plan, then auto-execute
+description: "Interactive project start — discuss requirements, research, plan, then auto-execute. Use when: (1) user wants to implement a new feature or complex functionality, (2) user wants to research/analyze a technology then build something, (3) user describes a multi-step task that needs planning and decomposition, (4) user says '帮我做/实现/开发/搞一个...' or 'let\\'s build/create/implement...', (5) task is too complex for a single-shot response and needs phased execution"
 argument-hint: Optional feature or project description
 ---
 

package/hooks/gsd-auto-update.cjs

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+// GSD-Lite Auto-Update Module
+// Checks GitHub Releases for new versions and auto-installs updates.
+// CJS format to match other hook modules.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { execSync, spawnSync } = require('node:child_process');
+
+// ── Configuration ──────────────────────────────────────────
+const GITHUB_REPO = 'sdsrss/gsd-lite';
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const RATE_LIMIT_INTERVAL_MS = 48 * 60 * 60 * 1000; // 48h back-off if rate-limited
+const FETCH_TIMEOUT_MS = 3000; // 3s network timeout
+
+// ── Paths ──────────────────────────────────────────────────
+const claudeDir =
+  process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+const runtimeDir = path.join(claudeDir, 'gsd');
+const stateDir = path.join(runtimeDir, 'runtime');
+const STATE_FILE = path.join(stateDir, 'update-state.json');
+const pluginRoot = path.resolve(__dirname, '..');
+
+// ── Main Entry ─────────────────────────────────────────────
+async function checkForUpdate(options = {}) {
+  const { force = false, verbose = false, install = true } = options;
+
+  try {
+    if (!force && shouldSkipUpdateCheck()) {
+      if (verbose) console.log('Skipping update check (dev mode or auto-update in progress)');
+      return null;
+    }
+
+    const state = readState();
+    if (!force && !shouldCheck(state)) {
+      if (state.updateAvailable && state.latestVersion) {
+        return {
+          updateAvailable: true,
+          from: getCurrentVersion(),
+          to: state.latestVersion,
+        };
+      }
+      if (verbose) console.log('Throttled — last check:', state.lastCheck);
+      return null;
+    }
+
+    if (verbose) console.log('Checking GitHub for latest release...');
+    const token = getGitHubToken();
+    const latest = await fetchLatestRelease(token);
+    if (!latest) {
+      if (latest === false) state.rateLimited = true; // 403 rate-limited
+      saveState({ ...state, lastCheck: new Date().toISOString() });
+      if (verbose) console.log('Could not fetch latest release');
+      return null;
+    }
+
+    // Successful fetch — clear rate-limit back-off
+    state.rateLimited = false;
+    const currentVersion = getCurrentVersion();
+    if (verbose) console.log(`Current: v${currentVersion} — Latest: v${latest.version}`);
+
+    const hasUpdate = compareVersions(latest.version, currentVersion) > 0;
+
+    if (hasUpdate) {
+      if (!install) {
+        // Check-only mode (used by SessionStart hook)
+        saveState({
+          ...state,
+          lastCheck: new Date().toISOString(),
+          latestVersion: latest.version,
+          updateAvailable: true,
+        });
+        return {
+          updateAvailable: true,
+          from: currentVersion,
+          to: latest.version,
+        };
+      }
+
+      if (verbose) console.log(`Downloading v${latest.version}...`);
+      const success = await downloadAndInstall(latest.tarballUrl, verbose, token);
+
+      saveState({
+        ...state,
+        lastCheck: new Date().toISOString(),
+        latestVersion: latest.version,
+        updateAvailable: !success,
+        lastUpdate: success ? new Date().toISOString() : state.lastUpdate,
+      });
+
+      return {
+        updateAvailable: !success,
+        updated: success,
+        from: currentVersion,
+        to: latest.version,
+      };
+    }
+
+    // No update needed
+    saveState({
+      ...state,
+      lastCheck: new Date().toISOString(),
+      latestVersion: latest.version,
+      updateAvailable: false,
+    });
+    if (verbose) console.log('Already up to date');
+    return null;
+  } catch (err) {
+    if (verbose) console.error('Update check failed:', err.message);
+    return null;
+  }
+}
+
+// ── Skip Check Detection ──────────────────────────────────
+// Returns true when update checks should be skipped:
+// 1. PLUGIN_AUTO_UPDATE env set → recursive guard (auto-update already in progress)
+// 2. Running from a git clone → dev mode (developer working on source)
+function shouldSkipUpdateCheck() {
+  if (process.env.PLUGIN_AUTO_UPDATE) return true;
+  try {
+    if (!fs.existsSync(path.join(pluginRoot, '.git'))) return false;
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(pluginRoot, 'package.json'), 'utf8'),
+    );
+    return pkg.name === 'gsd-lite';
+  } catch {
+    return false;
+  }
+}
+
+// ── Throttle ───────────────────────────────────────────────
+function shouldCheck(state) {
+  if (!state.lastCheck) return true;
+  const elapsed = Date.now() - new Date(state.lastCheck).getTime();
+  const interval = state.rateLimited
+    ? RATE_LIMIT_INTERVAL_MS
+    : CHECK_INTERVAL_MS;
+  return elapsed >= interval;
+}
+
+// ── GitHub Auth ─────────────────────────────────────────────
+function getGitHubToken() {
+  // Try gh CLI token first (5000 req/hour vs 60 unauthenticated)
+  try {
+    return execSync('gh auth token', { timeout: 2000, stdio: ['pipe', 'pipe', 'pipe'] })
+      .toString()
+      .trim();
+  } catch {
+    return null;
+  }
+}
+
+// ── GitHub API ─────────────────────────────────────────────
+async function fetchLatestRelease(token) {
+  const url = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+  try {
+    const headers = {
+      Accept: 'application/vnd.github+json',
+      'User-Agent': 'gsd-lite-auto-update/1.0',
+    };
+    if (token) headers.Authorization = `Bearer ${token}`;
+
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers,
+    });
+
+    if (res.status === 403) return false; // rate-limited — caller sets flag
+    if (!res.ok) return null;
+
+    const data = await res.json();
+    return {
+      version: data.tag_name.replace(/^v/, ''),
+      tarballUrl: data.tarball_url,
+      releaseUrl: data.html_url,
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// ── Version Comparison (semver) ────────────────────────────
+function compareVersions(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+function getCurrentVersion() {
+  for (const p of [
+    path.join(pluginRoot, 'package.json'),
+    path.join(runtimeDir, 'package.json'),
+  ]) {
+    try {
+      return JSON.parse(fs.readFileSync(p, 'utf8')).version;
+    } catch {
+      /* try next */
+    }
+  }
+  return '0.0.0';
+}
+
+// ── Download & Install ─────────────────────────────────────
+async function downloadAndInstall(tarballUrl, verbose = false, token = null) {
+  const tmpDir = path.join(os.tmpdir(), `gsd-update-${Date.now()}`);
+  try {
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    // Download tarball via fetch (no shell interpolation)
+    if (verbose) console.log('  Downloading tarball...');
+    const headers = { Accept: 'application/vnd.github+json', 'User-Agent': 'gsd-lite-auto-update/1.0' };
+    if (token) headers.Authorization = `Bearer ${token}`;
+
+    const controller = new AbortController();
+    const dlTimeout = setTimeout(() => controller.abort(), 30000);
+    let tarData;
+    try {
+      const res = await fetch(tarballUrl, { signal: controller.signal, headers, redirect: 'follow' });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      tarData = Buffer.from(await res.arrayBuffer());
+    } finally {
+      clearTimeout(dlTimeout);
+    }
+
+    // Write tarball to file, then extract with spawnSync (no shell)
+    const tarPath = path.join(tmpDir, 'release.tar.gz');
+    fs.writeFileSync(tarPath, tarData);
+    const tar = spawnSync('tar', ['xzf', tarPath, '-C', tmpDir, '--strip-components=1'], { timeout: 30000 });
+    if (tar.status !== 0) throw new Error(`tar extract failed: ${(tar.stderr || '').toString().slice(0, 200)}`);
+
+    // Run installer with spawnSync (no shell)
+    if (verbose) console.log('  Running installer...');
+    const install = spawnSync(process.execPath, [path.join(tmpDir, 'install.js')], {
+      timeout: 60000,
+      stdio: verbose ? 'inherit' : 'pipe',
+      env: { ...process.env, PLUGIN_AUTO_UPDATE: '1' },
+    });
+    if (install.status !== 0) throw new Error(`Installer failed: ${(install.stderr || '').toString().slice(0, 200)}`);
+
+    return true;
+  } catch (err) {
+    if (verbose) console.error('  Install failed:', err.message);
+    return false;
+  } finally {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+// ── State Persistence ──────────────────────────────────────
+function readState() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveState(state) {
+  try {
+    fs.mkdirSync(stateDir, { recursive: true });
+    const tmpPath = STATE_FILE + `.${process.pid}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify(state, null, 2) + '\n');
+    fs.renameSync(tmpPath, STATE_FILE);
+  } catch {
+    /* silent */
+  }
+}
+
+module.exports = {
+  checkForUpdate,
+  getCurrentVersion,
+  compareVersions,
+  shouldSkipUpdateCheck,
+};

package/hooks/gsd-session-init.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // GSD-Lite SessionStart hook
-// Auto-registers statusLine in settings.json if not already configured.
-// This bridges the gap for plugin marketplace installs (which don't run install.js).
+// 1. Auto-registers statusLine in settings.json if not already configured.
+// 2. Checks for updates and notifies user (no download in hook context).
 // Idempotent: skips if statusLine already points to gsd-statusline, preserves
 // third-party statuslines.
 
@@ -14,48 +14,65 @@ const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.cla
 const settingsPath = path.join(claudeDir, 'settings.json');
 const statuslineScript = path.join(pluginRoot, 'hooks', 'gsd-statusline.cjs');
 
-// Clean up stale bridge/debounce files from previous sessions (older than 24h)
-try {
-  const tmpDir = os.tmpdir();
-  const DAY_MS = 24 * 60 * 60 * 1000;
-  const now = Date.now();
-  for (const entry of fs.readdirSync(tmpDir)) {
-    if (!entry.startsWith('gsd-ctx-')) continue;
+// Safety: exit after 4s regardless (hook timeout is 5s)
+setTimeout(() => process.exit(0), 4000).unref();
+
+(async () => {
+  // ── Phase 1: Clean up stale bridge/debounce files (throttled to once/day) ──
+  try {
+    const cleanupMarker = path.join(claudeDir, 'gsd', 'runtime', 'last-cleanup');
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    let shouldClean = true;
     try {
-      const fullPath = path.join(tmpDir, entry);
-      if (now - fs.statSync(fullPath).mtimeMs > DAY_MS) fs.unlinkSync(fullPath);
-    } catch { /* skip */ }
-  }
-} catch { /* silent */ }
-
-try {
-  // Verify the statusline script exists (sanity check)
-  if (!fs.existsSync(statuslineScript)) {
-    process.exit(0);
-  }
-
-  let settings = {};
+      shouldClean = now - fs.statSync(cleanupMarker).mtimeMs > DAY_MS;
+    } catch { /* no marker = first run */ }
+
+    if (shouldClean) {
+      const tmpDir = os.tmpdir();
+      for (const entry of fs.readdirSync(tmpDir)) {
+        if (!entry.startsWith('gsd-ctx-')) continue;
+        try {
+          const fullPath = path.join(tmpDir, entry);
+          if (now - fs.statSync(fullPath).mtimeMs > DAY_MS) fs.unlinkSync(fullPath);
+        } catch { /* skip */ }
+      }
+      try {
+        fs.mkdirSync(path.dirname(cleanupMarker), { recursive: true });
+        fs.writeFileSync(cleanupMarker, String(now));
+      } catch { /* skip */ }
+    }
+  } catch { /* silent */ }
+
+  // ── Phase 2: StatusLine auto-registration ──
+  try {
+    if (fs.existsSync(statuslineScript)) {
+      let settings = {};
+      try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      } catch { /* Can't read settings — skip registration */ }
+
+      if (settings && !settings.statusLine?.command) {
+        settings.statusLine = {
+          type: 'command',
+          command: `node ${JSON.stringify(statuslineScript)}`
+        };
+        const tmpPath = settingsPath + `.gsd-tmp-${process.pid}`;
+        fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + '\n');
+        fs.renameSync(tmpPath, settingsPath);
+      }
+    }
+  } catch { /* silent */ }
+
+  // ── Phase 3: Auto-update check (notify only, no download) ──
+  // checkForUpdate handles throttling internally via shouldCheck()
   try {
-    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  } catch {
-    process.exit(0); // Can't read settings — don't risk writing a broken file
-  }
-
-  // Already has a statusLine configured (ours or third-party) — don't overwrite
-  if (settings.statusLine?.command) {
-    process.exit(0);
-  }
-
-  // Register our statusLine
-  settings.statusLine = {
-    type: 'command',
-    command: `node ${JSON.stringify(statuslineScript)}`
-  };
-
-  // Atomic write to avoid corruption
-  const tmpPath = settingsPath + `.gsd-tmp-${process.pid}`;
-  fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + '\n');
-  fs.renameSync(tmpPath, settingsPath);
-} catch {
-  // Silent fail — never block session start
-}
+    const { checkForUpdate } = require('./gsd-auto-update.cjs');
+    const result = await checkForUpdate({ install: false });
+    if (result?.updateAvailable) {
+      console.log(
+        `\n📦 GSD-Lite v${result.to} available (current: v${result.from}). Run: gsd update`
+      );
+    }
+  } catch { /* silent — never block session start */ }
+})().catch(() => {});

package/hooks/hooks.json

@@ -8,7 +8,7 @@
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gsd-session-init.cjs\"",
-            "timeout": 3
+            "timeout": 5
           }
         ]
       }

package/install.js

@@ -12,8 +12,16 @@ const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
 const RUNTIME_DIR = join(CLAUDE_DIR, 'gsd');
 const DRY_RUN = process.argv.includes('--dry-run');
 
-function log(msg) { console.log(msg); }
+// Single source of truth for hook files (used by copy loop and registration)
+const HOOK_FILES = ['gsd-session-init.cjs', 'gsd-auto-update.cjs', 'gsd-context-monitor.cjs', 'gsd-statusline.cjs'];
+
+// Hook registration config: hookType → { file identifier, matcher, timeout? }
+const HOOK_REGISTRY = [
+  { hookType: 'SessionStart', identifier: 'gsd-session-init', matcher: 'startup', timeout: 5 },
+  { hookType: 'PostToolUse', identifier: 'gsd-context-monitor', matcher: '*' },
+];
 
+function log(msg) { console.log(msg); }
 
 function registerStatusLine(settings, statuslineScriptPath) {
   const command = `node ${JSON.stringify(statuslineScriptPath)}`;
@@ -29,27 +37,31 @@ function registerStatusLine(settings, statuslineScriptPath) {
   return true;
 }
 
-function registerPostToolUseHook(hooks, contextMonitorPath) {
-  const command = `node ${JSON.stringify(contextMonitorPath)}`;
-  const entry = { matcher: '*', hooks: [{ type: 'command', command }] };
-  if (!hooks.PostToolUse) {
-    hooks.PostToolUse = [entry];
+function registerHookEntry(hooks, { hookType, identifier, matcher, timeout }) {
+  const scriptPath = join(CLAUDE_DIR, 'hooks', `${identifier}.cjs`);
+  const command = `node ${JSON.stringify(scriptPath)}`;
+  const hookDef = { type: 'command', command };
+  if (timeout) hookDef.timeout = timeout;
+  const entry = { matcher, hooks: [hookDef] };
+
+  if (!hooks[hookType]) {
+    hooks[hookType] = [entry];
     return true;
   }
   // Handle legacy string format
-  if (typeof hooks.PostToolUse === 'string') {
-    if (!hooks.PostToolUse.includes('gsd-context-monitor')) {
-      log('  ! Preserved existing PostToolUse hook');
+  if (typeof hooks[hookType] === 'string') {
+    if (!hooks[hookType].includes(identifier)) {
+      log(`  ! Preserved existing ${hookType} hook`);
       return false;
     }
-    hooks.PostToolUse = [entry];
+    hooks[hookType] = [entry];
     return true;
   }
-  if (Array.isArray(hooks.PostToolUse)) {
-    const idx = hooks.PostToolUse.findIndex(e =>
-      e.hooks?.some(h => h.command?.includes('gsd-context-monitor')));
-    if (idx >= 0) hooks.PostToolUse[idx] = entry;
-    else hooks.PostToolUse.push(entry);
+  if (Array.isArray(hooks[hookType])) {
+    const idx = hooks[hookType].findIndex(e =>
+      e.hooks?.some(h => h.command?.includes(identifier)));
+    if (idx >= 0) hooks[hookType][idx] = entry;
+    else hooks[hookType].push(entry);
     return true;
   }
   return false;
@@ -109,8 +121,10 @@ export function main() {
   // 4. References
   copyDir(join(__dirname, 'references'), join(CLAUDE_DIR, 'references', 'gsd'), 'references → ~/.claude/references/gsd/');
 
-  // 5. Hooks
-  copyDir(join(__dirname, 'hooks'), join(CLAUDE_DIR, 'hooks'), 'hooks → ~/.claude/hooks/');
+  // 5. Hooks (copy scripts only, skip hooks.json to avoid overwriting other plugins)
+  for (const hookFile of HOOK_FILES) {
+    copyFile(join(__dirname, 'hooks', hookFile), join(CLAUDE_DIR, 'hooks', hookFile), `hooks/${hookFile}`);
+  }
 
   // 6. Stable runtime for MCP server
   copyDir(join(__dirname, 'src'), join(RUNTIME_DIR, 'src'), 'runtime/src → ~/.claude/gsd/src/');
@@ -148,18 +162,20 @@ export function main() {
       args: [join(RUNTIME_DIR, 'src', 'server.js')],
     };
 
-    // Register statusLine (top-level setting) and PostToolUse hook
+    // Register statusLine (top-level setting) and hooks
     if (!settings.hooks) settings.hooks = {};
     const statuslinePath = join(CLAUDE_DIR, 'hooks', 'gsd-statusline.cjs');
-    const contextMonitorPath = join(CLAUDE_DIR, 'hooks', 'gsd-context-monitor.cjs');
     const statusLineRegistered = registerStatusLine(settings, statuslinePath);
-    const postToolUseRegistered = registerPostToolUseHook(settings.hooks, contextMonitorPath);
+    let hooksRegistered = false;
+    for (const config of HOOK_REGISTRY) {
+      if (registerHookEntry(settings.hooks, config)) hooksRegistered = true;
+    }
 
     const tmpSettings = settingsPath + `.${process.pid}-${Date.now()}.tmp`;
     writeFileSync(tmpSettings, JSON.stringify(settings, null, 2) + '\n');
     renameSync(tmpSettings, settingsPath);
     log('  ✓ MCP server registered in settings.json');
-    if (statusLineRegistered || postToolUseRegistered) {
+    if (statusLineRegistered || hooksRegistered) {
       log('  ✓ GSD-Lite hooks registered in settings.json');
     }
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-lite",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "description": "AI orchestration tool for Claude Code — GSD management shell + Superpowers quality core",
   "type": "module",
   "bin": {

package/src/tools/orchestrator.js

@@ -793,6 +793,9 @@ export async function handleExecutorResult({ result, basePath = process.cwd() }
     };
   }
 
+  // Task stays in 'running' lifecycle intentionally — executor outcome 'failed' means
+  // "attempt failed, ready for retry or debugger", NOT lifecycle 'failed'. The task only
+  // transitions to lifecycle 'failed' via handleDebuggerResult when debugging is exhausted.
   const retry_count = (task.retry_count || 0) + 1;
   const error_fingerprint = typeof result.error_fingerprint === 'string' && result.error_fingerprint.length > 0
     ? result.error_fingerprint
@@ -967,7 +970,10 @@ export async function handleReviewerResult({ result, basePath = process.cwd() }
     }
   }
 
-  // Snapshot accepted task IDs before propagation (for done counter adjustment)
+  // Snapshot accepted task IDs before propagation (for done counter adjustment).
+  // Note: rework_tasks patches above are NOT yet applied in-memory, so tasks demoted
+  // by the rework loop are still 'accepted' here. The guard below
+  // `!taskPatches.some(p => p.id === task.id)` prevents double-counting.
   const acceptedBeforePropagation = new Set(
     (phase.todo || []).filter(t => t.lifecycle === 'accepted').map(t => t.id),
   );

package/uninstall.js

@@ -38,7 +38,7 @@ export function main() {
   removeDir(join(CLAUDE_DIR, 'gsd-lite'), 'legacy gsd-lite runtime/');
 
   // Remove hook files (both legacy and current names)
-  for (const name of ['context-monitor.js', 'gsd-statusline.cjs', 'gsd-context-monitor.cjs', 'gsd-session-init.cjs']) {
+  for (const name of ['context-monitor.js', 'gsd-statusline.cjs', 'gsd-context-monitor.cjs', 'gsd-session-init.cjs', 'gsd-auto-update.cjs']) {
     const hookFile = join(CLAUDE_DIR, 'hooks', name);
     if (existsSync(hookFile)) {
       rmSync(hookFile);
@@ -118,19 +118,23 @@ export function main() {
         delete settings.hooks.StatusLine;
         changed = true;
       }
-      // Remove GSD PostToolUse entry from array (match both old and new patterns)
-      if (Array.isArray(settings.hooks.PostToolUse)) {
-        const len = settings.hooks.PostToolUse.length;
-        settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(e =>
-          !e.hooks?.some(h => h.command?.includes('gsd-context-monitor') ||
-                              h.command?.includes('context-monitor.js')));
-        if (settings.hooks.PostToolUse.length < len) changed = true;
-        if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
-      } else if (typeof settings.hooks.PostToolUse === 'string'
-          && (settings.hooks.PostToolUse.includes('gsd-context-monitor') ||
-              settings.hooks.PostToolUse.includes('context-monitor.js'))) {
-        delete settings.hooks.PostToolUse;
-        changed = true;
+      // Remove GSD entries from hook arrays
+      for (const [hookType, identifier] of [
+        ['PostToolUse', 'gsd-context-monitor'],
+        ['PostToolUse', 'context-monitor.js'],
+        ['SessionStart', 'gsd-session-init'],
+      ]) {
+        if (Array.isArray(settings.hooks[hookType])) {
+          const len = settings.hooks[hookType].length;
+          settings.hooks[hookType] = settings.hooks[hookType].filter(e =>
+            !e.hooks?.some(h => h.command?.includes(identifier)));
+          if (settings.hooks[hookType].length < len) changed = true;
+          if (settings.hooks[hookType].length === 0) delete settings.hooks[hookType];
+        } else if (typeof settings.hooks[hookType] === 'string'
+            && settings.hooks[hookType].includes(identifier)) {
+          delete settings.hooks[hookType];
+          changed = true;
+        }
       }
     }
     if (changed) {