get-shit-done-cc 1.6.2 → 1.6.4

package/agents/gsd-planner.md

@@ -1296,7 +1296,7 @@ Execute: `/gsd:execute-phase {phase}`
 
 ### Next Steps
 
-Execute: `/gsd:execute-phase {phase}`
+Execute: `/gsd:execute-phase {phase} --gaps-only`
 ```
 
 ## Revision Complete

package/bin/install.js

@@ -151,6 +151,96 @@ function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
   }
 }
 
+/**
+ * Clean up orphaned files from previous GSD versions
+ */
+function cleanupOrphanedFiles(claudeDir) {
+  const orphanedFiles = [
+    'hooks/gsd-notify.sh',  // Removed in v1.6.x
+  ];
+
+  for (const relPath of orphanedFiles) {
+    const fullPath = path.join(claudeDir, relPath);
+    if (fs.existsSync(fullPath)) {
+      fs.unlinkSync(fullPath);
+      console.log(`  ${green}✓${reset} Removed orphaned ${relPath}`);
+    }
+  }
+}
+
+/**
+ * Clean up orphaned hook registrations from settings.json
+ */
+function cleanupOrphanedHooks(settings) {
+  const orphanedHookPatterns = [
+    'gsd-notify.sh',  // Removed in v1.6.x
+  ];
+
+  let cleaned = false;
+
+  // Check all hook event types (Stop, SessionStart, etc.)
+  if (settings.hooks) {
+    for (const eventType of Object.keys(settings.hooks)) {
+      const hookEntries = settings.hooks[eventType];
+      if (Array.isArray(hookEntries)) {
+        // Filter out entries that contain orphaned hooks
+        const filtered = hookEntries.filter(entry => {
+          if (entry.hooks && Array.isArray(entry.hooks)) {
+            // Check if any hook in this entry matches orphaned patterns
+            const hasOrphaned = entry.hooks.some(h =>
+              h.command && orphanedHookPatterns.some(pattern => h.command.includes(pattern))
+            );
+            if (hasOrphaned) {
+              cleaned = true;
+              return false;  // Remove this entry
+            }
+          }
+          return true;  // Keep this entry
+        });
+        settings.hooks[eventType] = filtered;
+      }
+    }
+  }
+
+  if (cleaned) {
+    console.log(`  ${green}✓${reset} Removed orphaned hook registrations`);
+  }
+
+  return settings;
+}
+
+/**
+ * Verify a directory exists and contains files
+ */
+function verifyInstalled(dirPath, description) {
+  if (!fs.existsSync(dirPath)) {
+    console.error(`  ${yellow}✗${reset} Failed to install ${description}: directory not created`);
+    return false;
+  }
+  try {
+    const entries = fs.readdirSync(dirPath);
+    if (entries.length === 0) {
+      console.error(`  ${yellow}✗${reset} Failed to install ${description}: directory is empty`);
+      return false;
+    }
+  } catch (e) {
+    console.error(`  ${yellow}✗${reset} Failed to install ${description}: ${e.message}`);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Verify a file exists
+ */
+function verifyFileInstalled(filePath, description) {
+  if (!fs.existsSync(filePath)) {
+    console.error(`  ${yellow}✗${reset} Failed to install ${description}: file not created`);
+    return false;
+  }
+  return true;
+}
+
 /**
  * Install to the specified directory
  */
@@ -175,6 +265,12 @@ function install(isGlobal) {
 
   console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
 
+  // Track installation failures
+  const failures = [];
+
+  // Clean up orphaned files from previous versions
+  cleanupOrphanedFiles(claudeDir);
+
   // Create commands directory
   const commandsDir = path.join(claudeDir, 'commands');
   fs.mkdirSync(commandsDir, { recursive: true });
@@ -183,13 +279,21 @@ function install(isGlobal) {
   const gsdSrc = path.join(src, 'commands', 'gsd');
   const gsdDest = path.join(commandsDir, 'gsd');
   copyWithPathReplacement(gsdSrc, gsdDest, pathPrefix);
-  console.log(`  ${green}✓${reset} Installed commands/gsd`);
+  if (verifyInstalled(gsdDest, 'commands/gsd')) {
+    console.log(`  ${green}✓${reset} Installed commands/gsd`);
+  } else {
+    failures.push('commands/gsd');
+  }
 
   // Copy get-shit-done skill with path replacement
   const skillSrc = path.join(src, 'get-shit-done');
   const skillDest = path.join(claudeDir, 'get-shit-done');
   copyWithPathReplacement(skillSrc, skillDest, pathPrefix);
-  console.log(`  ${green}✓${reset} Installed get-shit-done`);
+  if (verifyInstalled(skillDest, 'get-shit-done')) {
+    console.log(`  ${green}✓${reset} Installed get-shit-done`);
+  } else {
+    failures.push('get-shit-done');
+  }
 
   // Copy agents to ~/.claude/agents (subagents must be at root level)
   // Only delete gsd-*.md files to preserve user's custom agents
@@ -216,7 +320,11 @@ function install(isGlobal) {
         fs.writeFileSync(path.join(agentsDest, entry.name), content);
       }
     }
-    console.log(`  ${green}✓${reset} Installed agents`);
+    if (verifyInstalled(agentsDest, 'agents')) {
+      console.log(`  ${green}✓${reset} Installed agents`);
+    } else {
+      failures.push('agents');
+    }
   }
 
   // Copy CHANGELOG.md
@@ -224,13 +332,21 @@ function install(isGlobal) {
   const changelogDest = path.join(claudeDir, 'get-shit-done', 'CHANGELOG.md');
   if (fs.existsSync(changelogSrc)) {
     fs.copyFileSync(changelogSrc, changelogDest);
-    console.log(`  ${green}✓${reset} Installed CHANGELOG.md`);
+    if (verifyFileInstalled(changelogDest, 'CHANGELOG.md')) {
+      console.log(`  ${green}✓${reset} Installed CHANGELOG.md`);
+    } else {
+      failures.push('CHANGELOG.md');
+    }
   }
 
   // Write VERSION file for whats-new command
   const versionDest = path.join(claudeDir, 'get-shit-done', 'VERSION');
   fs.writeFileSync(versionDest, pkg.version);
-  console.log(`  ${green}✓${reset} Wrote VERSION (${pkg.version})`);
+  if (verifyFileInstalled(versionDest, 'VERSION')) {
+    console.log(`  ${green}✓${reset} Wrote VERSION (${pkg.version})`);
+  } else {
+    failures.push('VERSION');
+  }
 
   // Copy hooks
   const hooksSrc = path.join(src, 'hooks');
@@ -243,12 +359,23 @@ function install(isGlobal) {
       const destFile = path.join(hooksDest, entry);
       fs.copyFileSync(srcFile, destFile);
     }
-    console.log(`  ${green}✓${reset} Installed hooks`);
+    if (verifyInstalled(hooksDest, 'hooks')) {
+      console.log(`  ${green}✓${reset} Installed hooks`);
+    } else {
+      failures.push('hooks');
+    }
+  }
+
+  // If critical components failed, exit with error
+  if (failures.length > 0) {
+    console.error(`\n  ${yellow}Installation incomplete!${reset} Failed: ${failures.join(', ')}`);
+    console.error(`  Try running directly: node ~/.npm/_npx/*/node_modules/get-shit-done-cc/bin/install.js --global\n`);
+    process.exit(1);
   }
 
   // Configure statusline and hooks in settings.json
   const settingsPath = path.join(claudeDir, 'settings.json');
-  const settings = readSettings(settingsPath);
+  const settings = cleanupOrphanedHooks(readSettings(settingsPath));
   const statuslineCommand = isGlobal
     ? 'node "$HOME/.claude/hooks/statusline.js"'
     : 'node .claude/hooks/statusline.js';
@@ -364,11 +491,37 @@ function handleStatusline(settings, isInteractive, callback) {
  * Prompt for install location
  */
 function promptLocation() {
+  // Check if stdin is a TTY - if not, fall back to global install
+  // This handles npx execution in environments like WSL2 where stdin may not be properly connected
+  if (!process.stdin.isTTY) {
+    console.log(`  ${yellow}Non-interactive terminal detected, defaulting to global install${reset}\n`);
+    const { settingsPath, settings, statuslineCommand } = install(true);
+    handleStatusline(settings, false, (shouldInstallStatusline) => {
+      finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline);
+    });
+    return;
+  }
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
 
