gsd-lite 0.5.2 → 0.5.4

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

package/.claude-plugin/plugin.json

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

package/commands/doctor.md

@@ -19,7 +19,7 @@ Check if `.gsd/state.json` exists:
 
 ## STEP 2: MCP Server Health
 
-Call the `gsd health` MCP tool:
+Call the `health` MCP tool:
 - If returns `status: "ok"`: record PASS with server version
 - If returns error or unreachable: record FAIL with error message
 - Note: if MCP server is not available at all (tool not found), record FAIL "MCP server not registered"
@@ -51,7 +51,7 @@ Check if `.gsd/.state-lock` exists:
 
 Check for update-related information:
 - Read `~/.claude/gsd/package.json` for installed version
-- Compare with the version from `gsd health` tool response
+- Compare with the version from `health` tool response
 - If versions match: record PASS with version number
 - If mismatch: record WARN "Version mismatch: installed={x}, server={y}"
 - If `~/.claude/gsd/.update-pending` exists: record INFO "Update pending, will apply on next session"

package/commands/start.md

@@ -12,7 +12,7 @@ argument-hint: Optional feature or project description
 
 ## STEP 0 — 已有项目检测
 
-调用 `gsd health` 工具。如果返回 state_exists=true:
+调用 `health` 工具（MCP tool 名称: health）。如果返回 state_exists=true:
 - 告知用户: "检测到进行中的 GSD 项目。"
 - 提供选项:
   - (a) 恢复执行 → 转到 `/gsd:resume`

package/hooks/gsd-statusline.cjs

