elliot-stack 1.0.17 → 1.0.19

package/README.md

@@ -52,6 +52,23 @@ npx elliot-stack@latest
 - [Claude Code](https://claude.ai/code) CLI installed
 - Node.js 18+
 
+## Contributing
+
+External contributions are welcome via pull request. Direct pushes to `main` are blocked — fork the repo, push your changes to a branch, and open a PR. Only the maintainer (Elliot) can merge to `main` and cut releases. This is intentional: `elliot-stack` is a security-sensitive npm package and the release tag can only be pushed by the maintainer.
+
+### Testing locally
+
+Run the installer straight from your checkout to preview what a real install would do to your `~/.claude/`:
+
+```bash
+node bin/install.cjs            # dry run — previews changes, writes nothing
+node bin/install.cjs --install  # actually sync your local edits to ~/.claude/skills/
+```
+
+Run from the repo, the installer **dry-runs by default** so testing never clobbers your live `~/.claude/skills/` install. Pass `--install` once the preview looks right. (`--dry-run` forces a preview even under `npx`.)
+
+See [`docs/publishing.md`](docs/publishing.md) for the release flow and security model.
+
 ## License
 
 MIT

package/bin/install.cjs

@@ -15,10 +15,25 @@ const BACKUP_DIR = path.join(CLAUDE_DIR, '.estack-backup');
 const CHECKSUMS_FILE = path.join(CLAUDE_DIR, '.estack-checksums.json');
 const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
 const PACKAGE_SKILLS_DIR = path.join(__dirname, '..', 'skills');
+const HOOKS_DIR = path.join(CLAUDE_DIR, 'hooks');
+const PACKAGE_HOOKS_DIR = path.join(__dirname, '..', 'hooks');
 
 // ── Flags ──────────────────────────────────────────────────────────────────
 const SILENT = process.argv.includes('--silent');
 const STARTUP = process.argv.includes('--startup');
+// When run directly from the repo (not via npx/node_modules), default to dry-run
+// so local testing never silently clobbers the live ~/.claude/skills install.
+// Pass --install to actually write files, or --dry-run to force preview mode.
+const IS_LOCAL = !__dirname.includes('node_modules');
+const DRY_RUN = process.argv.includes('--dry-run') ||
+  (IS_LOCAL && !process.argv.includes('--install'));
+
+// ── Deprecated skills ──────────────────────────────────────────────────────
+// Skills that were renamed or removed. The installer removes these on every
+// run so users don't end up with both the old and new name installed.
+const DEPRECATED_SKILLS = [
+  'estack-prompt-builder', // renamed to estack-prompt-builder-coach
+];
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
@@ -39,15 +54,23 @@ function walkDir(dir, base) {
   return files;
 }
 
+function computeFileHash(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const hash = crypto.createHash('sha256');
+  const raw = fs.readFileSync(filePath);
+  hash.update(Buffer.from(raw.toString('utf8').replace(/\r\n/g, '\n')));
+  return hash.digest('hex');
+}
+
 function computeSkillHash(skillDir) {
   if (!fs.existsSync(skillDir)) return null;
   const hash = crypto.createHash('sha256');
   const files = walkDir(skillDir, skillDir);
   for (const relPath of files) {
     const fullPath = path.join(skillDir, relPath);
-    const contents = fs.readFileSync(fullPath);
+    const raw = fs.readFileSync(fullPath);
     hash.update(relPath.replace(/\\/g, '/'));
-    hash.update(contents);
+    hash.update(Buffer.from(raw.toString('utf8').replace(/\r\n/g, '\n')));
   }
   return hash.digest('hex');
 }
@@ -66,6 +89,14 @@ function backupSkill(name) {
   copyDir(installedDir, path.join(BACKUP_DIR, name));
 }
 
+function backupHook(filename) {
+  const installedFile = path.join(HOOKS_DIR, filename);
+  if (!fs.existsSync(installedFile)) return;
+  const dest = path.join(BACKUP_DIR, 'hooks', filename);
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(installedFile, dest);
+}
+
 function promptChar(question) {
   if (!process.stdin.isTTY) {
     // Non-interactive environment — read a line from piped stdin
@@ -118,9 +149,11 @@ function getSkillDescription(skillDir) {
   return '';
 }
 
-// ── Startup hook setup ─────────────────────────────────────────────────────
+// ── Hook setup ─────────────────────────────────────────────────────────────
 
-function setupStartupHook() {
+// Returns true if the hook was added (or would be added in dryRun), false if
+// it was already configured. In dryRun mode nothing is written to disk.
+function setupStartupHook(dryRun) {
   let settings = {};
   if (fs.existsSync(SETTINGS_FILE)) {
     try {
@@ -143,6 +176,8 @@ function setupStartupHook() {
     }
   }
 
+  if (dryRun) return true;
+
   if (!settings.hooks) settings.hooks = {};
   if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
 
@@ -164,9 +199,75 @@ function setupStartupHook() {
   return true;
 }
 
+// Returns true if the hook was added (or would be added in dryRun), false if
+// it was already configured. In dryRun mode nothing is written to disk.
+function setupRepoSearchNudgeHook(dryRun) {
+  let settings = {};
+  if (fs.existsSync(SETTINGS_FILE)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'));
+    } catch (_) {
+      settings = {};
+    }
+  }
+
+  if (settings.hooks && settings.hooks.PostToolUse) {
+    for (const group of settings.hooks.PostToolUse) {
+      if (group.matcher === 'WebFetch|WebSearch' && group.hooks) {
+        for (const hook of group.hooks) {
+          if (hook.command && hook.command.includes('repo-search-nudge.js')) {
+            return false;
+          }
+        }
+      }
+    }
+  }
+
+  if (dryRun) return true;
+
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+
+  settings.hooks.PostToolUse.push({
+    matcher: 'WebFetch|WebSearch',
+    hooks: [{
+      type: 'command',
+      command: `node "${path.join(HOOKS_DIR, 'repo-search-nudge.js').replace(/\\/g, '/')}"`,
+      timeout: 5,
+    }],
+  });
+
+  fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+  fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+  return true;
+}
+
 // ── Main ────────────────────────────────────────────────────────────────────
 
 async function main() {
+  // 0. Remove deprecated skills (renamed/deleted from the package)
+  if (fs.existsSync(SKILLS_DIR)) {
+    const newChecksums0 = fs.existsSync(CHECKSUMS_FILE)
+      ? (() => { try { return JSON.parse(fs.readFileSync(CHECKSUMS_FILE, 'utf8')); } catch (_) { return {}; } })()
+      : {};
+    let changed = false;
+    for (const name of DEPRECATED_SKILLS) {
+      const dir = path.join(SKILLS_DIR, name);
+      if (fs.existsSync(dir)) {
+        if (!DRY_RUN) fs.rmSync(dir, { recursive: true, force: true });
+        delete newChecksums0[name];
+        changed = true;
+        if (!SILENT && !STARTUP) {
+          console.log((DRY_RUN ? '  [dry run] Would remove deprecated skill: ' : '  Removed deprecated skill: ') + name);
+        }
+      } else if (newChecksums0[name]) {
+        delete newChecksums0[name];
+        changed = true;
+      }
+    }
+    if (changed && !DRY_RUN) fs.writeFileSync(CHECKSUMS_FILE, JSON.stringify(newChecksums0, null, 2));
+  }
+
   // 1. Scan package skills
   if (!fs.existsSync(PACKAGE_SKILLS_DIR)) {
     if (!SILENT && !STARTUP) {
@@ -191,6 +292,16 @@ async function main() {
     packageHashes[name] = computeSkillHash(path.join(PACKAGE_SKILLS_DIR, name));
   }
 
+  // 2b. Scan package hooks
+  const hookFilenames = fs.existsSync(PACKAGE_HOOKS_DIR)
+    ? fs.readdirSync(PACKAGE_HOOKS_DIR).filter((f) => f.endsWith('.js')).sort()
+    : [];
+
+  const packageHookHashes = {};
+  for (const filename of hookFilenames) {
+    packageHookHashes[filename] = computeFileHash(path.join(PACKAGE_HOOKS_DIR, filename));
+  }
+
   // 3. Load existing checksums
   let storedChecksums = {};
   if (fs.existsSync(CHECKSUMS_FILE)) {
@@ -221,7 +332,7 @@ async function main() {
     } else if (currentHash !== storedChecksums[name]) {
       // Stored checksum exists but current doesn't match — user modified it
       modifiedSkills.push(name);
-      if (storedChecksums[name] !== packageHashes[name]) {
+      if (currentHash !== packageHashes[name]) {
         needsUpdate.push(name);
       }
     } else if (currentHash !== packageHashes[name]) {
@@ -230,9 +341,36 @@ async function main() {
     }
   }
 
+  // 4b. Detect local modifications and needed updates for hooks
+  const modifiedHooks = [];
+  const hooksNeedingUpdate = [];
+  for (const filename of hookFilenames) {
+    const installedFile = path.join(HOOKS_DIR, filename);
+    const key = 'hook:' + filename;
+    if (!fs.existsSync(installedFile)) {
+      hooksNeedingUpdate.push(filename);
+      continue;
+    }
+    const currentHash = computeFileHash(installedFile);
+    if (!storedChecksums[key]) {
+      if (currentHash !== packageHookHashes[filename]) {
+        modifiedHooks.push(filename);
+        hooksNeedingUpdate.push(filename);
+      }
+    } else if (currentHash !== storedChecksums[key]) {
+      modifiedHooks.push(filename);
+      if (storedChecksums[key] !== packageHookHashes[filename]) {
+        hooksNeedingUpdate.push(filename);
+      }
+    } else if (currentHash !== packageHookHashes[filename]) {
+      hooksNeedingUpdate.push(filename);
+    }
+  }
+
   // 5. Silent mode — no output at all
   if (SILENT) {
-    if (needsUpdate.length === 0 && modifiedSkills.length === 0) {
+    if (needsUpdate.length === 0 && modifiedSkills.length === 0 &&
+        hooksNeedingUpdate.length === 0 && modifiedHooks.length === 0) {
       process.exit(0);
     }
     fs.mkdirSync(SKILLS_DIR, { recursive: true });
@@ -243,13 +381,21 @@ async function main() {
       copyDir(path.join(PACKAGE_SKILLS_DIR, name), path.join(SKILLS_DIR, name));
       newChecksums[name] = packageHashes[name];
     }
+    fs.mkdirSync(HOOKS_DIR, { recursive: true });
+    for (const filename of hookFilenames) {
+      if (modifiedHooks.includes(filename)) continue;
+      if (!hooksNeedingUpdate.includes(filename) && fs.existsSync(path.join(HOOKS_DIR, filename))) continue;
+      fs.copyFileSync(path.join(PACKAGE_HOOKS_DIR, filename), path.join(HOOKS_DIR, filename));
+      newChecksums['hook:' + filename] = packageHookHashes[filename];
+    }
     fs.writeFileSync(CHECKSUMS_FILE, JSON.stringify(newChecksums, null, 2));
     process.exit(0);
   }
 
   // 6. Startup mode — non-interactive, backup + merge context for Claude Code
   if (STARTUP) {
-    if (needsUpdate.length === 0 && modifiedSkills.length === 0) {
+    if (needsUpdate.length === 0 && modifiedSkills.length === 0 &&
+        hooksNeedingUpdate.length === 0 && modifiedHooks.length === 0) {
       process.exit(0);
     }
 
@@ -273,6 +419,27 @@ async function main() {
       updated.push(name);
     }
 
+    // Install hooks
+    fs.mkdirSync(HOOKS_DIR, { recursive: true });
+    const updatedHooks = [];
+    const mergeNeededHooks = [];
+
+    for (const filename of hookFilenames) {
+      if (modifiedHooks.includes(filename)) {
+        backupHook(filename);
+        fs.copyFileSync(path.join(PACKAGE_HOOKS_DIR, filename), path.join(HOOKS_DIR, filename));
+        newChecksums['hook:' + filename] = packageHookHashes[filename];
+        mergeNeededHooks.push(filename);
+        continue;
+      }
+      if (!hooksNeedingUpdate.includes(filename) && fs.existsSync(path.join(HOOKS_DIR, filename))) continue;
+      fs.copyFileSync(path.join(PACKAGE_HOOKS_DIR, filename), path.join(HOOKS_DIR, filename));
+      newChecksums['hook:' + filename] = packageHookHashes[filename];
+      updatedHooks.push(filename);
+    }
+
+    setupRepoSearchNudgeHook();
+
     fs.writeFileSync(CHECKSUMS_FILE, JSON.stringify(newChecksums, null, 2));
 
     // Build output for Claude Code
@@ -283,6 +450,10 @@ async function main() {
       msgParts.push('estack: updated ' + updated.join(', '));
     }
 
+    if (updatedHooks.length > 0) {
+      msgParts.push('estack: updated hooks ' + updatedHooks.join(', '));
+    }
+
     if (mergeNeeded.length > 0) {
       const backupPath = BACKUP_DIR.replace(HOME, '~');
       msgParts.push(
@@ -299,6 +470,21 @@ async function main() {
         'identify the user\'s changes, and apply them to the new version where compatible.';
     }
 
+    if (mergeNeededHooks.length > 0) {
+      const backupPath = BACKUP_DIR.replace(HOME, '~');
+      msgParts.push(
+        'estack: updated hooks ' + mergeNeededHooks.join(', ') +
+        ' (local changes backed up to ' + backupPath + '/hooks/)'
+      );
+      const existingContext = output.additionalContext ? output.additionalContext + ' ' : '';
+      output.additionalContext =
+        existingContext +
+        'estack hooks were updated but the user had local modifications to: ' +
+        mergeNeededHooks.join(', ') + '. ' +
+        'Their previous versions are saved at ' + path.join(BACKUP_DIR, 'hooks') + '. ' +
+        'The new upstream versions are now installed at ' + HOOKS_DIR + '.';
+    }
+
     if (msgParts.length > 0) {
       output.systemMessage = msgParts.join('\n');
     }
@@ -312,37 +498,53 @@ async function main() {
   // 7. Interactive mode — prompt if modifications detected
   let modifiedAction = null; // 'overwrite', 'skip', or 'merge'
 
-  if (modifiedSkills.length > 0) {
-    console.log('\nThe following skills have been modified locally:');
-    for (const name of modifiedSkills) {
-      console.log('  - ' + name);
+  if (modifiedSkills.length > 0 || modifiedHooks.length > 0) {
+    console.log('\nThe following items have been modified locally:');
+    if (modifiedSkills.length > 0) {
+      console.log('  Skills:');
+      for (const name of modifiedSkills) {
+        console.log('    - ' + name);
+      }
+    }
+    if (modifiedHooks.length > 0) {
+      console.log('  Hooks:');
+      for (const filename of modifiedHooks) {
+        console.log('    - ' + filename);
+      }
     }
-    console.log('\nChoose an action:');
-    console.log('  [o] Overwrite all (replace with latest)');
-    console.log('  [s] Skip all (keep local versions)');
-    console.log('  [m] Merge (backup local, install new, merge in Claude Code)');
-    console.log('  [a] Abort (cancel installation)');
-    console.log('');
-
-    const answer = await promptChar('Your choice (o/s/m/a): ');
 
-    if (answer === 'a') {
-      console.log('Installation aborted.');
-      process.exit(0);
-    } else if (answer === 's') {
-      modifiedAction = 'skip';
-    } else if (answer === 'm') {
-      modifiedAction = 'merge';
-    } else if (answer === 'o') {
+    if (DRY_RUN) {
+      console.log('\n[dry run] Would prompt: overwrite / skip / merge / abort');
+      console.log('[dry run] Showing what would happen with default overwrite...');
       modifiedAction = 'overwrite';
     } else {
-      console.log('Invalid choice. Installation aborted.');
-      process.exit(1);
+      console.log('\nChoose an action:');
+      console.log('  [o] Overwrite all (replace with latest)');
+      console.log('  [s] Skip all (keep local versions)');
+      console.log('  [m] Merge (backup local, install new, merge in Claude Code)');
+      console.log('  [a] Abort (cancel installation)');
+      console.log('');
+
+      const answer = await promptChar('Your choice (o/s/m/a): ');
+
+      if (answer === 'a') {
+        console.log('Installation aborted.');
+        process.exit(0);
+      } else if (answer === 's') {
+        modifiedAction = 'skip';
+      } else if (answer === 'm') {
+        modifiedAction = 'merge';
+      } else if (answer === 'o') {
+        modifiedAction = 'overwrite';
+      } else {
+        console.log('Invalid choice. Installation aborted.');
+        process.exit(1);
+      }
     }
   }
 
   // 8. Install skills
-  fs.mkdirSync(SKILLS_DIR, { recursive: true });
+  if (!DRY_RUN) fs.mkdirSync(SKILLS_DIR, { recursive: true });
   const newChecksums = Object.assign({}, storedChecksums);
   let installedCount = 0;
   const mergedSkills = [];
@@ -356,30 +558,85 @@ async function main() {
         continue;
       }
       if (modifiedAction === 'merge') {
-        backupSkill(name);
+        if (!DRY_RUN) backupSkill(name);
         mergedSkills.push(name);
-        console.log('  Backed up ' + name + ' → ~/.claude/.estack-backup/' + name);
+        console.log((DRY_RUN ? '  [dry run] Would back up ' : '  Backed up ') + name + ' → ~/.claude/.estack-backup/' + name);
       }
       // overwrite or merge — fall through to install
     } else if (!needsUpdate.includes(name) && fs.existsSync(path.join(SKILLS_DIR, name))) {
       // Already installed and up-to-date
+      if (DRY_RUN) console.log('  [dry run] Up to date (no change): ' + name);
       continue;
     }
-    copyDir(path.join(PACKAGE_SKILLS_DIR, name), path.join(SKILLS_DIR, name));
+    const isUpdate = fs.existsSync(path.join(SKILLS_DIR, name));
+    if (!DRY_RUN) copyDir(path.join(PACKAGE_SKILLS_DIR, name), path.join(SKILLS_DIR, name));
     newChecksums[name] = packageHashes[name];
     installedCount++;
-    console.log('  Installed ' + name);
+    if (DRY_RUN) {
+      console.log('  [dry run] Would ' + (isUpdate ? 'update ' : 'install ') + name);
+    } else {
+      console.log('  Installed ' + name);
+    }
+  }
+
+  // 8b. Install hooks
+  if (!DRY_RUN) fs.mkdirSync(HOOKS_DIR, { recursive: true });
+  let installedHookCount = 0;
+  const mergedHooks = [];
+
+  for (const filename of hookFilenames) {
+    if (modifiedHooks.includes(filename)) {
+      if (modifiedAction === 'skip') {
+        console.log('  Skipped hook ' + filename + ' (local modifications preserved)');
+        const currentHash = computeFileHash(path.join(HOOKS_DIR, filename));
+        if (currentHash) newChecksums['hook:' + filename] = currentHash;
+        continue;
+      }
+      if (modifiedAction === 'merge') {
+        if (!DRY_RUN) backupHook(filename);
+        mergedHooks.push(filename);
+        console.log((DRY_RUN ? '  [dry run] Would back up hook ' : '  Backed up hook ') + filename + ' → ~/.claude/.estack-backup/hooks/' + filename);
+      }
+      // overwrite or merge — fall through to install
+    } else if (!hooksNeedingUpdate.includes(filename) && fs.existsSync(path.join(HOOKS_DIR, filename))) {
+      // Already installed and up-to-date
+      if (DRY_RUN) console.log('  [dry run] Up to date (no change): hook ' + filename);
+      continue;
+    }
+    const isHookUpdate = fs.existsSync(path.join(HOOKS_DIR, filename));
+    if (!DRY_RUN) fs.copyFileSync(path.join(PACKAGE_HOOKS_DIR, filename), path.join(HOOKS_DIR, filename));
+    newChecksums['hook:' + filename] = packageHookHashes[filename];
+    installedHookCount++;
+    if (DRY_RUN) {
+      console.log('  [dry run] Would ' + (isHookUpdate ? 'update hook ' : 'install hook ') + filename);
+    } else {
+      console.log('  Installed hook ' + filename);
+    }
   }
 
   // 9. Write checksums
-  fs.writeFileSync(CHECKSUMS_FILE, JSON.stringify(newChecksums, null, 2));
+  if (!DRY_RUN) fs.writeFileSync(CHECKSUMS_FILE, JSON.stringify(newChecksums, null, 2));
 
-  // 10. Setup startup hook
-  const hookInstalled = setupStartupHook();
+  // 10. Setup startup hook and repo-search nudge hook
+  // In dry-run these inspect settings.json read-only and report would-be action.
+  const hookInstalled = setupStartupHook(DRY_RUN);
+  const nudgeHookInstalled = setupRepoSearchNudgeHook(DRY_RUN);
 
   // 11. Summary output
-  console.log('\nestack installed successfully!\n');
-  console.log('  ' + installedCount + ' skill' + (installedCount !== 1 ? 's' : '') + ' installed to ~/.claude/skills/\n');
+  if (DRY_RUN) {
+    console.log('\n[dry run] No files were changed. Run with --install to apply.\n');
+    console.log('  ' + installedCount + ' skill' + (installedCount !== 1 ? 's' : '') + ' would be installed/updated in ~/.claude/skills/');
+    if (installedHookCount > 0) {
+      console.log('  ' + installedHookCount + ' hook' + (installedHookCount !== 1 ? 's' : '') + ' would be installed/updated in ~/.claude/hooks/');
+    }
+  } else {
+    console.log('\nestack installed successfully!\n');
+    console.log('  ' + installedCount + ' skill' + (installedCount !== 1 ? 's' : '') + ' installed to ~/.claude/skills/');
+    if (installedHookCount > 0) {
+      console.log('  ' + installedHookCount + ' hook' + (installedHookCount !== 1 ? 's' : '') + ' installed to ~/.claude/hooks/');
+    }
+  }
+  console.log('');
   console.log('Skills available:');
 
   for (const name of skillNames) {
@@ -393,12 +650,34 @@ async function main() {
     console.log('  "Merge my estack changes from ~/.claude/.estack-backup/"');
   }
 
-  if (hookInstalled) {
-    console.log('\nAuto-update hook added to ~/.claude/settings.json');
-    console.log('Skills will update automatically when you start Claude Code.');
+  if (mergedHooks.length > 0) {
+    console.log('\nLocal hook changes backed up for: ' + mergedHooks.join(', '));
+    console.log('Backed up to ~/.claude/.estack-backup/hooks/');
+  }
+
+  if (DRY_RUN) {
+    if (hookInstalled) {
+      console.log('\n[dry run] Would add auto-update hook to ~/.claude/settings.json');
+    } else {
+      console.log('\nAuto-update hook already configured (no change).');
+    }
+    if (nudgeHookInstalled) {
+      console.log('[dry run] Would register repo-search nudge hook in settings.json.');
+    } else {
+      console.log('Repo-search nudge hook already configured (no change).');
+    }
   } else {
-    console.log('\nAuto-update hook already configured.');
+    if (hookInstalled) {
+      console.log('\nAuto-update hook added to ~/.claude/settings.json');
+      console.log('Skills will update automatically when you start Claude Code.');
+    } else {
+      console.log('\nAuto-update hook already configured.');
+    }
+    if (nudgeHookInstalled) {
+      console.log('Repo-search nudge hook registered in settings.json.');
+    }
   }
+
   console.log('');
 }
 

package/hooks/repo-search-nudge.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// PostToolUse hook: nudges toward the repo-search skill when GitHub is involved.
+// Fires on every WebFetch or WebSearch that touches a github.com URL.
+
+const SKILL_NAME = "estack-repo-search";
+
+let input = "";
+process.stdin.on("data", (c) => (input += c));
+process.stdin.on("end", () => {
+  try { run(input); } catch { /* never break the tool */ }
+  process.exit(0);
+});
+
+function emitNudge() {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PostToolUse",
+      additionalContext: `GitHub repo detected. For deeper code questions, consider the ${SKILL_NAME} skill — it clones and greps the repo locally, which is usually faster and more accurate than web fetching multiple GitHub pages.`
+    }
+  }) + "\n");
+}
+
+function run(raw) {
+  let payload;
+  try { payload = JSON.parse(raw); } catch { return; }
+
+  const tool = payload.tool_name;
+  if (tool !== "WebFetch" && tool !== "WebSearch") return;
+
+  if (/github\.com/i.test(raw)) emitNudge();
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "elliot-stack",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Elliot's skill stack for Claude Code — install via npx elliot-stack@latest",
   "bin": {
     "elliot-stack": "bin/install.cjs"
   },
   "files": [
     "bin/",
-    "skills/"
+    "skills/",
+    "hooks/"
   ],
   "keywords": [
     "claude-code",