+  // Track whether we've processed the answer to prevent double-execution
+  let answered = false;
+
+  // Handle readline close event to detect premature stdin closure
+  rl.on('close', () => {
+    if (!answered) {
+      answered = true;
+      console.log(`\n  ${yellow}Input stream closed, defaulting to global install${reset}\n`);
+      const { settingsPath, settings, statuslineCommand } = install(true);
+      handleStatusline(settings, false, (shouldInstallStatusline) => {
+        finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline);
+      });
+    }
+  });
+
   const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
   const globalPath = configDir || path.join(os.homedir(), '.claude');
   const globalLabel = globalPath.replace(os.homedir(), '~');
@@ -380,6 +533,7 @@ function promptLocation() {
 `);
 
   rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    answered = true;
     rl.close();
     const choice = answer.trim() || '1';
     const isGlobal = choice !== '2';

package/commands/gsd/execute-phase.md

@@ -1,7 +1,7 @@
 ---
 name: gsd:execute-phase
 description: Execute all plans in a phase with wave-based parallelization
-argument-hint: "<phase-number>"
+argument-hint: "<phase-number> [--gaps-only]"
 allowed-tools:
   - Read
   - Write
@@ -30,6 +30,9 @@ Context budget: ~15% orchestrator, 100% fresh per subagent.
 <context>
 Phase: $ARGUMENTS
 
+**Flags:**
+- `--gaps-only` — Execute only gap closure plans (plans with `gap_closure: true` in frontmatter). Use after verify-work creates fix plans.
+
 @.planning/ROADMAP.md
 @.planning/STATE.md
 </context>
@@ -43,6 +46,7 @@ Phase: $ARGUMENTS
 2. **Discover plans**
    - List all *-PLAN.md files in phase directory
    - Check which have *-SUMMARY.md (already complete)
+   - If `--gaps-only`: filter to only plans with `gap_closure: true`
    - Build list of incomplete plans
 
 3. **Group by wave**

package/commands/gsd/verify-work.md

@@ -156,7 +156,7 @@ Fix plans verified ✓
 
 **Execute fix plans** — run diagnosed fixes
 
-/gsd:execute-phase {Z}
+/gsd:execute-phase {Z} --gaps-only
 
 <sub>/clear first → fresh context window</sub>
 

package/get-shit-done/workflows/execute-phase.md

@@ -71,15 +71,21 @@ ls -1 "$PHASE_DIR"/*-SUMMARY.md 2>/dev/null | sort
 For each plan, read frontmatter to extract:
 - `wave: N` - Execution wave (pre-computed)
 - `autonomous: true/false` - Whether plan has checkpoints
+- `gap_closure: true/false` - Whether plan closes gaps from verification/UAT
 
 Build plan inventory:
 - Plan path
 - Plan ID (e.g., "03-01")
 - Wave number
 - Autonomous flag
+- Gap closure flag
 - Completion status (SUMMARY exists = complete)
 
-Skip completed plans. If all complete, report "Phase already executed" and exit.
+**Filtering:**
+- Skip completed plans (have SUMMARY.md)
+- If `--gaps-only` flag: also skip plans where `gap_closure` is not `true`
+
+If all plans filtered out, report "No matching incomplete plans" and exit.
 </step>
 
 <step name="group_by_wave">
@@ -433,9 +439,9 @@ Present gaps and offer next command:
 
 User runs `/gsd:plan-phase {X} --gaps` which:
 1. Reads VERIFICATION.md gaps
-2. Creates additional plans (04, 05, etc.) to close gaps
-3. User then runs `/gsd:execute-phase {X}` again
-4. Execute-phase runs incomplete plans (04-05)
+2. Creates additional plans (04, 05, etc.) with `gap_closure: true` to close gaps
+3. User then runs `/gsd:execute-phase {X} --gaps-only`
+4. Execute-phase runs only gap closure plans (04-05)
 5. Verifier runs again after new plans complete
 
 User stays in control at each decision point.

package/get-shit-done/workflows/verify-work.md

@@ -505,7 +505,7 @@ Plans verified and ready for execution.
 
 **Execute fixes** — run fix plans
 
-`/clear` then `/gsd:execute-phase {phase}`
+`/clear` then `/gsd:execute-phase {phase} --gaps-only`
 
 ───────────────────────────────────────────────────────────────
 ```
@@ -559,5 +559,5 @@ Default to **major** if unclear. User can correct if needed.
 - [ ] If issues: gsd-planner creates fix plans (gap_closure mode)
 - [ ] If issues: gsd-plan-checker verifies fix plans
 - [ ] If issues: revision loop until plans pass (max 3 iterations)
-- [ ] Ready for `/gsd:execute-phase` when complete
+- [ ] Ready for `/gsd:execute-phase --gaps-only` when complete
 </success_criteria>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-shit-done-cc",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.",
   "bin": {
     "get-shit-done-cc": "bin/install.js"