@@ -60,10 +60,11 @@ process.stdin.on('end', () => {
 
     // Context window display (USED percentage scaled to usable context)
     // Claude Code reserves ~16.5% for autocompact buffer (configurable via env)
-    const AUTO_COMPACT_BUFFER_PCT = Number(process.env.GSD_AUTOCOMPACT_BUFFER) || 16.5;
+    const AUTO_COMPACT_BUFFER_PCT = Math.min(99, Math.max(0, Number(process.env.GSD_AUTOCOMPACT_BUFFER) || 16.5));
     let ctx = '';
     if (remaining != null) {
-      const usableRemaining = Math.max(0, ((remaining - AUTO_COMPACT_BUFFER_PCT) / (100 - AUTO_COMPACT_BUFFER_PCT)) * 100);
+      const divisor = 100 - AUTO_COMPACT_BUFFER_PCT;
+      const usableRemaining = divisor > 0 ? Math.max(0, ((remaining - AUTO_COMPACT_BUFFER_PCT) / divisor) * 100) : 0;
       const used = Math.max(0, Math.min(100, Math.round(100 - usableRemaining)));
 
       // Write bridge file for context-monitor PostToolUse hook (skip if remaining unchanged)
@@ -73,7 +74,7 @@ process.stdin.on('end', () => {
           let needsWrite = true;
           try {
             const existing = JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
-            if (existing.remaining_percentage === remaining) needsWrite = false;
+            if (existing.remaining_percentage === remaining && existing.has_gsd === hasGsd) needsWrite = false;
           } catch { /* no existing file */ }
           if (needsWrite) {
             const tmpBridge = bridgePath + '.tmp';

package/package.json

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

package/src/schema.js

@@ -17,6 +17,23 @@ export const WORKFLOW_MODES = [
   'failed',
 ];
 
+// Valid workflow_mode transitions — unlisted transitions are rejected by validateStateUpdate.
+// Terminal states (completed, failed) are guarded separately by the FROM-terminal check in state-update.
+export const WORKFLOW_TRANSITIONS = {
+  planning:                 ['executing_task', 'paused_by_user'],
+  executing_task:           ['planning', 'reviewing_task', 'reviewing_phase', 'awaiting_user', 'awaiting_clear', 'paused_by_user', 'reconcile_workspace', 'replan_required', 'research_refresh_needed', 'failed'],
+  reviewing_task:           ['executing_task', 'reviewing_phase', 'awaiting_user', 'awaiting_clear', 'paused_by_user', 'failed'],
+  reviewing_phase:          ['executing_task', 'awaiting_user', 'awaiting_clear', 'paused_by_user', 'completed', 'failed'],
+  awaiting_user:            ['executing_task', 'reviewing_task', 'reviewing_phase', 'paused_by_user', 'awaiting_clear'],
+  awaiting_clear:           ['executing_task', 'paused_by_user'],
+  paused_by_user:           ['executing_task', 'awaiting_user', 'awaiting_clear', 'reconcile_workspace', 'replan_required', 'research_refresh_needed', 'reviewing_task', 'reviewing_phase'],
+  reconcile_workspace:      ['executing_task', 'paused_by_user'],
+  replan_required:          ['executing_task', 'paused_by_user'],
+  research_refresh_needed:  ['executing_task', 'reviewing_task', 'reviewing_phase', 'paused_by_user'],
+  completed:                [],  // terminal — guarded by FROM-terminal check
+  failed:                   [],  // terminal — guarded by FROM-terminal check
+};
+
 export const TASK_LIFECYCLE = {
   pending:              ['running', 'blocked'],
   running:              ['checkpointed', 'blocked', 'failed', 'accepted'], // accepted: auto-accept for L0/review_required=false (atomic, skips checkpointed)
@@ -154,11 +171,28 @@ export function validateStateUpdate(state, updates) {
 
   for (const key of Object.keys(updates)) {
     switch (key) {
-      case 'workflow_mode':
+      case 'workflow_mode': {
         if (!WORKFLOW_MODES.includes(updates.workflow_mode)) {
           errors.push(`Invalid workflow_mode: ${updates.workflow_mode}`);
+          break;
+        }
+        // Transition whitelist — reject unlisted transitions
+        const currentMode = state.workflow_mode;
+        if (currentMode && updates.workflow_mode !== currentMode) {
+          const allowed = WORKFLOW_TRANSITIONS[currentMode];
+          if (allowed && !allowed.includes(updates.workflow_mode)) {
+            errors.push(`Invalid workflow_mode transition: '${currentMode}' → '${updates.workflow_mode}' (allowed: ${allowed.join(', ') || 'none (terminal state)'})`);
+          }
+        }
+        // Guard: 'completed' requires all phases accepted
+        if (updates.workflow_mode === 'completed' && Array.isArray(state.phases)) {
+          const unfinished = state.phases.filter(p => p.lifecycle !== 'accepted');
+          if (unfinished.length > 0) {
+            errors.push(`Cannot set workflow_mode to 'completed': ${unfinished.length} phase(s) not accepted (${unfinished.map(p => `${p.id}:${p.lifecycle}`).join(', ')})`);
+          }
         }
         break;
+      }
       case 'current_phase':
         if (!Number.isFinite(updates.current_phase)) {
           errors.push('current_phase must be a finite number');
@@ -383,8 +417,12 @@ export function validateState(state) {
       }
     }
   }
-  // P2-9: workflow_mode consistency — completed project must not have active/running tasks
+  // P2-9: workflow_mode consistency — completed project requires all phases accepted
   if (state.workflow_mode === 'completed' && Array.isArray(state.phases)) {
+    const unfinishedPhases = state.phases.filter(p => p.lifecycle !== 'accepted');
+    if (unfinishedPhases.length > 0) {
+      errors.push(`Completed project has ${unfinishedPhases.length} unfinished phase(s): ${unfinishedPhases.map(p => `${p.id}:${p.lifecycle}`).join(', ')}`);
+    }
     for (const phase of state.phases) {
       for (const task of (phase.todo || [])) {
         if (task.lifecycle === 'running') {
@@ -688,6 +726,33 @@ export function createInitialState({ project, phases }) {
     }
   }
 
+  // Validate requires references: must be structured objects with valid targets
+  for (const [pi, p] of phases.entries()) {
+    for (const [ti, t] of (p.tasks || []).entries()) {
+      const taskId = `${pi + 1}.${t.index ?? (ti + 1)}`;
+      for (const dep of (t.requires || [])) {
+        if (typeof dep === 'string') {
+          return { error: true, message: `Task ${taskId}: requires entry "${dep}" must be an object {kind: "task"|"phase", id: "..."}, not a string` };
+        }
+        if (!isPlainObject(dep) || !dep.kind || !dep.id) {
+          return { error: true, message: `Task ${taskId}: requires entries must be objects with kind ("task"|"phase") and id` };
+        }
+        if (!['task', 'phase'].includes(dep.kind)) {
+          return { error: true, message: `Task ${taskId}: requires entry kind must be "task" or "phase" (got "${dep.kind}")` };
+        }
+        if (dep.kind === 'task' && !seenIds.has(String(dep.id))) {
+          return { error: true, message: `Task ${taskId}: requires references non-existent task "${dep.id}" (valid IDs: ${[...seenIds].join(', ')})` };
+        }
+        if (dep.kind === 'phase') {
+          const phaseId = Number(dep.id);
+          if (!Number.isFinite(phaseId) || phaseId < 1 || phaseId > phases.length) {
+            return { error: true, message: `Task ${taskId}: requires references non-existent phase "${dep.id}" (valid: 1-${phases.length})` };
+          }
+        }
+      }
+    }
+  }
+
   // M-7: Detect circular dependencies within each phase (Kahn's algorithm)
   for (const [pi, p] of phases.entries()) {
     const tasks = p.tasks || [];

package/src/server.js

@@ -52,7 +52,7 @@ const TOOLS = [
                     name: { type: 'string', description: 'Task name (required)' },
                     index: { type: 'number', description: 'Task index within phase (default: auto)' },
                     level: { type: 'string', description: 'Complexity level: L0/L1/L2/L3 (default: L1)' },
-                    requires: { type: 'array', description: 'Dependency list (default: [])' },
+                    requires: { type: 'array', description: 'Dependencies: [{kind: "task"|"phase", id: "1.1", gate?: "checkpoint"|"accepted"|"phase_complete"}] (default: [])' },
                     review_required: { type: 'boolean', description: 'Whether review is needed (default: true)' },
                     verification_required: { type: 'boolean', description: 'Whether verification is needed (default: true)' },
                   },
@@ -90,7 +90,7 @@ const TOOLS = [
       properties: {
         updates: {
           type: 'object',
-          description: 'Key-value pairs of canonical fields to update',
+          description: 'Key-value pairs of canonical fields: workflow_mode, current_phase, current_task, current_review, git_head, plan_version, schema_version, total_phases, project, decisions, context, evidence, research',
         },
       },
       required: ['updates'],
@@ -105,7 +105,13 @@ const TOOLS = [
         phase_id: { type: 'number', description: 'Phase number to complete' },
         verification: {
           type: 'object',
-          description: 'Optional precomputed verification result object with lint/typecheck/test exit codes',
+          description: 'Optional precomputed verification — all three keys required, exit_code 0 = passed',
+          properties: {
+            lint: { type: 'object', properties: { exit_code: { type: 'number' } }, required: ['exit_code'] },
+            typecheck: { type: 'object', properties: { exit_code: { type: 'number' } }, required: ['exit_code'] },
+            test: { type: 'object', properties: { exit_code: { type: 'number' } }, required: ['exit_code'] },
+          },
+          required: ['lint', 'typecheck', 'test'],
         },
         run_verify: {
           type: 'boolean',
@@ -133,7 +139,10 @@ const TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        result: { type: 'object', description: 'Executor result payload' },
+        result: {
+          type: 'object',
+          description: 'Executor result: {task_id: string, outcome: "checkpointed"|"blocked"|"failed", summary: string, checkpoint_commit: string|null, files_changed: string[], decisions: [{id, summary, rationale}], blockers: [{description}], contract_changed: boolean, evidence: string[]}',
+        },
       },
       required: ['result'],
     },
@@ -144,7 +153,10 @@ const TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        result: { type: 'object', description: 'Debugger result payload' },
+        result: {
+          type: 'object',
+          description: 'Debugger result: {task_id: string, outcome: "root_cause_found"|"fix_suggested"|"failed", root_cause: string, evidence: object[], hypothesis_tested: [{hypothesis: string, result: "confirmed"|"rejected", evidence: string}], fix_direction: string, fix_attempts: integer, blockers: object[], architecture_concern: boolean}',
+        },
       },
       required: ['result'],
     },
@@ -155,9 +167,12 @@ const TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        result: { type: 'object', description: 'Researcher result payload' },
-        decision_index: { type: 'object', description: 'Decision index keyed by decision id' },
-        artifacts: { type: 'object', description: 'Markdown artifact contents keyed by file name' },
+        result: {
+          type: 'object',
+          description: 'Researcher result: {decision_ids: string[], volatility: "low"|"medium"|"high", expires_at: ISO8601 string, sources: [{id: string, type: string, ref: string}]}',
+        },
+        decision_index: { type: 'object', description: 'Decision index keyed by decision id, each value: {summary: string, source?: string, expires_at?: ISO8601}' },
+        artifacts: { type: 'object', description: 'Markdown contents keyed by filename: {STACK.md, ARCHITECTURE.md, PITFALLS.md, SUMMARY.md}' },
       },
       required: ['result', 'decision_index', 'artifacts'],
     },
@@ -168,7 +183,10 @@ const TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        result: { type: 'object', description: 'Reviewer result payload' },
+        result: {
+          type: 'object',
+          description: 'Reviewer result: {scope: "task"|"phase", scope_id: string|number, review_level: "L2"|"L1-batch", spec_passed: boolean, quality_passed: boolean, critical_issues: object[], important_issues: object[], minor_issues: object[], accepted_tasks: string[], rework_tasks: string[], evidence: object[]}',
+        },
       },
       required: ['result'],
     },

package/src/tools/state.js

@@ -341,10 +341,13 @@ function verificationPassed(verification) {
 
 function verificationSummary(verification) {
   if (!verification || typeof verification !== 'object') return 'no verification details';
-  return ['lint', 'typecheck', 'test']
-    .filter((key) => verification[key])
-    .map((key) => `${key}:${verification[key].exit_code}`)
-    .join(', ');
+  const parts = ['lint', 'typecheck', 'test'].map((key) => {
+    const v = verification[key];
+    if (!v) return `${key}:missing`;
+    if (typeof v !== 'object' || !('exit_code' in v)) return `${key}:invalid-format (expected {exit_code: number})`;
+    return `${key}:${v.exit_code === 0 ? 'pass' : `fail(${v.exit_code})`}`;
+  });
+  return parts.join(', ');
 }
 
 export async function phaseComplete({