gsd-lite 0.7.5 → 0.7.7

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.7.5",
+      "version": "0.7.7",
       "keywords": [
         "orchestration",
         "mcp",

package/.claude-plugin/plugin.json

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

package/README.md

@@ -291,7 +291,7 @@ gsd-lite/
 │   ├── gsd-session-stop.cjs   # Graceful shutdown with crash markers
 │   ├── gsd-statusline.cjs     # StatusLine display (composite-aware)
 │   └── lib/                   # Shared hook utilities (gsd-finder, composite statusline, semver)
-├── tests/                  # 966 tests (unit + simulation + E2E integration)
+├── tests/                  # 972 tests (unit + simulation + E2E integration)
 ├── cli.js                  # Install/uninstall CLI entry
 ├── install.js              # Installation script (plugin-aware, idempotent)
 └── uninstall.js            # Uninstall script
@@ -300,7 +300,7 @@ gsd-lite/
 ## Testing
 
 ```bash
-npm test                    # Run all 966 tests
+npm test                    # Run all 972 tests
 npm run test:coverage       # Tests + coverage report (94%+ lines, 83%+ branches)
 npm run lint                # Biome lint
 node --test tests/file.js   # Run a single test file

package/hooks/gsd-auto-update.cjs

@@ -29,6 +29,35 @@ const LOCK_STALE_MS = 10_000;
 const LOCK_RETRY_MS = 50;
 const LOCK_MAX_RETRIES = 100;
 
+// ── Orphan Detection ───────────────────────────────────────
+// Mirrors gsd-session-init.cjs Phase 0. When the plugin was removed via
+// /plugin uninstall but install.js-written state (hook files, runtime dir,
+// settings.json) survives, getInstallMode() falls through to 'manual' and a
+// new GitHub release would re-trigger install.js — resurrecting the plugin.
+// Guard here so checkForUpdate is a no-op until the orphan is cleaned up
+// (session-init Phase 0 handles the cleanup itself).
+function isOrphan() {
+  const installModeMarker = path.join(claudeDir, 'gsd', '.install-mode');
+  let mode = null;
+  try { mode = fs.readFileSync(installModeMarker, 'utf8').trim(); } catch { /* missing → fall through */ }
+  if (mode === 'manual') return false;
+  if (mode === 'plugin') {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(claudeDir, 'plugins', 'installed_plugins.json'), 'utf8'));
+      return !data.plugins?.['gsd@gsd'];
+    } catch { return false; }
+  }
+  // Pre-marker fallback: orphan iff every cached version has .orphaned_at.
+  const cacheBase = path.join(claudeDir, 'plugins', 'cache', 'gsd', 'gsd');
+  if (!fs.existsSync(cacheBase)) return false;
+  try {
+    const dirs = fs.readdirSync(cacheBase, { withFileTypes: true })
+      .filter(e => e.isDirectory() && /^\d+\.\d+\.\d+/.test(e.name));
+    if (dirs.length === 0) return false;
+    return dirs.every(d => fs.existsSync(path.join(cacheBase, d.name, '.orphaned_at')));
+  } catch { return false; }
+}
+
 // ── Main Entry ─────────────────────────────────────────────
 async function checkForUpdate(options = {}) {
   const {
@@ -43,6 +72,10 @@ async function checkForUpdate(options = {}) {
   const installMode = getInstallMode();
 
   try {
+    if (isOrphan()) {
+      if (verbose) console.log('Skipping update check (plugin uninstalled — orphan state)');
+      return null;
+    }
     if (!force && shouldSkipUpdateCheck()) {
       if (verbose) console.log('Skipping update check (dev mode or auto-update in progress)');
       return null;
@@ -643,6 +676,7 @@ module.exports = {
   compareVersions,
   getInstallMode,
   isDevMode,
+  isOrphan,
   shouldCheck,
   shouldSkipUpdateCheck,
   validateExtractedPackage,

package/hooks/gsd-session-init.cjs

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 // GSD-Lite SessionStart hook
+// 0. Orphan self-cleanup: if /plugin uninstall removed the plugin but left
+//    install.js-written state behind, run inline cleanup and exit.
 // 1. Cleans up stale temp files (throttled to once/day).
 // 2. Auto-registers statusLine in settings.json if not already configured.
 // 3. Self-heals .mcp.json if missing.
@@ -16,6 +18,143 @@ const os = require('node:os');
 const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
 const settingsPath = path.join(claudeDir, 'settings.json');
 
+// ── Phase 0: Orphan self-cleanup ──
+// /plugin uninstall only touches installed_plugins.json + enabledPlugins; it
+// leaves hook scripts, settings.json registrations, the runtime dir, and the
+// composite statusline registry in place — so hooks keep firing and Phases
+// 2/5 below will self-heal the stale state on every session. Detect that case
+// here and remove our footprint before any other phase runs.
+function isOrphan() {
+  // .install-mode marker (written by install.js ≥ 0.7.7) is authoritative.
+  const installModeMarker = path.join(claudeDir, 'gsd', '.install-mode');
+  let mode = null;
+  try { mode = fs.readFileSync(installModeMarker, 'utf8').trim(); } catch { /* missing → fall through */ }
+  if (mode === 'manual') return false; // npx install never enters /plugin uninstall path
+  if (mode === 'plugin') {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(claudeDir, 'plugins', 'installed_plugins.json'), 'utf8'));
+      return !data.plugins?.['gsd@gsd'];
+    } catch { return false; } // registry unreadable → don't assume orphan
+  }
+  // Pre-marker installs: fallback heuristic. Claude Code stamps
+  // .orphaned_at inside cache version dirs when the entry is removed from
+  // installed_plugins.json. Orphan iff every cached version has the marker.
+  const cacheBase = path.join(claudeDir, 'plugins', 'cache', 'gsd', 'gsd');
+  if (!fs.existsSync(cacheBase)) return false;
+  try {
+    const dirs = fs.readdirSync(cacheBase, { withFileTypes: true })
+      .filter(e => e.isDirectory() && /^\d+\.\d+\.\d+/.test(e.name));
+    if (dirs.length === 0) return false;
+    return dirs.every(d => fs.existsSync(path.join(cacheBase, d.name, '.orphaned_at')));
+  } catch { return false; }
+}
+
+function atomicWriteJson(filePath, value) {
+  const tmp = filePath + `.gsd-orphan-${process.pid}-${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n');
+  fs.renameSync(tmp, filePath);
+}
+
+function cleanupOrphan() {
+  // 1. Composite statusLine registry — call removeProvider BEFORE deleting
+  //    the lib file it lives in.
+  try {
+    const compositeLib = path.join(claudeDir, 'hooks', 'lib', 'statusline-composite.cjs');
+    if (fs.existsSync(compositeLib)) {
+      const { removeProvider } = require(compositeLib);
+      removeProvider();
+    }
+  } catch { /* best effort */ }
+
+  // 2. settings.json — mirror uninstall.js logic.
+  try {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    let changed = false;
+    for (const name of ['gsd', 'gsd-lite']) {
+      if (settings.mcpServers?.[name]) { delete settings.mcpServers[name]; changed = true; }
+      const pluginKey = `${name}@${name}`;
+      if (settings.enabledPlugins?.[pluginKey]) { delete settings.enabledPlugins[pluginKey]; changed = true; }
+      if (settings.extraKnownMarketplaces?.[name]) { delete settings.extraKnownMarketplaces[name]; changed = true; }
+    }
+    if (settings.extraKnownMarketplaces && Object.keys(settings.extraKnownMarketplaces).length === 0) {
+      delete settings.extraKnownMarketplaces;
+    }
+    if (settings.statusLine?.command?.includes('gsd-statusline')
+        || settings.statusLine?.command?.includes('context-monitor.js')) {
+      delete settings.statusLine;
+      changed = true;
+    }
+    if (settings.hooks) {
+      if (typeof settings.hooks.StatusLine === 'string'
+          && (settings.hooks.StatusLine.includes('gsd-statusline')
+              || settings.hooks.StatusLine.includes('context-monitor.js'))) {
+        delete settings.hooks.StatusLine;
+        changed = true;
+      }
+      for (const [hookType, identifier] of [
+        ['PostToolUse', 'gsd-context-monitor'],
+        ['PostToolUse', 'context-monitor.js'],
+        ['SessionStart', 'gsd-session-init'],
+        ['Stop', 'gsd-session-stop'],
+      ]) {
+        if (Array.isArray(settings.hooks[hookType])) {
+          const before = 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 < before) 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) atomicWriteJson(settingsPath, settings);
+  } catch { /* best effort */ }
+
+  // 3. plugins/known_marketplaces.json
+  try {
+    const known = path.join(claudeDir, 'plugins', 'known_marketplaces.json');
+    const data = JSON.parse(fs.readFileSync(known, 'utf8'));
+    let dirty = false;
+    for (const n of ['gsd', 'gsd-lite']) {
+      if (n in data) { delete data[n]; dirty = true; }
+    }
+    if (dirty) atomicWriteJson(known, data);
+  } catch { /* best effort */ }
+
+  // 4. Hook script files
+  for (const name of ['context-monitor.js', 'gsd-statusline.cjs', 'gsd-context-monitor.cjs', 'gsd-auto-update.cjs', 'gsd-session-stop.cjs']) {
+    try { fs.rmSync(path.join(claudeDir, 'hooks', name), { force: true }); } catch { /* best effort */ }
+  }
+  // 5. Hook lib files (GSD-owned only — don't touch other plugins' libs)
+  for (const lib of ['gsd-finder.cjs', 'statusline-composite.cjs', 'semver-sort.cjs']) {
+    try { fs.rmSync(path.join(claudeDir, 'hooks', 'lib', lib), { force: true }); } catch { /* best effort */ }
+  }
+  // 6. Runtime dir + plugin marketplace + cache dirs (current + legacy names)
+  for (const dir of [
+    path.join(claudeDir, 'gsd'),
+    path.join(claudeDir, 'gsd-lite'),
+    path.join(claudeDir, 'plugins', 'marketplaces', 'gsd'),
+    path.join(claudeDir, 'plugins', 'marketplaces', 'gsd-lite'),
+    path.join(claudeDir, 'plugins', 'cache', 'gsd'),
+    path.join(claudeDir, 'plugins', 'cache', 'gsd-lite'),
+  ]) {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
+  }
+  // 7. Self-removal — delete this script last. The running process keeps the
+  //    file handle until exit (POSIX); on Windows this may fail silently and
+  //    Phase 0's next-session check will retry.
+  try { fs.rmSync(path.join(claudeDir, 'hooks', 'gsd-session-init.cjs'), { force: true }); } catch { /* best effort */ }
+}
+
+if (isOrphan()) {
+  console.log('⚠ GSD-Lite plugin uninstalled — cleaning up orphaned hooks and runtime.');
+  try { cleanupOrphan(); } catch { /* best effort — never block session start */ }
+  process.exit(0);
+}
+
 // Safety: exit after 4s regardless (hook timeout is 5s)
 setTimeout(() => process.exit(0), 4000).unref();
 

package/install.js

@@ -211,6 +211,11 @@ export function main() {
   // 6. Stable runtime for MCP server
   copyDir(join(__dirname, 'src'), join(RUNTIME_DIR, 'src'), 'runtime/src → ~/.claude/gsd/src/');
   copyFile(join(__dirname, 'package.json'), join(RUNTIME_DIR, 'package.json'), 'runtime/package.json → ~/.claude/gsd/package.json');
+  // Copy uninstall.js so the SessionStart hook's Phase 0 orphan-cleanup can
+  // spawn it when /plugin uninstall has removed the plugin without running our
+  // uninstaller. Without this, hooks/runtime/settings.json entries written by
+  // install.js outlive the plugin and keep firing.
+  copyFile(join(__dirname, 'uninstall.js'), join(RUNTIME_DIR, 'uninstall.js'), 'runtime/uninstall.js → ~/.claude/gsd/uninstall.js');
   // Copy lock file so `npm ci` works when node_modules are not present (npx scenario)
   const lockFile = join(__dirname, 'package-lock.json');
   if (existsSync(lockFile)) {
@@ -289,6 +294,27 @@ export function main() {
     if (statusLineRegistered || hooksRegistered) {
       log('  ✓ GSD-Lite hooks registered in settings.json');
     }
+
+    // Record install mode so SessionStart's Phase 0 orphan-cleanup can
+    // distinguish "plugin uninstalled" from "npx install". Without this marker
+    // the hook falls back to the .orphaned_at cache heuristic, which is fine
+    // for pre-marker users but more guess-y.
+    try {
+      const installModeMarker = join(RUNTIME_DIR, '.install-mode');
+      writeFileSync(installModeMarker, (isPluginInstall ? 'plugin' : 'manual') + '\n');
+    } catch { /* best effort — marker missing falls back to heuristic */ }
+
+    // Clear stale .orphaned_at from the current plugin cache version, in case
+    // the user previously uninstalled (Claude Code stamps it) and is now
+    // reinstalling via /plugin. Leaving it would make orphan-cleanup mis-fire
+    // on the next session.
+    if (isPluginInstall) {
+      try {
+        const currentVersion = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf-8')).version;
+        const orphanMarker = join(CLAUDE_DIR, 'plugins', 'cache', 'gsd', 'gsd', currentVersion, '.orphaned_at');
+        if (existsSync(orphanMarker)) rmSync(orphanMarker, { force: true });
+      } catch { /* best effort */ }
+    }
   } else {
     log('  [dry-run] Would register MCP server in settings.json');
   }

package/package.json

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

package/src/server.js

@@ -144,7 +144,7 @@ const TOOLS = [
         },
         run_verify: {
           type: 'boolean',
-          description: 'When true, run lint/typecheck/test during handoff evaluation',
+          description: 'Assert that verification was run externally; if true without a verification object, returns INVALID_INPUT. The state layer does not execute external tools.',
         },
         direction_ok: {
           type: 'boolean',

package/src/tools/orchestrator/executor.js

@@ -1,4 +1,4 @@
-import { read, reclassifyReviewLevel } from '../state/index.js';
+import { read, reclassifyReviewLevel, selectRunnableTask } from '../state/index.js';
 import { validateExecutorResult } from '../../schema.js';
 import {
   MAX_DEBUG_RETRY,
@@ -101,8 +101,20 @@ export async function handleExecutorResult({ result, basePath = process.cwd() }
 
   if (result.outcome === 'blocked') {
     const { blocked_reason, unblock_condition } = getBlockedReasonFromResult(result);
+    // Probe whether other tasks remain runnable after this one is blocked.
+    // Design (docs/gsd-lite-design.md §1399): awaiting_user fires only when
+    // 0 runnable tasks remain — blocked-with-others-runnable continues execution.
+    const probePhase = {
+      ...phase,
+      todo: phase.todo.map((t) => (t.id === task.id
+        ? { ...t, lifecycle: 'blocked', blocked_reason, unblock_condition }
+        : t)),
+    };
+    const probe = selectRunnableTask(probePhase, state);
+    const hasOtherRunnable = !!probe?.task;
+
     const persistError = await persist(basePath, {
-      workflow_mode: 'awaiting_user',
+      workflow_mode: hasOtherRunnable ? 'executing_task' : 'awaiting_user',
       current_task: null,
       current_review: null,
       phases: [{
@@ -120,8 +132,8 @@ export async function handleExecutorResult({ result, basePath = process.cwd() }
 
     return {
       success: true,
-      action: 'awaiting_user',
-      workflow_mode: 'awaiting_user',
+      action: hasOtherRunnable ? 'continue_execution' : 'awaiting_user',
+      workflow_mode: hasOtherRunnable ? 'executing_task' : 'awaiting_user',
       task_id: task.id,
       blockers: getBlockedTasks({ todo: [{ id: task.id, lifecycle: 'blocked', blocked_reason, unblock_condition }] }),
     };

package/src/tools/state/crud.js

@@ -511,6 +511,13 @@ export async function phaseComplete({
       ? verificationPassed(verificationResult)
       : phase.phase_handoff.tests_passed === true;
     if (!testsPassed) {
+      if (!verificationResult) {
+        return {
+          error: true,
+          code: ERROR_CODES.HANDOFF_GATE,
+          message: 'Handoff gate not met: verification required. Run lint/typecheck/test externally, then call phase-complete with verification: { lint: { exit_code }, typecheck: { exit_code }, test: { exit_code } }',
+        };
+      }
       return {
         error: true,
         code: ERROR_CODES.HANDOFF_GATE,

package/workflows/execution-flow.md

@@ -163,21 +163,16 @@
 | `await_recovery_decision` | 工作流处于 failed 状态。向用户展示失败信息和恢复选项 (retry/skip/replan) |
 
 **`phase-complete` 参数:**
+
+编排器必须先用 Bash 外部执行 lint/typecheck/test (state 层不自动跑外部工具)，然后把结果作为 `verification` 传入:
 ```
 phase-complete({
   phase_id: <当前 phase 编号>,
-  run_verify: true,          // 自动运行 lint/typecheck/test
-  direction_ok: true         // 方向校验通过 (如有偏差设为 false)
-})
-```
-如果没有 lint/typecheck/test 工具，可改用 `verification` 参数传入预计算结果:
-```
-phase-complete({
-  phase_id: <phase>,
   verification: { lint: {exit_code: 0}, typecheck: {exit_code: 0}, test: {exit_code: 0} },
-  direction_ok: true
+  direction_ok: true         // 方向校验通过 (如有偏差设为 false)
 })
 ```
+`run_verify: true` 只是声明"已外部跑过"，不提供 `verification` 时会返回 INVALID_INPUT，用于防止调用方忘记传结果。如果项目缺少某项脚本 (例如无 typecheck)，跑对应工具时返回 0 视为通过即可 (约定: "命令不存在" = 不适用 = 通过)。
 </execution_loop>
 
 ## STEP 12 — 最终报告