sticky-note-cli 2.9.1 → 3.0.0

package/bin/cli.js

@@ -25,6 +25,7 @@ const VERSION = require("../package.json").version;
 
 const HOOK_FILES = [
   "sticky-utils.js",
+  "data-branch.js",          // git plumbing module for sticky-note/data branch
   "session-start.js",
   "session-end.js",
   "inject-context.js",
@@ -83,26 +84,116 @@ function readTemplate(name) {
   return fs.readFileSync(path.join(TEMPLATES_DIR, name), "utf-8");
 }
 
-// Replace $(git rev-parse --show-toplevel) with absolute root path
-// so hook commands work from any CWD without shell expansion.
-function resolveHookPaths(obj, rootDir) {
-  const root = rootDir.replace(/\\/g, "/");
-  const resolve = (s) =>
-    s.replace(/"\$\(git rev-parse --show-toplevel\)\//g, `"${root}/`);
-  const hooks = obj.hooks || {};
+// Hook commands in templates use relative paths (e.g. ".claude/hooks/foo.js")
+// because Claude Code and Copilot CLI both resolve hook commands relative to
+// the project root. Earlier versions rewrote these to absolute paths at init
+// time, but that path was machine-specific and got committed to settings.json,
+// causing every teammate's hooks to fail silently (issue #11). This is now a
+// no-op, kept only to avoid breaking any external callers of the function.
+function resolveHookPaths(_obj, _rootDir) {
+  return;
+}
+
+// Detects hook commands in an existing settings.json that point at an absolute
+// path (likely written by an older sticky-note-cli on another developer's
+// machine). Returns the list of stale command strings, or [] if all clean.
+function findStaleHookPaths(settings) {
+  const stale = [];
+  const hooks = (settings && settings.hooks) || {};
   for (const entries of Object.values(hooks)) {
     for (const entry of Array.isArray(entries) ? entries : []) {
-      if (entry.hooks) {
-        for (const h of entry.hooks) {
-          if (h.command) h.command = resolve(h.command);
+      for (const h of entry.hooks || []) {
+        const cmd = h && h.command;
+        if (typeof cmd !== "string") continue;
+        // Absolute paths (Unix /Users, /home, /root or Windows C:/, D:/ etc.)
+        // inside the hook command are the smoking gun. Match anywhere in the
+        // string — the path may be preceded by other tokens (env vars, shell
+        // prefixes) and may contain spaces.
+        if (
+          /["'][A-Za-z]:[\\/]/.test(cmd) ||
+          /["']\/(?:Users|home|root|tmp)\//.test(cmd) ||
+          cmd.includes("$(git rev-parse")
+        ) {
+          stale.push(cmd);
+        }
+        // Old relative-path format: node ".claude/hooks/foo.js"
+        // This fails when Claude Code launches from a subdirectory of the
+        // project root, because the path resolves relative to the launch cwd,
+        // not relative to where .claude/settings.json lives. The fix is to
+        // use `npx sticky-note run-hook foo` which walks up to find the hooks.
+        if (/node\s+["']\.claude[\\/]hooks[\\/][^"']+\.js["']/.test(cmd)) {
+          stale.push(cmd);
         }
       }
-      if (entry.bash) entry.bash = resolve(entry.bash);
-      if (entry.powershell) entry.powershell = resolve(entry.powershell);
-      if (entry.command) entry.command = resolve(entry.command);
     }
   }
-  return obj;
+  return stale;
+}
+
+// Parse a semver-ish version string ("2.9.1", "2.9.1-beta.1", "v2.9") into
+// [major, minor, patch] numbers. Pre-release suffixes are ignored. Returns
+// null if unparseable.
+function parseSemver(v) {
+  if (typeof v !== "string") return null;
+  const m = v.trim().replace(/^v/, "").match(/^(\d+)\.(\d+)(?:\.(\d+))?/);
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3] || 0)];
+}
+
+// Returns -1 if a < b, 0 if equal, 1 if a > b. Unparseable values sort last.
+function compareSemver(a, b) {
+  const pa = parseSemver(a), pb = parseSemver(b);
+  if (!pa && !pb) return 0;
+  if (!pa) return 1;
+  if (!pb) return -1;
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
+  }
+  return 0;
+}
+
+// When updating an existing config, only bump min_version forward — never
+// downgrade if a teammate has already pinned a newer minimum.
+function bumpMinVersion(existing, current) {
+  if (!existing) return current;
+  return compareSemver(existing, current) >= 0 ? existing : current;
+}
+
+// Add sticky-note-cli to the project package.json devDependencies so every
+// teammate gets a pinned working copy on `npm install` (issue #12). No-ops
+// gracefully if there is no package.json or if the entry is already present
+// at >= the current version.
+function pinCliInPackageJson() {
+  const pkgPath = path.join(process.cwd(), "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    print("  ⏭️  No package.json found — skipping devDependency pin");
+    return;
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  } catch (err) {
+    print(`  ⏭️  Could not parse package.json: ${err.message}`);
+    return;
+  }
+  pkg.devDependencies = pkg.devDependencies || {};
+  const existing = pkg.devDependencies["sticky-note-cli"];
+  const desired = `^${VERSION}`;
+  if (existing) {
+    const existingClean = String(existing).replace(/^[\^~]/, "");
+    if (compareSemver(existingClean, VERSION) >= 0) {
+      print(`  ⏭️  package.json devDependencies already pin sticky-note-cli ${existing}`);
+      return;
+    }
+  }
+  pkg.devDependencies["sticky-note-cli"] = desired;
+  // Keep keys sorted for clean diffs
+  pkg.devDependencies = Object.fromEntries(
+    Object.entries(pkg.devDependencies).sort(([a], [b]) => a.localeCompare(b))
+  );
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  print(`  [OK] package.json devDependencies: sticky-note-cli ${desired}`);
+  print("       Run `npm install` to lock the version for your team.");
 }
 
 function makeExecutable(filePath) {
@@ -654,17 +745,32 @@ async function cmdInit() {
     print(`  [OK] .claude/hooks/${file}`);
   }
 
-  // Create settings.json (Claude Code)
+  // Create settings.json (Claude Code) — uses relative hook paths so it can
+  // be safely committed and shared across teammates (issue #11).
   const settingsTemplate = JSON.parse(readTemplate("settings.json"));
-  resolveHookPaths(settingsTemplate, process.cwd());
   const settingsDest = path.join(process.cwd(), ".claude", "settings.json");
+  if (fs.existsSync(settingsDest)) {
+    const existing = readJsonSafe(settingsDest, {});
+    const stale = findStaleHookPaths(existing);
+    if (stale.length > 0) {
+      print("  ⚠️  .claude/settings.json contains absolute or shell-expanded hook paths:");
+      for (const cmd of stale.slice(0, 3)) print(`       ${cmd}`);
+      print("       Rewriting with relative paths so hooks work for every teammate.");
+    }
+  }
   fs.writeFileSync(settingsDest, JSON.stringify(settingsTemplate, null, 2) + "\n");
   print("  [OK] .claude/settings.json");
 
-  // Create hooks.json (Copilot CLI)
+  // Create hooks.json (Copilot CLI) — also relative paths.
   const hooksTemplate = JSON.parse(readTemplate("hooks.json"));
-  resolveHookPaths(hooksTemplate, process.cwd());
   const hooksDest = path.join(githubHooksDir, "hooks.json");
+  if (fs.existsSync(hooksDest)) {
+    const existing = readJsonSafe(hooksDest, {});
+    const stale = findStaleHookPaths(existing);
+    if (stale.length > 0) {
+      print("  ⚠️  .github/hooks/hooks.json contains absolute or shell-expanded hook paths — rewriting.");
+    }
+  }
   fs.writeFileSync(hooksDest, JSON.stringify(hooksTemplate, null, 2) + "\n");
   print("  [OK] .github/hooks/hooks.json");
 
@@ -718,6 +824,7 @@ async function cmdInit() {
     configTemplate.stale_days = staleDaysResolved;
     configTemplate.inject_token_budget = injectTokenBudgetResolved;
     configTemplate.hook_version = VERSION;
+    configTemplate.min_version = VERSION;
     fs.writeFileSync(configDest, JSON.stringify(configTemplate, null, 2) + "\n");
   } else {
     // Update existing config with new settings
@@ -728,10 +835,15 @@ async function cmdInit() {
     existing.stale_days = staleDaysResolved;
     existing.inject_token_budget = injectTokenBudgetResolved;
     existing.hook_version = VERSION;
+    existing.min_version = bumpMinVersion(existing.min_version, VERSION);
     fs.writeFileSync(configDest, JSON.stringify(existing, null, 2) + "\n");
   }
   print("  [OK] .sticky-note/sticky-note-config.json");
 
+  // Pin sticky-note-cli in the project package.json devDependencies so every
+  // teammate gets the same version on `npm install` (issue #12).
+  pinCliInPackageJson();
+
   // Update .gitignore
   const gitignorePath = path.join(process.cwd(), ".gitignore");
   const ignoreAdditions = fs
@@ -872,15 +984,9 @@ async function cmdInit() {
     print("  [OK] .git/hooks/post-rewrite (attribution survives rebase)");
   }
 
-  // Install pre-commit hook (auto-stage .sticky-note/ files)
-  if (installPreCommitHook()) {
-    print("  [OK] .git/hooks/pre-commit (auto-stage .sticky-note/ files)");
-  }
-
-  // Install post-commit hook (auto-commit leftover .sticky-note/ changes)
-  if (installPostCommitHook()) {
-    print("  [OK] .git/hooks/post-commit (auto-sync .sticky-note/ after commit)");
-  }
+  // Data branch sync handles persistence — no pre/post-commit hooks needed
+  print("  [OK] Skipping git pre/post-commit hooks (data branch sync handles this now)");
+  print("       Run `npx sticky-note migrate` to migrate existing .sticky-note/ data.");
 
   // Create environment directory structure
   const envDir = path.join(stickyNoteDir, "environment");
@@ -998,8 +1104,11 @@ function cmdUpdate() {
   const settingsPath = path.join(process.cwd(), ".claude", "settings.json");
   if (fs.existsSync(settingsPath)) {
     const settingsTemplate = JSON.parse(readTemplate("settings.json"));
-    resolveHookPaths(settingsTemplate, process.cwd());
     const existing = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    const stale = findStaleHookPaths(existing);
+    if (stale.length > 0) {
+      print("  ⚠️  Existing settings.json had absolute hook paths — replacing with relative paths.");
+    }
     existing.hooks = settingsTemplate.hooks;
     fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
     print("  [OK] .claude/settings.json (hooks updated)");
@@ -1009,7 +1118,6 @@ function cmdUpdate() {
   const hooksPath = path.join(process.cwd(), ".github", "hooks", "hooks.json");
   if (fs.existsSync(hooksPath)) {
     const hooksTemplate = JSON.parse(readTemplate("hooks.json"));
-    resolveHookPaths(hooksTemplate, process.cwd());
     fs.writeFileSync(hooksPath, JSON.stringify(hooksTemplate, null, 2) + "\n");
     print("  [OK] .github/hooks/hooks.json (updated)");
   }
@@ -1018,11 +1126,35 @@ function cmdUpdate() {
   if (installGitHook("post-rewrite")) {
     print("  [OK] .git/hooks/post-rewrite (attribution survives rebase)");
   }
-  if (installPreCommitHook()) {
-    print("  [OK] .git/hooks/pre-commit (auto-stage .sticky-note/ files)");
-  }
-  if (installPostCommitHook()) {
-    print("  [OK] .git/hooks/post-commit (auto-sync .sticky-note/ after commit)");
+
+  // Remove sticky-note pre-commit and post-commit git hooks (replaced by data branch)
+  const gitDir2 = path.join(process.cwd(), ".git");
+  if (fs.existsSync(gitDir2)) {
+    const gitHooksDir2 = path.join(gitDir2, "hooks");
+    for (const hookName of ["pre-commit", "post-commit"]) {
+      const hookPath2 = path.join(gitHooksDir2, hookName);
+      if (!fs.existsSync(hookPath2)) continue;
+      const content2 = fs.readFileSync(hookPath2, "utf-8");
+      if (!content2.includes(STICKY_PRE_COMMIT_MARKER) && !content2.includes(STICKY_POST_COMMIT_MARKER)) continue;
+      let updated2 = content2;
+      const preStart2 = updated2.indexOf(STICKY_PRE_COMMIT_MARKER);
+      const preEnd2 = updated2.indexOf(STICKY_PRE_COMMIT_END);
+      if (preStart2 !== -1 && preEnd2 !== -1) {
+        updated2 = updated2.slice(0, preStart2) + updated2.slice(preEnd2 + STICKY_PRE_COMMIT_END.length);
+      }
+      const postStart2 = updated2.indexOf(STICKY_POST_COMMIT_MARKER);
+      const postEnd2 = updated2.indexOf(STICKY_POST_COMMIT_END);
+      if (postStart2 !== -1 && postEnd2 !== -1) {
+        updated2 = updated2.slice(0, postStart2) + updated2.slice(postEnd2 + STICKY_POST_COMMIT_END.length);
+      }
+      if (updated2.replace(/^#!.*\n/, "").trim() === "") {
+        fs.unlinkSync(hookPath2);
+        print("  [OK] Removed .git/hooks/" + hookName + " (no longer needed)");
+      } else {
+        fs.writeFileSync(hookPath2, updated2, "utf-8");
+        print("  [OK] Removed sticky-note blocks from .git/hooks/" + hookName);
+      }
+    }
   }
 
   // Update hook_version in config
@@ -1161,6 +1293,33 @@ function cmdStatus() {
     `    ${fs.existsSync(hooksJsonPath) ? "[OK]" : "[ERR]"} .github/hooks/hooks.json`
   );
 
+  // Issue #11 guard: warn about absolute hook paths in shared config files.
+  for (const [label, p] of [
+    [".claude/settings.json", settingsPath],
+    [".github/hooks/hooks.json", hooksJsonPath],
+  ]) {
+    if (!fs.existsSync(p)) continue;
+    const data = readJsonSafe(p, {});
+    const stale = findStaleHookPaths(data);
+    if (stale.length > 0) {
+      print(`    ⚠️  ${label} has absolute hook paths — hooks will fail for teammates.`);
+      print("        Run `npx sticky-note init` to rewrite with relative paths.");
+    }
+  }
+
+  // Issue #12 guard: warn if installed CLI is below the project's min_version.
+  const configPathForVersionCheck = path.join(stickyDir, "sticky-note-config.json");
+  if (fs.existsSync(configPathForVersionCheck)) {
+    const cfg = readJsonSafe(configPathForVersionCheck, {});
+    if (cfg.min_version && compareSemver(VERSION, cfg.min_version) < 0) {
+      print(
+        `    ⚠️  Installed sticky-note-cli v${VERSION} is below the project's ` +
+        `min_version v${cfg.min_version}.`
+      );
+      print("        Run `npm i -D sticky-note-cli@latest` to update.");
+    }
+  }
+
   // Sticky Note data — V2 format
   const memoryPath = path.join(stickyDir, "sticky-note.json");
   const configPath = path.join(stickyDir, "sticky-note-config.json");
