claude-code-pilot 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Othmane Hanyf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# Claude Code Pilot
+
+Universal Claude Code configuration for **any project**. Bundles two complementary systems:
+
+- **GSD** (Get Shit Done) v1.22.4 — *Methodology*. Spec-driven development with fresh 200k contexts per task. Prevents context rot.
+- **ECC** (Everything Claude Code) v1.8.0 — *Toolbox*. Session persistence, continuous learning, verification, quality gates. Prevents knowledge loss.
+
+One command to install. `/setup` wizard auto-configures everything.
+
+## Install
+
+```bash
+cd your-project
+npx claude-code-pilot
+claude
+> /setup
+```
+
+## The Workflow
+
+```
+npx claude-code-pilot            ← install (once)
+claude → /setup                         ← wizard scans codebase, generates CLAUDE.md
+
+# Development
+/gsd:discuss-phase 1                    ← GSD: capture requirements
+/gsd:plan-phase 1                       ← GSD: atomic plans
+/checkpoint create "before-impl"        ← ECC: snapshot
+/gsd:execute-phase 1                    ← GSD: build with fresh contexts
+/verify                                 ← ECC: build → types → lint → tests → security
+/gsd:verify-work 1                      ← GSD: does it match the spec?
+/save-session                           ← ECC: persist for next session
+/learn                                  ← ECC: extract reusable patterns
+
+# Next session
+/resume-session                         ← ECC: load previous context
+/evolve                                 ← ECC: promote instincts → skills
+/kit:update                             ← update everything
+```
+
+## What's Included (254 files after install)
+
+### GSD — Methodology (32 commands, 12 agents)
+| Command | What |
+|---------|------|
+| `/gsd:new-project` | Initialize with roadmap and milestones |
+| `/gsd:discuss-phase N` | Capture requirements |
+| `/gsd:plan-phase N` | Atomic plans (max 3 tasks per subagent) |
+| `/gsd:execute-phase N` | Build in fresh 200k contexts |
+| `/gsd:verify-work N` | Goal-backward verification |
+| `/gsd:quick "task"` | Same quality, lighter process |
+| `/gsd:progress` | Milestone progress |
+| `/gsd:help` | All 32 commands |
+
+12 specialized subagents: executor, planner, verifier, debugger, codebase-mapper, roadmapper, etc.
+
+### ECC — Toolbox (9 commands, 6 agents, 3 skills)
+| Command | What |
+|---------|------|
+| `/verify` | 6-phase quality check (build, types, lint, tests, security, diff) |
+| `/checkpoint` | Git-backed snapshots with before/after comparison |
+| `/save-session` | Persist what worked, what didn't, exact next step |
+| `/resume-session` | Load previous session context |
+| `/learn` | Extract reusable patterns from session |
+| `/evolve` | Promote learned instincts into skills/commands/agents |
+| `/quality-gate` | On-demand quality pipeline |
+| `/model-route` | Recommend model tier (Haiku/Sonnet/Opus) |
+| `/sessions` | List, load, alias saved sessions |
+
+6 agents: architect, code-reviewer, security-reviewer, tdd-guide, e2e-runner, doc-updater.
+
+3 skills: continuous-learning-v2 (instinct system), strategic-compact, verification-loop.
+
+### Kit — Infrastructure
+| Feature | What |
+|---------|------|
+| `/setup` wizard | Scans codebase, generates CLAUDE.md, installs language rules |
+| `/setup:refresh` | Updates config after project changes |
+| `/kit:update` | Updates kit + GSD + ECC |
+| Safety hooks | Blocks rm -rf, DROP TABLE, push --force; protects .env/lock files |
+| Notifications | Desktop alerts (task complete, idle, permission needed) |
+| Context modes | dev.md, research.md, review.md |
+| Language rules | 9 common + 7 language-specific sets (activated by /setup) |
+
+## How GSD and ECC Work Together
+
+| | GSD | ECC |
+|---|---|---|
+| **Purpose** | Structure *how* to work | Ensure *quality* of work |
+| **Core** | Phases, milestones, subagents | Verification, learning, persistence |
+| **Verification** | "Does it match the spec?" | "Is it production-ready?" |
+| **Context** | Fresh 200k per task | Strategic compact, pre-compact save |
+| **Knowledge** | Plans in files | Instincts that evolve into skills |
+| **Persistence** | Atomic commits | Session files with full context |
+
+## Hooks (13 total)
+
+| Hook | Event | Source |
+|------|-------|--------|
+| Command blocker | PreToolUse:Bash | Kit |
+| File protection | PreToolUse:Write\|Edit | Kit |
+| Context monitor | PostToolUse | GSD |
+| GSD update check | SessionStart | GSD |
+| Kit update check | SessionStart | Kit |
+| Session loader | SessionStart | ECC |
+| Session saver | Stop | ECC |
+| Pre-compact save | PreCompact | ECC |
+| Strategic compact | PreToolUse:Edit\|Write | ECC |
+| Task completed | Stop | Kit |
+| Idle prompt | Notification | Kit |
+| Permission needed | Notification | Kit |
+| Statusline | Always | GSD |
+
+## Language Rules
+
+The installer copies 9 common rules (always active) and 7 language-specific rule sets into `available-rules/`. The `/setup` wizard detects your language and activates the matching set.
+
+Available: TypeScript, Python, Go, Swift, Kotlin, PHP, Perl.
+
+## Self-Updating
+
+On every session start, the kit checks npm for new versions. When available, the agent sees: *"⬆️ Pilot update available. Run /kit:update."*
+
+```bash
+# From Claude Code:
+/kit:update
+
+# From terminal:
+npx claude-code-pilot@latest --update
+```
+
+Updates preserve your CLAUDE.md, architecture docs, and settings customizations.
+
+## CLI
+
+```
+npx claude-code-pilot [options]
+
+  -l, --local       Install to .claude/ (default)
+  -g, --global      Install to ~/.claude/
+  -u, --update      Update existing installation
+  --uninstall       Remove kit files (preserves CLAUDE.md)
+  -h, --help        Show help
+```
+
+## Credits
+
+- **GSD** by [TÂCHES](https://github.com/glittercowboy/get-shit-done) (MIT)
+- **ECC** by [Affaan Mustafa](https://github.com/affaan-m/everything-claude-code) (MIT)
+- **find-skills** by [Vercel Labs](https://github.com/vercel-labs/skills)
+- **Context7** by [Upstash](https://github.com/upstash/context7)

package/bin/install.js

@@ -0,0 +1,431 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const cyan = '\x1b[36m', green = '\x1b[32m', yellow = '\x1b[33m', dim = '\x1b[2m', reset = '\x1b[0m';
+
+const pkg = require('../package.json');
+const manifest = require('../manifest.json');
+
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+const hasUpdate = args.includes('--update') || args.includes('-u');
+const hasUninstall = args.includes('--uninstall');
+const hasHelp = args.includes('--help') || args.includes('-h');
+
+const banner = '\n' +
+  cyan + '  ╔═╗┬┬  ┌─┐┌┬┐\n' +
+  '  ╠═╝││  │ │ │ \n' +
+  '  ╩  ┴┴─┘└─┘ ┴ ' + reset + '\n\n' +
+  '  Claude Code Pilot ' + dim + 'v' + pkg.version + reset + '\n' +
+  '  GSD ' + dim + 'v' + manifest.bundled.gsd.version + reset +
+  '  +  ECC ' + dim + 'v' + manifest.bundled.ecc.version + reset + '\n';
+
+console.log(banner);
+
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx claude-code-pilot [options]\n
+  ${yellow}Options:${reset}
+    ${cyan}-l, --local${reset}       Install to current project (default)
+    ${cyan}-g, --global${reset}      Install to ~/.claude/
+    ${cyan}-u, --update${reset}      Update existing installation
+    ${cyan}--uninstall${reset}       Remove kit files
+    ${cyan}-h, --help${reset}        Show help\n`);
+  process.exit(0);
+}
+
+// --- Paths ---
+const src = path.join(__dirname, '..');
+const isGlobal = hasGlobal;
+const targetDir = isGlobal
+  ? (process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'))
+  : path.join(process.cwd(), '.claude');
+const locationLabel = isGlobal ? targetDir.replace(os.homedir(), '~') : '.claude/';
+const pathPrefix = isGlobal ? `${targetDir.replace(/\\/g, '/')}/` : './.claude/';
+const projectRoot = isGlobal ? os.homedir() : process.cwd();
+
+// --- Utilities ---
+function readSettings(p) {
+  if (fs.existsSync(p)) { try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return {}; } }
+  return {};
+}
+function writeSettings(p, s) { fs.writeFileSync(p, JSON.stringify(s, null, 2) + '\n'); }
+
+function copyDir(srcDir, destDir, opts = {}) {
+  if (!fs.existsSync(srcDir)) return 0;
+  const { replacePaths = false, clean = false } = opts;
+  if (clean && fs.existsSync(destDir)) fs.rmSync(destDir, { recursive: true });
+  fs.mkdirSync(destDir, { recursive: true });
+  let count = 0;
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const s = path.join(srcDir, entry.name);
+    const d = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      count += copyDir(s, d, opts);
+    } else {
+      if (replacePaths && (entry.name.endsWith('.md') || entry.name.endsWith('.sh'))) {
+        let text = fs.readFileSync(s, 'utf8');
+        text = text.replace(/~\/\.claude\//g, pathPrefix);
+        text = text.replace(/\$HOME\/\.claude\//g, pathPrefix);
+        fs.writeFileSync(d, text);
+      } else {
+        fs.copyFileSync(s, d);
+      }
+      count++;
+    }
+  }
+  return count;
+}
+
+function copyFile(s, d, replace = false) {
+  fs.mkdirSync(path.dirname(d), { recursive: true });
+  if (replace) {
+    let text = fs.readFileSync(s, 'utf8');
+    text = text.replace(/~\/\.claude\//g, pathPrefix);
+    text = text.replace(/\$HOME\/\.claude\//g, pathPrefix);
+    // Replace CLAUDE_PLUGIN_ROOT with actual path
+    text = text.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pathPrefix.replace(/\/$/, ''));
+    fs.writeFileSync(d, text);
+  } else {
+    fs.copyFileSync(s, d);
+  }
+}
+
+function addHookIfMissing(settings, event, matcher, fingerprint, hookCmd, description) {
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks[event]) settings.hooks[event] = [];
+  const exists = settings.hooks[event].some(e =>
+    e.hooks?.some(h => h.command?.includes(fingerprint))
+  );
+  if (!exists) {
+    const entry = { hooks: [{ type: 'command', command: hookCmd }] };
+    if (matcher !== null) entry.matcher = matcher;
+    if (description) entry.description = description;
+    settings.hooks[event].push(entry);
+    return true;
+  }
+  return false;
+}
+
+// --- Install ---
+function install() {
+  const mode = hasUpdate ? 'Updating' : 'Installing';
+  console.log(`  ${mode} to ${cyan}${locationLabel}${reset}\n`);
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  // ═══════════════════════════════════════
+  // Kit Core
+  // ═══════════════════════════════════════
+  console.log(`  ${dim}Kit core...${reset}`);
+  const kitSrc = path.join(src, 'kit');
+  copyDir(path.join(kitSrc, 'commands'), path.join(targetDir, 'commands'), { replacePaths: true });
+  copyDir(path.join(kitSrc, 'hooks'), path.join(targetDir, 'hooks'));
+  console.log(`  ${green}✓${reset} Kit commands + hooks`);
+
+  // ═══════════════════════════════════════
+  // GSD
+  // ═══════════════════════════════════════
+  console.log(`\n  ${dim}GSD v${manifest.bundled.gsd.version}...${reset}`);
+  const gsdSrc = path.join(src, 'gsd');
+
+  const cmdCount = copyDir(path.join(gsdSrc, 'commands-gsd'), path.join(targetDir, 'commands', 'gsd'), { replacePaths: true, clean: true });
+  console.log(`  ${green}✓${reset} GSD commands (${cmdCount})`);
+
+  copyDir(path.join(gsdSrc, 'get-shit-done'), path.join(targetDir, 'get-shit-done'), { replacePaths: true, clean: true });
+  console.log(`  ${green}✓${reset} GSD core (workflows, references, templates)`);
+
+  copyDir(path.join(gsdSrc, 'agents'), path.join(targetDir, 'agents'), { replacePaths: true });
+  console.log(`  ${green}✓${reset} GSD agents (12)`);
+
+  // GSD hooks
+  const gsdHooksSrc = path.join(gsdSrc, 'hooks');
+  if (fs.existsSync(gsdHooksSrc)) {
+    const hooksDest = path.join(targetDir, 'hooks');
+    fs.mkdirSync(hooksDest, { recursive: true });
+    for (const f of fs.readdirSync(gsdHooksSrc).filter(f => f.endsWith('.js'))) {
+      fs.copyFileSync(path.join(gsdHooksSrc, f), path.join(hooksDest, f));
+    }
+    console.log(`  ${green}✓${reset} GSD hooks (statusline, context monitor, update check)`);
+  }
+
+  // ═══════════════════════════════════════
+  // ECC
+  // ═══════════════════════════════════════
+  console.log(`\n  ${dim}ECC v${manifest.bundled.ecc.version}...${reset}`);
+  const eccSrc = path.join(src, 'ecc');
+
+  // ECC commands (flat — alongside kit commands)
+  const eccCmdSrc = path.join(eccSrc, 'commands');
+  if (fs.existsSync(eccCmdSrc)) {
+    for (const f of fs.readdirSync(eccCmdSrc).filter(f => f.endsWith('.md'))) {
+      copyFile(path.join(eccCmdSrc, f), path.join(targetDir, 'commands', f), true);
+    }
+    const eccCmdCount = fs.readdirSync(eccCmdSrc).filter(f => f.endsWith('.md')).length;
+    console.log(`  ${green}✓${reset} ECC commands (${eccCmdCount}: sessions, verify, learn, checkpoint, ...)`);
+  }
+
+  // ECC skills
+  const eccSkillsSrc = path.join(eccSrc, 'skills');
+  if (fs.existsSync(eccSkillsSrc)) {
+    copyDir(eccSkillsSrc, path.join(targetDir, 'skills'), { replacePaths: true });
+    console.log(`  ${green}✓${reset} ECC skills (continuous-learning, strategic-compact, verification-loop)`);
+  }
+
+  // ECC contexts
+  const eccCtxSrc = path.join(eccSrc, 'contexts');
+  if (fs.existsSync(eccCtxSrc)) {
+    copyDir(eccCtxSrc, path.join(targetDir, 'contexts'));
+    console.log(`  ${green}✓${reset} ECC context modes (dev, research, review)`);
+  }
+
+  // ECC agents (alongside GSD agents)
+  const eccAgentsSrc = path.join(eccSrc, 'agents');
+  if (fs.existsSync(eccAgentsSrc)) {
+    for (const f of fs.readdirSync(eccAgentsSrc).filter(f => f.endsWith('.md'))) {
+      copyFile(path.join(eccAgentsSrc, f), path.join(targetDir, 'agents', f), true);
+    }
+    const eccAgentCount = fs.readdirSync(eccAgentsSrc).filter(f => f.endsWith('.md')).length;
+    console.log(`  ${green}✓${reset} ECC agents (${eccAgentCount}: architect, code-reviewer, security, tdd, ...)`);
+  }
+
+  // ECC scripts (hooks + lib — preserve relative paths)
+  const eccScriptsSrc = path.join(eccSrc, 'scripts');
+  if (fs.existsSync(eccScriptsSrc)) {
+    copyDir(eccScriptsSrc, path.join(targetDir, 'ecc-scripts'));
+    console.log(`  ${green}✓${reset} ECC scripts (session lifecycle, project detection, utils)`);
+  }
+
+  // Patch ECC getClaudeDir() for local installs (CWD-relative)
+  if (!isGlobal) {
+    const utilsPath = path.join(targetDir, 'ecc-scripts', 'lib', 'utils.js');
+    if (fs.existsSync(utilsPath)) {
+      let utilsContent = fs.readFileSync(utilsPath, 'utf8');
+      utilsContent = utilsContent.replace(
+        /function getClaudeDir\(\)\s*\{[^}]*\}/,
+        "function getClaudeDir() {\n  return path.join(process.cwd(), '.claude');\n}"
+      );
+      fs.writeFileSync(utilsPath, utilsContent);
+      console.log(`  ${green}✓${reset} ECC: patched getClaudeDir() for local install`);
+    }
+  }
+
+  // ECC rules (common always, language-specific all copied — /setup activates relevant ones)
+  const eccRulesSrc = path.join(eccSrc, 'rules');
+  if (fs.existsSync(eccRulesSrc)) {
+    copyDir(path.join(eccRulesSrc, 'common'), path.join(targetDir, 'rules', 'common'), { replacePaths: true });
+    // Copy language rules into available-rules/ (activated by /setup based on detection)
+    for (const lang of fs.readdirSync(eccRulesSrc).filter(d => d !== 'common')) {
+      const langSrc = path.join(eccRulesSrc, lang);
+      if (fs.statSync(langSrc).isDirectory()) {
+        copyDir(langSrc, path.join(targetDir, 'available-rules', lang), { replacePaths: true });
+      }
+    }
+    console.log(`  ${green}✓${reset} ECC rules (common + 7 language sets in available-rules/)`);
+  }
+
+  // ECC examples
+  const eccExSrc = path.join(eccSrc, 'examples');
+  if (fs.existsSync(eccExSrc)) {
+    copyDir(eccExSrc, path.join(targetDir, 'ecc-examples'), { replacePaths: true });
+    console.log(`  ${green}✓${reset} ECC example CLAUDE.md files (reference)`);
+  }
+
+  // ═══════════════════════════════════════
+  // CommonJS + package.json
+  // ═══════════════════════════════════════
+  fs.writeFileSync(path.join(targetDir, 'package.json'), '{"type":"commonjs"}\n');
+
+  // ═══════════════════════════════════════
+  // Root files (only fresh install or bootstrap)
+  // ═══════════════════════════════════════
+  console.log(`\n  ${dim}Root files...${reset}`);
+  const claudeMdSrc = path.join(kitSrc, 'CLAUDE.md');
+  const claudeMdDest = path.join(projectRoot, 'CLAUDE.md');
+  if (fs.existsSync(claudeMdSrc)) {
+    if (!fs.existsSync(claudeMdDest) ||
+        fs.readFileSync(claudeMdDest, 'utf8').includes('Run `/setup` to auto-configure')) {
+      fs.copyFileSync(claudeMdSrc, claudeMdDest);
+      console.log(`  ${green}✓${reset} CLAUDE.md (bootstrap)`);
+    } else {
+      console.log(`  ${dim}⏭️  CLAUDE.md (customized — preserved)${reset}`);
+    }
+  }
+
+  const mcpSrc = path.join(kitSrc, 'mcp.json');
+  const mcpDest = path.join(projectRoot, '.mcp.json');
+  if (fs.existsSync(mcpSrc) && !fs.existsSync(mcpDest)) {
+    fs.copyFileSync(mcpSrc, mcpDest);
+    console.log(`  ${green}✓${reset} .mcp.json (Context7)`);
+  }
+
+  const archSrc = path.join(src, 'docs', 'agent-guides', 'architecture.md');
+  const archDest = path.join(projectRoot, 'docs', 'agent-guides', 'architecture.md');
+  if (fs.existsSync(archSrc) && !fs.existsSync(archDest)) {
+    fs.mkdirSync(path.dirname(archDest), { recursive: true });
+    fs.copyFileSync(archSrc, archDest);
+    console.log(`  ${green}✓${reset} docs/agent-guides/architecture.md`);
+  }
+
+  // ═══════════════════════════════════════
+  // Settings (merge — never overwrite)
+  // ═══════════════════════════════════════
+  console.log(`\n  ${dim}Configuring settings...${reset}`);
+  const settingsPath = path.join(targetDir, 'settings.json');
+  const settings = readSettings(settingsPath);
+
+  // --- Safety hooks ---
+  let added;
+  added = addHookIfMissing(settings, 'PreToolUse', 'Bash', 'Blocked: forbidden',
+    `bash -c 'CMD=$(jq -r ".tool_input.command" <<< "$(cat)"); for p in "rm -rf /" "rm -rf ~" "DROP TABLE" "TRUNCATE" "push.*--force"; do if echo "$CMD" | grep -qiE "$p"; then echo "Blocked: forbidden pattern \\"$p\\" detected" >&2; exit 2; fi; done; exit 0'`);
+  if (added) console.log(`  ${green}✓${reset} Safety: dangerous command blocker`);
+
+  added = addHookIfMissing(settings, 'PreToolUse', 'Write|Edit', 'Protected file',
+    `bash -c 'FILE=$(jq -r ".tool_input.file_path // empty" <<< "$(cat)"); for p in ".env" "package-lock.json" "pnpm-lock.yaml" "yarn.lock" "bun.lock" ".git/"; do if [[ "$FILE" == *"$p"* ]]; then echo "Protected file: $p" >&2; exit 2; fi; done; exit 0'`);
+  if (added) console.log(`  ${green}✓${reset} Safety: file protection`);
+
+  // --- GSD hooks ---
+  added = addHookIfMissing(settings, 'PostToolUse', null, 'gsd-context-monitor',
+    `node ${pathPrefix}hooks/gsd-context-monitor.js`, 'GSD context window monitor');
+  if (added) console.log(`  ${green}✓${reset} GSD: context monitor`);
+
+  added = addHookIfMissing(settings, 'SessionStart', null, 'gsd-check-update',
+    `node ${pathPrefix}hooks/gsd-check-update.js`, 'GSD version check');
+  if (added) console.log(`  ${green}✓${reset} GSD: update check`);
+
+  // --- Kit hooks ---
+  added = addHookIfMissing(settings, 'SessionStart', null, 'kit-check-update',
+    `node ${pathPrefix}hooks/kit-check-update.js`, 'Pilot version check');
+  if (added) console.log(`  ${green}✓${reset} Kit: update check`);
+
+  // --- ECC hooks ---
+  added = addHookIfMissing(settings, 'SessionStart', null, 'ecc-scripts/hooks/session-start',
+    `node ${pathPrefix}ecc-scripts/hooks/session-start.js`, 'ECC session context loader');
+  if (added) console.log(`  ${green}✓${reset} ECC: session start (loads previous context)`);
+
+  added = addHookIfMissing(settings, 'Stop', null, 'ecc-scripts/hooks/session-end',
+    `node ${pathPrefix}ecc-scripts/hooks/session-end.js`, 'ECC session persistence');
+  if (added) console.log(`  ${green}✓${reset} ECC: session end (saves session state)`);
+
+  added = addHookIfMissing(settings, 'PreCompact', null, 'ecc-scripts/hooks/pre-compact',
+    `node ${pathPrefix}ecc-scripts/hooks/pre-compact.js`, 'ECC pre-compact state save');
+  if (added) console.log(`  ${green}✓${reset} ECC: pre-compact (saves state before compaction)`);
+
+  added = addHookIfMissing(settings, 'PreToolUse', 'Edit|Write', 'suggest-compact',
+    `node ${pathPrefix}ecc-scripts/hooks/suggest-compact.js`, 'ECC strategic compact suggestions');
+  if (added) console.log(`  ${green}✓${reset} ECC: strategic compact suggestions`);
+
+  // --- Notifications ---
+  added = addHookIfMissing(settings, 'Stop', '', 'Task completed',
+    `bash -c 'if command -v terminal-notifier &>/dev/null; then terminal-notifier -title "Claude Code" -message "Task completed" -sound default; elif command -v osascript &>/dev/null; then osascript -e "display notification \\"Task completed\\" with title \\"Claude Code\\" sound name \\"Glass\\""; elif command -v notify-send &>/dev/null; then notify-send -u normal "Claude Code" "Task completed"; fi'`);
+  if (added) console.log(`  ${green}✓${reset} Notification: task completed`);
+
+  added = addHookIfMissing(settings, 'Notification', 'idle_prompt', 'Ready for input',
+    `bash -c 'if command -v terminal-notifier &>/dev/null; then terminal-notifier -title "Claude Code" -message "Ready for input" -sound default; elif command -v osascript &>/dev/null; then osascript -e "display notification \\"Ready for input\\" with title \\"Claude Code\\" sound name \\"Glass\\""; elif command -v notify-send &>/dev/null; then notify-send -u normal "Claude Code" "Ready for input"; fi'`);
+  if (added) console.log(`  ${green}✓${reset} Notification: idle prompt`);
+
+  added = addHookIfMissing(settings, 'Notification', 'permission_prompt', 'Permission needed',
+    `bash -c 'if command -v terminal-notifier &>/dev/null; then terminal-notifier -title "Claude Code" -message "Permission needed" -sound Submarine; elif command -v osascript &>/dev/null; then osascript -e "display notification \\"Permission needed\\" with title \\"Claude Code\\" sound name \\"Submarine\\""; elif command -v notify-send &>/dev/null; then notify-send -u critical "Claude Code" "Permission needed"; fi'`);
+  if (added) console.log(`  ${green}✓${reset} Notification: permission prompt`);
+
+  // --- Statusline ---
+  if (!settings.statusLine) {
+    settings.statusLine = { type: 'command', command: `node ${pathPrefix}hooks/gsd-statusline.js` };
+    console.log(`  ${green}✓${reset} GSD statusline`);
+  }
+
+  // --- Permissions ---
+  if (!settings.permissions) settings.permissions = {};
+  if (!settings.permissions.deny) settings.permissions.deny = [];
+  for (const p of ['Bash(rm -rf *)', 'Bash(git push --force*)', 'Bash(*DROP TABLE*)']) {
+    if (!settings.permissions.deny.includes(p)) settings.permissions.deny.push(p);
+  }
+
+  writeSettings(settingsPath, settings);
+  console.log(`  ${green}✓${reset} Settings written`);
+
+  // ═══════════════════════════════════════
+  // Version files
+  // ═══════════════════════════════════════
+  const gsdVersionDir = path.join(targetDir, 'get-shit-done');
+  fs.mkdirSync(gsdVersionDir, { recursive: true });
+  fs.writeFileSync(path.join(gsdVersionDir, 'VERSION'), manifest.bundled.gsd.version);
+
+  const kitVersionDir = path.join(targetDir, 'kit-version');
+  fs.mkdirSync(kitVersionDir, { recursive: true });
+  fs.writeFileSync(path.join(kitVersionDir, 'VERSION'), pkg.version);
+  fs.writeFileSync(path.join(kitVersionDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+  console.log(`  ${green}✓${reset} Version files (kit v${pkg.version}, GSD v${manifest.bundled.gsd.version}, ECC v${manifest.bundled.ecc.version})`);
+
+  // ═══════════════════════════════════════
+  // External: find-skills
+  // ═══════════════════════════════════════
+  console.log(`\n  ${dim}External dependencies...${reset}`);
+  try {
+    execSync('npx skills add https://github.com/vercel-labs/skills --skill find-skills -g -a claude-code -y', { stdio: 'pipe', timeout: 30000 });
+    console.log(`  ${green}✓${reset} find-skills`);
+  } catch {
+    console.log(`  ${yellow}⚠${reset} find-skills failed — run: npx skills add https://github.com/vercel-labs/skills --skill find-skills -g -a claude-code -y`);
+  }
+
+  // Notifications check
+  console.log('');
+  try { execSync('which terminal-notifier', { stdio: 'pipe' }); console.log(`  ${green}✓${reset} Notifications: terminal-notifier`); }
+  catch { try { execSync('which osascript', { stdio: 'pipe' }); console.log(`  ${green}✓${reset} Notifications: osascript`); }
+  catch { try { execSync('which notify-send', { stdio: 'pipe' }); console.log(`  ${green}✓${reset} Notifications: notify-send`); }
+  catch { console.log(`  ${yellow}⚠${reset} No notification tool found`); } } }
+
+  // ═══════════════════════════════════════
+  // Summary
+  // ═══════════════════════════════════════
+  const totalAgents = fs.existsSync(path.join(targetDir, 'agents'))
+    ? fs.readdirSync(path.join(targetDir, 'agents')).filter(f => f.endsWith('.md')).length : 0;
+
+  const action = hasUpdate ? 'Updated' : 'Installed';
+  console.log(`
+  ${green}${action}!${reset}  Kit v${pkg.version}
+
+  ${cyan}GSD${reset}  v${manifest.bundled.gsd.version} — 32 commands, 12 agents, spec-driven development
+  ${cyan}ECC${reset}  v${manifest.bundled.ecc.version} — Sessions, learning, verification, quality gates
+  ${cyan}Kit${reset}  — Safety hooks, notifications, auto-updates, /setup wizard
+
+  ${totalAgents} agents total. Context monitoring. Session persistence.
+  Language rules ready in available-rules/ (activated by /setup).
+
+  Next:
+    ${cyan}claude${reset}
+    ${cyan}/setup${reset}            ← auto-configure this project
+    ${cyan}/kit:update${reset}       ← update to latest version
+
+  GSD:                        ECC:
+    ${cyan}/gsd:new-project${reset}      ${cyan}/save-session${reset}
+    ${cyan}/gsd:quick "task"${reset}     ${cyan}/verify${reset}
+    ${cyan}/gsd:discuss-phase 1${reset}  ${cyan}/checkpoint create "v1"${reset}
+    ${cyan}/gsd:help${reset}            ${cyan}/learn${reset}
+`);
+}
+
+// --- Uninstall ---
+function uninstall() {
+  console.log(`  Uninstalling from ${cyan}${locationLabel}${reset}\n`);
+  const dirs = ['commands', 'get-shit-done', 'agents', 'hooks', 'rules', 'skills',
+    'contexts', 'ecc-scripts', 'ecc-examples', 'available-rules', 'kit-version'];
+  let removed = 0;
+  for (const d of dirs) {
+    const p = path.join(targetDir, d);
+    if (fs.existsSync(p)) {
+      fs.rmSync(p, { recursive: true });
+      removed++;
+      console.log(`  ${green}✓${reset} Removed ${d}/`);
+    }
+  }
+  console.log(removed ? `\n  ${green}Done!${reset} CLAUDE.md and settings.json preserved.\n` : `  ${yellow}⚠${reset} Nothing to remove\n`);
+}
+
+// --- Main ---
+if (hasUninstall) { uninstall(); }
+else if (!hasGlobal && !hasLocal) { console.log(`  ${dim}Defaulting to local install (.claude/)${reset}\n`); install(); }
+else { install(); }