gsd-lite 0.6.1 → 0.6.3

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

package/.claude-plugin/plugin.json

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

package/hooks/gsd-auto-update.cjs

@@ -286,6 +286,7 @@ async function fetchLatestRelease(token) {
     if (!res.ok) return null;
 
     const data = await res.json();
+    if (!data.tag_name || !data.tarball_url) return null;
     return {
       version: data.tag_name.replace(/^v/, ''),
       tarballUrl: data.tarball_url,

package/hooks/gsd-session-init.cjs

@@ -13,10 +13,8 @@ const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
 
-const pluginRoot = path.resolve(__dirname, '..');
 const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
 const settingsPath = path.join(claudeDir, 'settings.json');
-const statuslineScript = path.join(pluginRoot, 'hooks', 'gsd-statusline.cjs');
 
 // Safety: exit after 4s regardless (hook timeout is 5s)
 setTimeout(() => process.exit(0), 4000).unref();
@@ -49,21 +47,38 @@ setTimeout(() => process.exit(0), 4000).unref();
   } catch { /* silent */ }
 
   // ── Phase 2: StatusLine auto-registration ──
+  // StatusLine is a top-level settings.json config that the plugin system
+  // (hooks.json) cannot manage. Self-heal if not registered.
   try {
-    if (fs.existsSync(statuslineScript)) {
+    const stableStatuslinePath = path.join(claudeDir, 'hooks', 'gsd-statusline.cjs');
+    if (fs.existsSync(stableStatuslinePath)) {
       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);
+      if (settings) {
+        const current = settings.statusLine?.command || '';
+
+        if (current.includes('gsd-statusline')) {
+          // Already registered — nothing to do
+        } else if (!current) {
+          // No statusLine — register directly
+          settings.statusLine = {
+            type: 'command',
+            command: `node ${JSON.stringify(stableStatuslinePath)}`
+          };
+          const tmpPath = settingsPath + `.gsd-tmp-${process.pid}`;
+          fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + '\n');
+          fs.renameSync(tmpPath, settingsPath);
+        } else if (current.includes('statusline-composite')) {
+          // Composite system (e.g., code-graph) — register as provider
+          try {
+            const { registerProvider } = require('./lib/statusline-composite.cjs');
+            registerProvider(stableStatuslinePath);
+          } catch { /* composite helper not available */ }
+        }
+        // else: some other statusLine, don't overwrite
       }
     }
   } catch { /* silent */ }

package/hooks/lib/statusline-composite.cjs