@@ -1243,7 +1402,7 @@ function cmdStatus() {
       const lastSeen = info.last_seen || "";
       if (lastSeen) {
         const ts = new Date(lastSeen).getTime();
-        if (!isNaN(ts) && now - ts < 15 * 60 * 1000) {
+        if (!isNaN(ts) && now - ts < 60 * 60 * 1000) {
           activeUsers.push(path.basename(f, ".json"));
         }
       }
@@ -1687,7 +1846,7 @@ function cmdWho() {
       for (const [user, info] of Object.entries(data)) {
         const lastSeen = info.last_seen || "";
         const ts = lastSeen ? new Date(lastSeen).getTime() : 0;
-        const active = !isNaN(ts) && now - ts < 15 * 60 * 1000;
+        const active = !isNaN(ts) && now - ts < 60 * 60 * 1000;
         const ago = lastSeen ? _relativeTime(lastSeen) : "unknown";
         const files = (info.active_files || []).slice(0, 5).join(", ");
         const marker = active ? "[ACTIVE]" : "[IDLE]";
@@ -1713,7 +1872,7 @@ function cmdWho() {
     const info = readJsonSafe(path.join(presenceDir, f), {});
     const lastSeen = info.last_seen || "";
     const ts = lastSeen ? new Date(lastSeen).getTime() : 0;
-    const active = !isNaN(ts) && now - ts < 15 * 60 * 1000;
+    const active = !isNaN(ts) && now - ts < 60 * 60 * 1000;
     users.push({ user, info, lastSeen, active });
   }
 
@@ -3218,6 +3377,308 @@ async function cmdEnvAddPlugin() {
   print("");
 }
 
+// ──────────────────────────────────────────────
+// run-hook: locate and execute a hook from any directory
+// ──────────────────────────────────────────────
+
+function cmdRunHook() {
+  const { spawnSync } = require("child_process");
+  const hookName = process.argv[3]; // e.g. "session-start"
+
+  if (!hookName) {
+    process.stderr.write(
+      "[sticky-note] run-hook: missing hook name\n" +
+      "  Usage: npx sticky-note run-hook <name>\n" +
+      "  Names: session-start, session-end, inject-context, pre-tool-use,\n" +
+      "         track-work, on-stop, on-error\n"
+    );
+    // Emit empty output so Claude Code doesn't choke on missing stdout JSON
+    process.stdout.write(JSON.stringify({ output: "" }) + "\n");
+    process.exit(0);
+  }
+
+  // Walk up from cwd to find .claude/hooks/<name>.js
+  const hookFile = hookName.endsWith(".js") ? hookName : `${hookName}.js`;
+  let dir = process.cwd();
+  let hookPath = null;
+  for (let i = 0; i < 20; i++) {
+    const candidate = path.join(dir, ".claude", "hooks", hookFile);
+    if (fs.existsSync(candidate)) {
+      hookPath = candidate;
+      break;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break; // filesystem root
+    dir = parent;
+  }
+
+  if (!hookPath) {
+    // Hook not installed — exit silently (non-fatal)
+    process.stdout.write(JSON.stringify({ output: "" }) + "\n");
+    process.exit(0);
+  }
+
+  // Spawn the hook with stdin/stdout/stderr inherited so Claude Code's pipe
+  // flows through to the hook process unchanged.
+  const result = spawnSync(process.execPath, [hookPath], {
+    stdio: "inherit",
+    env: process.env,
+  });
+  process.exit(result.status != null ? result.status : 0);
+}
+
+// ──────────────────────────────────────────────
+// MIGRATE command
+// ──────────────────────────────────────────────
+
+/**
+ * One-time migration from .sticky-note/ (feature-branch storage) to
+ * .git/sticky-note/ (data-branch storage).
+ *
+ * Idempotent — safe to run multiple times.
+ */
+async function cmdMigrate() {
+  printBanner();
+
+  if (!isGitRepo()) {
+    print("  [ERR] Not a git repository.");
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+  const oldDir = path.join(cwd, ".sticky-note");
+
+  // Locate .git directory using plumbing (works from subdirectories)
+  let gitDir;
+  try {
+    gitDir = execFileSync("git", ["rev-parse", "--absolute-git-dir"], {
+      encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+      cwd,
+    }).trim();
+  } catch (err) {
+    print("  [ERR] Could not locate .git directory: " + err.message);
+    process.exit(1);
+  }
+
+  const newDir = path.join(gitDir, "sticky-note");
+  print("  📂 Source: " + oldDir);
+  print("  📂 Target: " + newDir);
+  print("");
+
+  // Step 1: Copy files from .sticky-note/ to .git/sticky-note/
+  mkdirSafe(newDir);
+  mkdirSafe(path.join(newDir, "audit"));
+  mkdirSafe(path.join(newDir, "presence"));
+
+  let copiedFiles = 0;
+  const srcMemory = path.join(oldDir, "sticky-note.json");
+  const dstMemory = path.join(newDir, "sticky-note.json");
+  if (fs.existsSync(srcMemory)) {
+    fs.copyFileSync(srcMemory, dstMemory);
+    copiedFiles++;
+    print("  [OK] Copied sticky-note.json");
+  } else if (!fs.existsSync(dstMemory)) {
+    // No existing data — create empty memory
+    fs.writeFileSync(
+      dstMemory,
+      JSON.stringify({ version: "2", project: "", threads: [] }, null, 2) + "\n"
+    );
+    print("  [OK] Created empty sticky-note.json (no .sticky-note/ found)");
+  }
+
+  const oldAuditDir = path.join(oldDir, "audit");
+  if (fs.existsSync(oldAuditDir)) {
+    for (const file of fs.readdirSync(oldAuditDir)) {
+      if (file.endsWith(".jsonl")) {
+        const dst = path.join(newDir, "audit", file);
+        if (!fs.existsSync(dst)) {
+          fs.copyFileSync(path.join(oldAuditDir, file), dst);
+          copiedFiles++;
+        }
+      }
+    }
+  }
+
+  const oldPresenceDir = path.join(oldDir, "presence");
+  if (fs.existsSync(oldPresenceDir)) {
+    for (const file of fs.readdirSync(oldPresenceDir)) {
+      if (file.endsWith(".json")) {
+        const dst = path.join(newDir, "presence", file);
+        if (!fs.existsSync(dst)) {
+          fs.copyFileSync(path.join(oldPresenceDir, file), dst);
+          copiedFiles++;
+        }
+      }
+    }
+  }
+  if (copiedFiles > 0) print("  [OK] Copied " + copiedFiles + " file(s) to .git/sticky-note/");
+
+  // Step 2: Commit files to sticky-note/data branch using plumbing
+  print("");
+  print("  📌 Committing to sticky-note/data branch...");
+  try {
+    // Inline the plumbing here (data-branch.js lives in hooks, not in CLI path)
+    _commitFilesToDataBranch(newDir);
+    print("  [OK] sticky-note/data branch created/updated");
+  } catch (err) {
+    print("  [WARN] Could not commit to data branch: " + err.message);
+  }
+
+  // Step 3: Add .sticky-note/ to .gitignore
+  print("");
+  const gitignorePath = path.join(cwd, ".gitignore");
+  const MARKER = "# sticky-note: data branch migration";
+  const IGNORE_LINE = ".sticky-note/";
+  let gitignoreUpdated = false;
+  if (fs.existsSync(gitignorePath)) {
+    const existing = fs.readFileSync(gitignorePath, "utf-8");
+    const gitignoreLines = existing.split(/\r?\n/).map(l => l.trim());
+    if (!gitignoreLines.includes(IGNORE_LINE)) {
+      fs.appendFileSync(gitignorePath, "\n" + MARKER + "\n" + IGNORE_LINE + "\n");
+      gitignoreUpdated = true;
+    }
+  } else {
+    fs.writeFileSync(gitignorePath, MARKER + "\n" + IGNORE_LINE + "\n");
+    gitignoreUpdated = true;
+  }
+  if (gitignoreUpdated) {
+    print("  [OK] Added .sticky-note/ to .gitignore");
+  } else {
+    print("  [OK] .gitignore already contains .sticky-note/");
+  }
+
+  // Step 4: Remove sticky-note pre-commit and post-commit hooks
+  print("");
+  const gitHooksDir = path.join(gitDir, "hooks");
+  for (const hookName of ["pre-commit", "post-commit"]) {
+    const hookPath = path.join(gitHooksDir, hookName);
+    if (!fs.existsSync(hookPath)) continue;
+    const content = fs.readFileSync(hookPath, "utf-8");
+    if (content.includes(STICKY_PRE_COMMIT_MARKER) || content.includes(STICKY_POST_COMMIT_MARKER)) {
+      // Remove sticky-note blocks
+      let updated = content;
+      // Remove pre-commit block
+      const preStart = updated.indexOf(STICKY_PRE_COMMIT_MARKER);
+      const preEnd = updated.indexOf(STICKY_PRE_COMMIT_END);
+      if (preStart !== -1 && preEnd !== -1) {
+        updated = updated.slice(0, preStart) + updated.slice(preEnd + STICKY_PRE_COMMIT_END.length);
+      }
+      // Remove post-commit block
+      const postStart = updated.indexOf(STICKY_POST_COMMIT_MARKER);
+      const postEnd = updated.indexOf(STICKY_POST_COMMIT_END);
+      if (postStart !== -1 && postEnd !== -1) {
+        updated = updated.slice(0, postStart) + updated.slice(postEnd + STICKY_POST_COMMIT_END.length);
+      }
+      // If only the shebang remains, delete the file
+      if (updated.replace(/^#!.*\n/, "").trim() === "") {
+        fs.unlinkSync(hookPath);
+        print("  [OK] Removed .git/hooks/" + hookName + " (was sticky-note only)");
+      } else {
+        fs.writeFileSync(hookPath, updated, "utf-8");
+        print("  [OK] Removed sticky-note blocks from .git/hooks/" + hookName);
+      }
+    }
+  }
+
+  // Step 5: Push data branch if remote exists
+  print("");
+  try {
+    const remote = execFileSync("git", ["remote"], {
+      encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+      cwd,
+    }).trim().split("\n")[0];
+    if (remote) {
+      print("  🔄 Pushing sticky-note/data to " + remote + "...");
+      execFileSync("git", ["push", remote, "refs/heads/sticky-note/data:refs/heads/sticky-note/data"], {
+        timeout: 30000, stdio: ["pipe", "pipe", "pipe"],
+        cwd,
+      });
+      print("  [OK] Pushed sticky-note/data");
+    } else {
+      print("  ⏭️  No remote configured — skipping push");
+    }
+  } catch (err) {
+    print("  [WARN] Push failed: " + err.message);
+    print("  [INFO] Your data is safe locally. Run `npx sticky-note migrate` again to retry.");
+  }
+
+  print("");
+  print("  ✅ Migration complete!");
+  print("");
+  print("  Next steps:");
+  print("  1. Commit the .gitignore change:  git add .gitignore && git commit -m 'chore: gitignore sticky-note data dir'");
+  print("  2. Each teammate runs:             npx sticky-note init");
+  print("");
+}
+
+/**
+ * Inline git plumbing to commit files from a local dir to sticky-note/data.
+ * Extracted from data-branch.js for use in CLI context (no hooks dir on PATH).
+ */
+function _commitFilesToDataBranch(srcDir) {
+  const os = require("os");
+  const crypto = require("crypto");
+  const branchRef = "refs/heads/sticky-note/data";
+  const tmpIndex = path.join(
+    os.tmpdir(),
+    "sticky-idx-" + process.pid + "-" + crypto.randomBytes(4).toString("hex")
+  );
+
+  try {
+    let parentSha = null;
+    try {
+      parentSha = execFileSync("git", ["rev-parse", "--verify", branchRef], {
+        encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+    } catch (_) {}
+
+    const indexEnv = { ...process.env, GIT_INDEX_FILE: tmpIndex };
+    if (parentSha) {
+      execFileSync("git", ["read-tree", parentSha], {
+        timeout: 5000, stdio: ["pipe", "pipe", "pipe"], env: indexEnv,
+      });
+    }
+
+    // Walk srcDir and commit all files
+    function walkAndAdd(dir, prefix) {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        const relPath = prefix ? prefix + "/" + entry.name : entry.name;
+        if (entry.isDirectory()) {
+          walkAndAdd(full, relPath);
+        } else if (entry.isFile() && !entry.name.startsWith(".sticky-")) {
+          const content = fs.readFileSync(full);
+          const blobSha = execFileSync("git", ["hash-object", "-w", "--stdin"], {
+            input: content, encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+          }).trim();
+          execFileSync(
+            "git",
+            ["update-index", "--add", "--cacheinfo", "100644," + blobSha + "," + relPath],
+            { timeout: 5000, stdio: ["pipe", "pipe", "pipe"], env: indexEnv }
+          );
+        }
+      }
+    }
+    walkAndAdd(srcDir, "");
+
+    const treeSha = execFileSync("git", ["write-tree"], {
+      encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"], env: indexEnv,
+    }).trim();
+
+    const commitArgs = ["commit-tree", treeSha, "-m", "chore(sticky-note): migrate to data branch"];
+    if (parentSha) commitArgs.push("-p", parentSha);
+    const commitSha = execFileSync("git", commitArgs, {
+      encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+
+    execFileSync("git", ["update-ref", branchRef, commitSha], {
+      timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+    });
+  } finally {
+    try { fs.unlinkSync(tmpIndex); } catch (_) {}
+  }
+}
+
 // ──────────────────────────────────────────────
 // Main
 // ──────────────────────────────────────────────
@@ -3287,6 +3748,15 @@ async function main() {
     case "mcp-server":
       cmdMcpServer();
       break;
+    case "run-hook":
+      cmdRunHook();
+      break;
+    case "migrate":
+      cmdMigrate().catch((err) => {
+        console.error(err);
+        process.exit(1);
+      });
+      break;
     case "--version":
     case "-v":
       print(`sticky-note v${VERSION}`);
@@ -3317,6 +3787,7 @@ async function main() {
     print("    bootstrap          Provision MCP servers with secrets from manifest");
     print("    env                Environment management (status, add-server, add-plugin)");
     print("    mcp-server         Launch the sticky-note MCP server (stdio JSON-RPC)");
+    print("    run-hook <name>    Run a hook from any subdirectory (finds .claude/hooks/ up the tree)");
       print("");
       print("  Options:");
       print("    --version  Show version");