@@ -0,0 +1,110 @@
+'use strict';
+// Detect and register with composite statusline systems (e.g., code-graph).
+// Used by install.js, gsd-session-init.cjs, and uninstall.js.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+// Known composite statusline registry paths
+const REGISTRY_PATHS = [
+  path.join(os.homedir(), '.cache', 'code-graph', 'statusline-registry.json'),
+];
+
+function isCompositeStatusLine(command) {
+  return typeof command === 'string' && command.includes('statusline-composite');
+}
+
+function findCompositeRegistry() {
+  for (const p of REGISTRY_PATHS) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+/**
+ * Register GSD as a provider in the composite statusline registry.
+ * Idempotent: updates existing entry or inserts before code-graph.
+ * @param {string} statuslineScriptPath - Absolute path to gsd-statusline.cjs
+ * @returns {boolean} true if registered/updated
+ */
+function registerProvider(statuslineScriptPath) {
+  let registryPath = findCompositeRegistry();
+
+  // If composite statusLine is configured but registry file is missing,
+  // create it if the parent directory exists (e.g., code-graph installed
+  // but registry was deleted or not yet created).
+  if (!registryPath) {
+    for (const candidate of REGISTRY_PATHS) {
+      const dir = path.dirname(candidate);
+      if (fs.existsSync(dir)) {
+        registryPath = candidate;
+        break;
+      }
+    }
+    if (!registryPath) return false;
+  }
+
+  try {
+    let registry;
+    try {
+      registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    } catch {
+      registry = []; // File missing or corrupt — start fresh
+    }
+    if (!Array.isArray(registry)) return false;
+
+    const command = `node ${JSON.stringify(statuslineScriptPath)}`;
+    const provider = { id: 'gsd', command, needsStdin: true };
+
+    // Find existing GSD entry (by id or command)
+    const idx = registry.findIndex(p =>
+      p.id === 'gsd' || p.command?.includes('gsd-statusline'));
+
+    if (idx >= 0) {
+      registry[idx] = provider;
+    } else {
+      // Insert before code-graph for display priority
+      const cgIdx = registry.findIndex(p => p.id === 'code-graph');
+      if (cgIdx >= 0) registry.splice(cgIdx, 0, provider);
+      else registry.unshift(provider);
+    }
+
+    // Atomic write
+    const tmp = registryPath + `.${process.pid}-${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(registry, null, 2) + '\n');
+    fs.renameSync(tmp, registryPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove GSD entry from composite statusline registry.
+ * @returns {boolean} true if an entry was removed
+ */
+function removeProvider() {
+  const registryPath = findCompositeRegistry();
+  if (!registryPath) return false;
+
+  try {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+    if (!Array.isArray(registry)) return false;
+
+    const idx = registry.findIndex(p =>
+      p.id === 'gsd' || p.command?.includes('gsd-statusline'));
+    if (idx < 0) return false;
+
+    registry.splice(idx, 1);
+
+    const tmp = registryPath + `.${process.pid}-${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(registry, null, 2) + '\n');
+    fs.renameSync(tmp, registryPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { isCompositeStatusLine, findCompositeRegistry, registerProvider, removeProvider };

package/install.js

@@ -11,6 +11,7 @@ import { createRequire } from 'node:module';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const _require = createRequire(import.meta.url);
 const { semverSortComparator } = _require('./hooks/lib/semver-sort.cjs');
+const { isCompositeStatusLine, registerProvider: registerCompositeProvider } = _require('./hooks/lib/statusline-composite.cjs');
 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');
@@ -39,16 +40,35 @@ function isInstalledAsPlugin(claudeDir) {
 
 function registerStatusLine(settings, statuslineScriptPath) {
   const command = `node ${JSON.stringify(statuslineScriptPath)}`;
-  // Don't overwrite non-GSD statusLine
-  if (settings.statusLine && typeof settings.statusLine === 'object'
-      && !settings.statusLine.command?.includes('gsd-statusline')) {
-    log('  ! Preserved existing statusLine');
-    return false;
-  }
-  settings.statusLine = { type: 'command', command };
+
   // Clean up legacy format (was incorrectly placed in hooks)
   if (settings.hooks?.StatusLine) delete settings.hooks.StatusLine;
-  return true;
+
+  const current = settings.statusLine?.command || '';
+
+  // Already GSD → update command path
+  if (current.includes('gsd-statusline')) {
+    settings.statusLine = { type: 'command', command };
+    return true;
+  }
+
+  // No statusLine → set GSD directly
+  if (!current) {
+    settings.statusLine = { type: 'command', command };
+    return true;
+  }
+
+  // Composite statusLine (e.g., code-graph) → register as provider
+  if (isCompositeStatusLine(current)) {
+    if (registerCompositeProvider(statuslineScriptPath)) {
+      log('  ✓ Registered GSD in composite statusLine registry');
+      return true;
+    }
+  }
+
+  // Other statusLine → don't overwrite
+  log('  ! Preserved existing statusLine');
+  return false;
 }
 
 function registerHookEntry(hooks, { hookType, identifier, matcher, timeout }) {
@@ -170,8 +190,13 @@ export function main() {
     copyDir(localNM, join(RUNTIME_DIR, 'node_modules'), 'runtime/node_modules (copied)');
   } else if (!DRY_RUN) {
     log('  ⧗ Installing runtime dependencies...');
-    execSync('npm ci --omit=dev', { cwd: RUNTIME_DIR, stdio: 'pipe' });
-    log('  ✓ runtime dependencies installed');
+    try {
+      execSync('npm ci --omit=dev', { cwd: RUNTIME_DIR, stdio: 'pipe' });
+      log('  ✓ runtime dependencies installed');
+    } catch (err) {
+      log(`  ✗ Failed to install runtime dependencies: ${err.message}`);
+      process.exit(1);
+    }
   } else {
     log('  [dry-run] Would install runtime dependencies');
   }
@@ -209,15 +234,16 @@ export function main() {
       log('  ✓ MCP server registered in settings.json');
     }
 
-    // Register statusLine (top-level setting) and hooks
-    // When installed as a plugin, hooks are managed by hooks.json via the plugin system.
+    // StatusLine is a top-level setting that the plugin system (hooks.json)
+    // cannot manage. Always register, regardless of install method.
+    const statuslinePath = join(CLAUDE_DIR, 'hooks', 'gsd-statusline.cjs');
+    let statusLineRegistered = registerStatusLine(settings, statuslinePath);
+
+    // Hooks are managed by hooks.json via the plugin system for plugin installs.
     // Only register in settings.json for manual installs to avoid double execution.
-    let statusLineRegistered = false;
     let hooksRegistered = false;
     if (!isPluginInstall) {
       if (!settings.hooks) settings.hooks = {};
-      const statuslinePath = join(CLAUDE_DIR, 'hooks', 'gsd-statusline.cjs');
-      statusLineRegistered = registerStatusLine(settings, statuslinePath);
       for (const config of HOOK_REGISTRY) {
         if (registerHookEntry(settings.hooks, config)) hooksRegistered = true;
       }

package/package.json

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

package/src/tools/orchestrator/helpers.js

@@ -208,20 +208,11 @@ async function evaluatePreflight(state, basePath) {
     }
   }
 
-  const expired_research = collectExpiredResearch(state);
-  if (expired_research.length > 0) {
-    hints.push({
-      workflow_mode: 'research_refresh_needed',
-      action: 'dispatch_researcher',
-      updates: { workflow_mode: 'research_refresh_needed' },
-      expired_research,
-      message: 'Research cache expired and must be refreshed before execution resumes',
-    });
-  }
-
-  // P0-2: Dirty-phase detection — rollback current_phase to earliest phase
+  // Dirty-phase detection — rollback current_phase to earliest phase
   // that has needs_revalidation tasks, ensuring earlier invalidated work
   // is re-executed before proceeding with later phases.
+  // Priority: placed before research expiry because dirty-phase rollback is a
+  // safety-critical action (prevents executing later phases on stale foundations).
   // Use filter+reduce (not .find) to guarantee lowest-ID match regardless of array order.
   const dirtyPhases = (state.phases || []).filter(p =>
     p.id < state.current_phase
@@ -245,6 +236,17 @@ async function evaluatePreflight(state, basePath) {
     });
   }
 
+  const expired_research = collectExpiredResearch(state);
+  if (expired_research.length > 0) {
+    hints.push({
+      workflow_mode: 'research_refresh_needed',
+      action: 'dispatch_researcher',
+      updates: { workflow_mode: 'research_refresh_needed' },
+      expired_research,
+      message: 'Research cache expired and must be refreshed before execution resumes',
+    });
+  }
+
   if (hints.length === 0) return { override: null };
 
   return {

package/src/tools/orchestrator/resume.js

@@ -53,7 +53,7 @@ function _buildResumeSummary(state, response) {
   };
 }
 
-async function resumeAwaitingClear(state, basePath) {
+async function resumeAwaitingClear(state, basePath, _depth = 0) {
   const health = await readContextHealth(basePath);
   if (health !== null && health < CONTEXT_RESUME_THRESHOLD) {
     const persistError = await persist(basePath, {
@@ -83,7 +83,7 @@ async function resumeAwaitingClear(state, basePath) {
   }
   const persistError = await persist(basePath, updates);
   if (persistError) return persistError;
-  return resumeWorkflow({ basePath });
+  return resumeWorkflow({ basePath, _depth: _depth + 1 });
 }
 
 async function resumeExecutingTask(state, basePath) {
@@ -319,7 +319,7 @@ export async function resumeWorkflow({ basePath = process.cwd(), _depth = 0, unb
         result = await resumeExecutingTask(state, basePath);
         break;
       case 'awaiting_clear':
-        result = await resumeAwaitingClear(state, basePath);
+        result = await resumeAwaitingClear(state, basePath, _depth);
         break;
       case 'awaiting_user': {
         if (state.current_review?.stage === 'direction_drift') {

package/src/tools/orchestrator/reviewer.js

@@ -74,6 +74,23 @@ export async function handleReviewerResult({ result, basePath = process.cwd() }
   const qualityFailed = result.quality_passed === false;
   const needsRework = hasCritical || specFailed || qualityFailed;
 
+  // Safety: if rework is needed but no tasks were targeted for rework,
+  // fall back to marking all non-accepted checkpointed/accepted tasks as needs_revalidation
+  // to prevent infinite review loops (no runnable tasks → trigger_review → same result).
+  if (needsRework && taskPatches.filter(p => p.lifecycle === 'needs_revalidation').length === 0) {
+    for (const task of (phase.todo || [])) {
+      if (task.lifecycle === 'checkpointed' || task.lifecycle === 'accepted') {
+        taskPatches.push({
+          id: task.id,
+          lifecycle: 'needs_revalidation',
+          retry_count: 0,
+          evidence_refs: [],
+          last_review_feedback: ['Reviewer indicated rework needed but did not specify tasks; all completed tasks require revalidation'],
+        });
+      }
+    }
+  }
+
   // Compute retry count once for both exhaustion check and state update
   const currentRetryCount = phase.phase_review?.retry_count || 0;
   const nextRetryCount = needsRework ? currentRetryCount + 1 : 0;

package/src/tools/state/crud.js

@@ -251,6 +251,11 @@ export async function update({ updates, basePath = process.cwd(), expectedVersio
     // Deep merge phases by ID instead of shallow replace [I-1]
     const merged = { ...state, ...updates };
 
+    // Deep merge context by key (preserves plan_hashes, last_session, etc.)
+    if (updates.context && isPlainObject(updates.context)) {
+      merged.context = { ...(state.context || {}), ...updates.context };
+    }
+
     // Deep merge evidence by key (preserves existing entries)
     if (updates.evidence && isPlainObject(updates.evidence)) {
       merged.evidence = { ...(state.evidence || {}), ...updates.evidence };
@@ -326,10 +331,13 @@ export async function update({ updates, basePath = process.cwd(), expectedVersio
       await _pruneEvidenceFromState(merged, merged.current_phase, gsdDir);
     }
 
-    // Use incremental validation for simple updates (no phases changes)
-    const validation = !updates.phases
-      ? validateStateUpdate(state, updates)
-      : validateState(merged);
+    // Use incremental validation for simple updates (no phases/propagation/decisions changes)
+    const needsFullValidation = updates.phases
+      || (_append_decisions?.length > 0)
+      || (_propagation_tasks?.length > 0);
+    const validation = needsFullValidation
+      ? validateState(merged)
+      : validateStateUpdate(state, updates);
     if (!validation.valid) {
       return {
         error: true,
@@ -495,6 +503,7 @@ export async function phaseComplete({
       if (!driftValidation.valid) {
         return { error: true, code: ERROR_CODES.VALIDATION_FAILED, message: `Validation failed: ${driftValidation.errors.join('; ')}` };
       }
+      state._version = (state._version ?? 0) + 1;
       await writeJson(statePath, state);
       return {
         success: true,
@@ -525,6 +534,8 @@ export async function phaseComplete({
     } else if (state.current_phase === phase_id && phase_id >= state.total_phases) {
       // Final phase completed — mark workflow as completed
       state.workflow_mode = 'completed';
+      state.current_task = null;
+      state.current_review = null;
     }
 
     // Update git_head to current commit
@@ -539,6 +550,7 @@ export async function phaseComplete({
     if (!finalValidation.valid) {
       return { error: true, code: ERROR_CODES.VALIDATION_FAILED, message: `Validation failed: ${finalValidation.errors.join('; ')}` };
     }
+    state._version = (state._version ?? 0) + 1;
     await writeJson(statePath, state);
     return { success: true };
   });
@@ -570,7 +582,7 @@ export async function addEvidence({ id, data, basePath = process.cwd() }) {
     if (!result.ok) {
       return { error: true, code: ERROR_CODES.NO_PROJECT_DIR, message: result.error };
     }
-    const state = result.data;
+    const state = migrateState(result.data);
 
     if (!state.evidence) {
       state.evidence = {};
@@ -585,6 +597,7 @@ export async function addEvidence({ id, data, basePath = process.cwd() }) {
       await _pruneEvidenceFromState(state, state.current_phase, gsdDir);
     }
 
+    state._version = (state._version ?? 0) + 1;
     await writeJson(statePath, state);
     return { success: true };
   });
@@ -650,11 +663,14 @@ export async function pruneEvidence({ currentPhase, basePath = process.cwd() })
     if (!result.ok) {
       return { error: true, code: ERROR_CODES.NO_PROJECT_DIR, message: result.error };
     }
-    const state = result.data;
+    const state = migrateState(result.data);
 
     const gsdDir = dirname(statePath);
     const archived = await _pruneEvidenceFromState(state, currentPhase, gsdDir);
-    if (archived > 0) await writeJson(statePath, state);
+    if (archived > 0) {
+      state._version = (state._version ?? 0) + 1;
+      await writeJson(statePath, state);
+    }
 
     return { success: true, archived };
   });
@@ -734,6 +750,7 @@ export async function patchPlan({ operations, basePath = process.cwd() } = {}) {
       return { error: true, code: ERROR_CODES.VALIDATION_FAILED, message: `Validation failed: ${validation.errors.join('; ')}` };
     }
 
+    state._version = (state._version ?? 0) + 1;
     await writeJson(statePath, state);
     return { success: true, applied, plan_version: state.plan_version };
   });

package/src/tools/state/logic.js

@@ -5,6 +5,7 @@ import { writeFile, rename, unlink } from 'node:fs/promises';
 import { ensureDir, readJson, writeJson, getStatePath } from '../../utils.js';
 import {
   TASK_LIFECYCLE,
+  migrateState,
   validateResearchArtifacts,
   validateResearchDecisionIndex,
   validateResearcherResult,
@@ -439,7 +440,7 @@ export async function storeResearch({ result, artifacts, decision_index, basePat
       return { error: true, code: ERROR_CODES.NO_PROJECT_DIR, message: current.error };
     }
 
-    const state = current.data;
+    const state = migrateState(current.data);
     const gsdDir = dirname(statePath);
     const researchDir = join(gsdDir, 'research');
     await ensureDir(researchDir);
@@ -503,6 +504,7 @@ export async function storeResearch({ result, artifacts, decision_index, basePat
       return { error: true, code: ERROR_CODES.VALIDATION_FAILED, message: `State validation failed: ${validation.errors.join('; ')}` };
     }
 
+    state._version = (state._version ?? 0) + 1;
     await writeJson(statePath, state);
     return {
       success: true,

package/uninstall.js

@@ -5,6 +5,7 @@ import { existsSync, rmSync, readFileSync, writeFileSync, renameSync } from 'nod
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
 
 const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
 const RUNTIME_DIR = join(CLAUDE_DIR, 'gsd');
@@ -27,6 +28,16 @@ function removeDir(path, label) {
 export function main() {
   log('GSD-Lite Uninstaller\n');
 
+  // Clean up GSD entry from composite statusLine registry before removing files
+  try {
+    const _require = createRequire(import.meta.url);
+    const compositeLib = join(CLAUDE_DIR, 'hooks', 'lib', 'statusline-composite.cjs');
+    if (existsSync(compositeLib)) {
+      const { removeProvider } = _require(compositeLib);
+      if (removeProvider()) log('  ✓ Removed GSD from composite statusLine registry');
+    }
+  } catch { /* best effort */ }
+
   log('Removing files...');
 
   removeDir(join(CLAUDE_DIR, 'commands', 'gsd'), 'commands/gsd/');
@@ -49,10 +60,12 @@ export function main() {
   const hookLibDir = join(CLAUDE_DIR, 'hooks', 'lib');
   if (existsSync(hookLibDir)) {
     // Only remove GSD-owned files, not other plugins' libs
-    const gsdLibFile = join(hookLibDir, 'gsd-finder.cjs');
-    if (existsSync(gsdLibFile)) {
-      rmSync(gsdLibFile);
-      log('  ✓ Removed hooks/lib/gsd-finder.cjs');
+    for (const libFile of ['gsd-finder.cjs', 'statusline-composite.cjs', 'semver-sort.cjs']) {
+      const fullPath = join(hookLibDir, libFile);
+      if (existsSync(fullPath)) {
+        rmSync(fullPath);
+        log(`  ✓ Removed hooks/lib/${libFile}`);
+      }
     }
   }