sticky-note-cli 2.9.1 → 2.9.2

package/README.md

@@ -17,6 +17,10 @@
 
 <br/>
 
+<p align="center">
+  <img src="docs/images/demo.gif" alt="Sticky Note demo" width="600" />
+</p>
+
 <p align="center">
   <img src="https://raw.githubusercontent.com/BandaruDheeraj/sticky-note/main/docs/images/architecture.svg" alt="Architecture diagram" width="800" />
 </p>
@@ -154,7 +158,7 @@ threads only — non-stuck threads are held for lazy injection.
 - **Stuck threads** — All stuck threads are injected eagerly (V2.5).
 - **Team config** — Conventions, MCP servers, and skills from
   `sticky-note-config.json`.
-- **Active presence** — Developers seen in the last 15 minutes and the
+- **Active presence** — Developers seen in the last hour and the
   files they're working on.
 
 The hook also clears the injected-this-session tracking set, snapshots

package/bin/cli.js

@@ -83,26 +83,108 @@ 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);
         }
       }
-      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 +736,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 +815,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 +826,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
@@ -998,8 +1101,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 +1115,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)");
   }
@@ -1161,6 +1266,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 +1375,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 +1819,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 +1845,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 });
   }
 

package/bin/mcp-server.js

@@ -234,7 +234,7 @@ function toolGetPresence() {
   const active = entries
     .filter(([_user, data]) => {
       const lastSeen = new Date(data.last_seen || 0);
-      return now - lastSeen < 15 * 60 * 1000;
+      return now - lastSeen < 60 * 60 * 1000;
     })
     .map(([user, data]) => ({
       user,
@@ -298,7 +298,7 @@ function toolCheckOverlaps(params) {
   for (const [user, data] of Object.entries(presence)) {
     if (user === currentUser) continue;
     const lastSeen = new Date(data.last_seen || 0);
-    if (now - lastSeen > 15 * 60 * 1000) continue;
+    if (now - lastSeen > 60 * 60 * 1000) continue;
 
     const presenceFiles = (data.active_files || []).map((f) =>
       f.replace(/\\/g, "/")
@@ -576,7 +576,7 @@ const TOOLS = {
   },
   get_presence: {
     description:
-      "Get current developer presence — who is actively working and on which files. Only shows users seen in the last 15 minutes.",
+      "Get current developer presence — who is actively working and on which files. Only shows users seen in the last hour.",
     inputSchema: {
       type: "object",
       properties: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "2.9.1",
+  "version": "2.9.2",
   "description": "Human-to-human handoff for AI coding assistants. Git-backed shared memory for Claude Code and Copilot CLI.",
   "license": "MIT",
   "bin": {
@@ -32,5 +32,8 @@
   },
   "scripts": {
     "test": "node test/smoke.test.js"
+  },
+  "devDependencies": {
+    "sticky-note-cli": "^2.9.1"
   }
 }

package/templates/CLAUDE.md

@@ -159,6 +159,7 @@ Example format:
 - `.sticky-note/.sticky-head` — transient HEAD snapshot
 - `.sticky-note/.sticky-injected` — transient injection tracking (V2.5)
 - `.sticky-note/.sticky-active-resume` — transient active resume marker (V2.5)
+- `.sticky-note/.sticky-banner-shown` — transient startup banner dedup
 
 When a session ends or the user asks to commit, **always include
 `sticky-note.json` and the `audit/` and `presence/` directories**

package/templates/copilot-instructions.md

@@ -162,6 +162,7 @@ Example format:
 - `.sticky-note/.sticky-head` — transient HEAD snapshot
 - `.sticky-note/.sticky-injected` — transient injection tracking (V2.5)
 - `.sticky-note/.sticky-active-resume` — transient active resume marker (V2.5)
+- `.sticky-note/.sticky-banner-shown` — transient startup banner dedup
 
 When a session ends or the user asks to commit, **always include
 `sticky-note.json` and the `audit/` and `presence/` directories**

package/templates/gitignore-additions.txt

@@ -8,6 +8,7 @@
 .sticky-note/.sticky-injected
 .sticky-note/.sticky-active-resume
 .sticky-note/.sticky-checkpoint
+.sticky-note/.sticky-banner-shown
 
 # Sticky Note - debug log
 .sticky-note/hook-debug.log

package/templates/hooks/inject-context.js

@@ -39,10 +39,20 @@ function _safeExit() {
 let utils;
 try {
   utils = require("./sticky-utils.js");
-} catch (_) {
+} catch (err) {
+  try {
+    process.stderr.write(
+      `[STICKY-NOTE] UserPromptSubmit hook error: failed to load sticky-utils.js — ${err.message}\n` +
+      `[STICKY-NOTE]   hint: re-run \`npx sticky-note init\` to restore .claude/hooks/.\n`
+    );
+  } catch (_) { /* ignore */ }
   _safeExit();
 }
 
+// Issue #13: also self-heal from this hook (Copilot CLI doesn't fire
+// SessionStart, so inject-context may be the first hook to run successfully).
+try { utils.selfHealHookPaths && utils.selfHealHookPaths(); } catch (_) { /* non-fatal */ }
+
 let gitNotes;
 try {
   gitNotes = require("./sticky-git-notes.js");
@@ -626,6 +636,9 @@ if (require.main === module) {
   try {
     main();
   } catch (exc) {
+    try {
+      utils.reportHookError("UserPromptSubmit", exc);
+    } catch (_) { /* ignore */ }
     try {
       appendAuditLine({
         type: "inject_result",

package/templates/hooks/on-stop.js

@@ -22,7 +22,13 @@ function safeExit() {
 let utils;
 try {
   utils = require("./sticky-utils.js");
-} catch (_) {
+} catch (err) {
+  try {
+    process.stderr.write(
+      `[STICKY-NOTE] Stop hook error: failed to load sticky-utils.js — ${err.message}\n` +
+      `[STICKY-NOTE]   hint: re-run \`npx sticky-note init\` to restore .claude/hooks/.\n`
+    );
+  } catch (_) { /* ignore */ }
   safeExit();
 }
 
@@ -285,6 +291,8 @@ async function main() {
 }
 
 main().catch((err) => {
-  try { utils.logHookError("on-stop", err); } catch (_) {}
+  try { utils.reportHookError("Stop", err); } catch (_) {
+    try { utils.logHookError("on-stop", err); } catch (_) {}
+  }
   safeExit();
 });

package/templates/hooks/session-start.js

@@ -33,13 +33,78 @@ function _safeExit() {
   process.exit(0);
 }
 
+// Issue #12: warn (non-blocking) when the running CLI is below the project's
+// configured min_version. Returns "" when nothing to say. Also writes a
+// stderr banner so the user sees it directly even if the hook output is
+// swallowed by the host tool.
+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)];
+}
+function _cmpSemver(a, b) {
+  const pa = _parseSemver(a), pb = _parseSemver(b);
+  if (!pa || !pb) return 0;
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
+  }
+  return 0;
+}
+function _installedCliVersion() {
+  // Try the package.json shipped alongside this hook script's CLI.
+  try {
+    const candidates = [
+      path.join(__dirname, "..", "..", "package.json"),
+      path.join(__dirname, "..", "..", "..", "sticky-note-cli", "package.json"),
+    ];
+    for (const p of candidates) {
+      try {
+        const pkg = JSON.parse(require("fs").readFileSync(p, "utf-8"));
+        if (pkg && pkg.name === "sticky-note-cli" && pkg.version) return pkg.version;
+      } catch (_) { /* try next */ }
+    }
+  } catch (_) { /* ignore */ }
+  return null;
+}
+function formatVersionWarning(config) {
+  try {
+    const min = config && config.min_version;
+    if (!min) return "";
+    const installed = _installedCliVersion();
+    if (!installed) return "";
+    if (_cmpSemver(installed, min) >= 0) return "";
+    const msg =
+      `[STICKY-NOTE] ⚠️ Installed sticky-note-cli v${installed} is below ` +
+      `this project's min_version v${min}. Run \`npm i -D sticky-note-cli@latest\` ` +
+      `to update — features and schema may differ until you do.`;
+    try { process.stderr.write(msg + "\n"); } catch (_) { /* non-fatal */ }
+    return msg;
+  } catch (_) {
+    return "";
+  }
+}
+
 let utils;
 try {
   utils = require("./sticky-utils.js");
-} catch (_) {
+} catch (err) {
+  try {
+    process.stderr.write(
+      `[STICKY-NOTE] session-start hook error: failed to load sticky-utils.js — ${err.message}\n` +
+      `[STICKY-NOTE]   hint: re-run \`npx sticky-note init\` to restore .claude/hooks/.\n`
+    );
+  } catch (_) { /* ignore */ }
   _safeExit();
 }
 
+// Issue #13: self-heal stale absolute hook paths in .claude/settings.json
+// before doing anything else, so the next session loads cleanly even if some
+// other hook (e.g. on-stop, inject-context) was pointing at a path that no
+// longer exists. Failures here are non-fatal — we still want the rest of
+// session-start to run.
+try { utils.selfHealHookPaths && utils.selfHealHookPaths(); } catch (_) { /* non-fatal */ }
+
 const {
   getMemoryPath,
   getConfigPath,
@@ -121,6 +186,59 @@ function autoCloseCopilotCliThreads(memory, autoCloseHours) {
 
 // ── Formatting helpers ────────────────────────────────────
 
+function formatStuckBanner(threads) {
+  const stuck = (threads || []).filter((t) => t && t.status === "stuck");
+  if (stuck.length === 0) return "";
+
+  const R = "\x1b[0m";
+  const Y = "\x1b[33m";
+  const BY = "\x1b[1;33m";
+  const BR = "\x1b[1;31m";
+  const B = "\x1b[1m";
+  const C = "\x1b[36m";
+  const D = "\x1b[2m";
+  const bar = "━".repeat(52);
+
+  const lines = [
+    "",
+    `${Y}${bar}${R}`,
+    `${BY}  ⚠️  STUCK THREADS${R}`,
+    `${Y}${bar}${R}`,
+  ];
+
+  for (const t of stuck.slice(0, 5)) {
+    const user = t.user || t.author || "unknown";
+    const branch = t.branch ? ` ${D}·${R} ${C}${t.branch}${R}` : "";
+    const files = (t.files_touched || []).slice(0, 3).join(", ");
+    const narrative = t.narrative || t.last_note || "";
+    const snip =
+      narrative.length > 80 ? narrative.substring(0, 80) + "…" : narrative;
+    const threadId = (t.id || "").substring(0, 8);
+    const failed = t.failed_approaches || [];
+
+    lines.push(
+      `${Y}  ┃${R}  ${BR}[STUCK]${R} ${B}${user}${R}${branch}`
+    );
+    if (files) lines.push(`${Y}  ┃${R}    Files: ${files}`);
+    if (snip) lines.push(`${Y}  ┃${R}    ${D}"${snip}"${R}`);
+    if (failed.length > 0) {
+      lines.push(
+        `${Y}  ┃${R}    ${BR}⚠️ ${failed.length} failed approach(es)${R}`
+      );
+    }
+    lines.push(
+      `${Y}  ┃${R}    → Resume: ${C}npx sticky-note resume ${threadId}${R}`
+    );
+  }
+
+  if (stuck.length > 5) {
+    lines.push(`${Y}  ┃${R}  ... and ${stuck.length - 5} more`);
+  }
+
+  lines.push(`${Y}${bar}${R}`, "");
+  return lines.join("\n") + "\n";
+}
+
 function formatThreadsForInjection(threads, maxThreads, maxTokens) {
   maxThreads = maxThreads || 10;
   maxTokens = maxTokens || 500;
@@ -251,7 +369,7 @@ function formatPresence(presenceData, threads) {
     try {
       const ts = new Date(lastSeen).getTime();
       if (isNaN(ts)) continue;
-      if (now - ts < 15 * 60 * 1000) {
+      if (now - ts < 60 * 60 * 1000) {
         const files = (info.active_files || []).slice(0, 3).join(", ");
         const thread = userThreads[user];
         let line = `- **${user}**`;
@@ -911,6 +1029,7 @@ function main() {
   const overlapContext = formatOverlapWarnings(
     (memory.threads || []).filter(Boolean), getUser(), memory
   );
+  const versionWarning = formatVersionWarning(config);
 
   // V2.5: Mark eagerly-injected stuck threads so PreToolUse won't re-inject.
   // Skip for Copilot CLI — its sessionStart output is not surfaced to the AI,
@@ -930,6 +1049,41 @@ function main() {
 
   saveMemoryMerged(memoryPath, memory);
 
+  // ── Stuck threads startup banner ────────────────────────
+  // Write a visible banner to stderr so the user sees stuck threads
+  // immediately when the session starts, before any AI interaction.
+  const stuckThreads = (memory.threads || [])
+    .filter((t) => t && t.status === "stuck");
+  if (stuckThreads.length > 0) {
+    const fs = require("fs");
+    const bannerShownPath = path.join(
+      path.dirname(memoryPath),
+      ".sticky-banner-shown"
+    );
+    let showBanner = true;
+
+    // Copilot CLI fires sessionStart per-turn — only show once per session.
+    if (isCopilotCli) {
+      try {
+        const shown = fs.readFileSync(bannerShownPath, "utf-8").trim();
+        if (shown === sessionId) showBanner = false;
+      } catch (_) {
+        /* file doesn't exist yet */
+      }
+    }
+
+    if (showBanner) {
+      process.stderr.write(formatStuckBanner(stuckThreads));
+      if (isCopilotCli) {
+        try {
+          fs.writeFileSync(bannerShownPath, sessionId, "utf-8");
+        } catch (_) {
+          /* non-fatal */
+        }
+      }
+    }
+  }
+
   // ── Assemble output ───────────────────────────────────
   const parts = [];
 
@@ -1013,6 +1167,7 @@ function main() {
   }
 
   // Overlap warning comes first — most urgent signal
+  if (versionWarning) parts.push(versionWarning);
   if (overlapContext) parts.push(overlapContext);
 
   if (threadContext) parts.push(threadContext);
@@ -1028,6 +1183,8 @@ function main() {
 try {
   main();
 } catch (err) {
-  try { utils.logHookError("session-start", err); } catch (_) {}
+  try { utils.reportHookError("session-start", err); } catch (_) {
+    try { utils.logHookError("session-start", err); } catch (_) {}
+  }
   _safeExit();
 }

package/templates/hooks/sticky-utils.js

@@ -57,6 +57,94 @@ function logHookError(hookName, error) {
   }
 }
 
+// Issue #14: Surface hook failures to stderr so the host tool's generic
+// "<HookName> hook error" message has actionable detail next to it. Earlier
+// versions silently swallowed `require()` failures and top-level exceptions,
+// which made stale-path issues (#13) and other crashes impossible to diagnose
+// — particularly under UserPromptSubmit, which Claude Code reports without
+// a stack trace. This helper prefixes every line with `[STICKY-NOTE]` so the
+// user can spot it in mixed hook output.
+function reportHookError(hookName, error, hint) {
+  const msg = error instanceof Error ? (error.stack || error.message) : String(error);
+  const lines = [`[STICKY-NOTE] ${hookName} hook error: ${msg}`];
+  if (hint) lines.push(`[STICKY-NOTE]   hint: ${hint}`);
+  try { process.stderr.write(lines.join("\n") + "\n"); } catch (_) { /* ignore */ }
+  try { logHookError(hookName, error); } catch (_) { /* ignore */ }
+}
+
+// Issue #13: When a teammate copies `.claude/settings.json` from another
+// machine (or runs an older sticky-note-cli that wrote absolute paths), the
+// hook commands point at non-existent absolute paths and every hook fails
+// with MODULE_NOT_FOUND. Re-running `npx sticky-note init` fixes it, but
+// users typically don't know that — they just see "<Hook> hook error" each
+// session. This helper detects and rewrites those stale commands in-place
+// the first time any hook (e.g. session-start, inject-context) successfully
+// loads, so the next session starts clean.
+//
+// The rewritten command always uses the relative form `node ".claude/hooks/<basename>"`,
+// matching what `templates/settings.json` ships today. We extract `<basename>`
+// from the existing command so we never invent hook scripts that don't exist.
+//
+// Returns the list of (hookEvent, oldCommand, newCommand) tuples that were
+// rewritten, or [] if nothing was stale.
+function selfHealHookPaths(settingsPath) {
+  const result = [];
+  try {
+    if (!settingsPath) {
+      settingsPath = path.join(process.cwd(), ".claude", "settings.json");
+    }
+    if (!fs.existsSync(settingsPath)) return result;
+
+    const raw = fs.readFileSync(settingsPath, "utf-8");
+    let settings;
+    try { settings = JSON.parse(raw); } catch (_) { return result; }
+    if (!settings || !settings.hooks) return result;
+
+    // Match the same shapes findStaleHookPaths() in bin/cli.js looks for:
+    // any absolute path inside the command string, or a $(git rev-parse ...)
+    // shell expansion that won't work on Windows / under Claude Code.
+    const STALE = /["'][A-Za-z]:[\\/]|["']\/(?:Users|home|root|tmp)\/|\$\(git rev-parse/;
+    // Match the script basename in either quoted or bare form.
+    const BASENAME = /([A-Za-z0-9_.-]+\.(?:js|sh|cjs|mjs))(?:["'`\s]|$)/;
+
+    let changed = false;
+    for (const [event, entries] of Object.entries(settings.hooks)) {
+      if (!Array.isArray(entries)) continue;
+      for (const entry of entries) {
+        for (const h of (entry && entry.hooks) || []) {
+          const cmd = h && h.command;
+          if (typeof cmd !== "string" || !STALE.test(cmd)) continue;
+          const m = cmd.match(BASENAME);
+          if (!m) continue;
+          const basename = m[1];
+          const newCmd = `node ".claude/hooks/${basename}"`;
+          result.push({ event, oldCommand: cmd, newCommand: newCmd });
+          h.command = newCmd;
+          changed = true;
+        }
+      }
+    }
+
+    if (!changed) return result;
+
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    try {
+      const summary =
+        `[STICKY-NOTE] ⚠️  Detected ${result.length} stale absolute hook path(s) in ` +
+        `${path.relative(process.cwd(), settingsPath) || settingsPath} — rewrote to ` +
+        `relative paths so hooks work on this machine. Commit the change to share ` +
+        `the fix with your team.`;
+      process.stderr.write(summary + "\n");
+      for (const { event, oldCommand, newCommand } of result.slice(0, 5)) {
+        process.stderr.write(`[STICKY-NOTE]   ${event}: ${oldCommand} → ${newCommand}\n`);
+      }
+    } catch (_) { /* non-fatal */ }
+  } catch (err) {
+    try { logHookError("selfHealHookPaths", err); } catch (_) { /* ignore */ }
+  }
+  return result;
+}
+
 const _paths = {
   memory: "sticky-note.json",
   config: "sticky-note-config.json",
@@ -947,6 +1035,8 @@ module.exports = {
   RETRY_PATTERNS,
   FILE_PATH_PATTERN,
   logHookError,
+  reportHookError,
+  selfHealHookPaths,
   getMemoryPath,
   getConfigPath,
   getAuditPath,

package/templates/hooks.json

@@ -1,47 +1,47 @@
-{
-  "version": 1,
-  "hooks": {
-    "sessionStart": [
-      {
-        "type": "command",
-        "bash": "COPILOT_CLI=1 node \"$(git rev-parse --show-toplevel)/.claude/hooks/session-start.js\" --copilot-cli",
-        "powershell": "$env:COPILOT_CLI='1'; node \"$(git rev-parse --show-toplevel)/.claude/hooks/session-start.js\" --copilot-cli"
-      }
-    ],
-    "sessionEnd": [
-      {
-        "type": "command",
-        "bash": "COPILOT_CLI=1 node \"$(git rev-parse --show-toplevel)/.claude/hooks/session-end.js\" --copilot-cli",
-        "powershell": "$env:COPILOT_CLI='1'; node \"$(git rev-parse --show-toplevel)/.claude/hooks/session-end.js\" --copilot-cli"
-      }
-    ],
-    "userPromptSubmitted": [
-      {
-        "type": "command",
-        "bash": "COPILOT_CLI=1 node \"$(git rev-parse --show-toplevel)/.claude/hooks/inject-context.js\" --copilot-cli",
-        "powershell": "$env:COPILOT_CLI='1'; node \"$(git rev-parse --show-toplevel)/.claude/hooks/inject-context.js\" --copilot-cli"
-      }
-    ],
-    "preToolUse": [
-      {
-        "type": "command",
-        "bash": "COPILOT_CLI=1 node \"$(git rev-parse --show-toplevel)/.claude/hooks/pre-tool-use.js\" --copilot-cli",
-        "powershell": "$env:COPILOT_CLI='1'; node \"$(git rev-parse --show-toplevel)/.claude/hooks/pre-tool-use.js\" --copilot-cli"
-      }
-    ],
-    "postToolUse": [
-      {
-        "type": "command",
-        "bash": "COPILOT_CLI=1 node \"$(git rev-parse --show-toplevel)/.claude/hooks/track-work.js\" --copilot-cli",
-        "powershell": "$env:COPILOT_CLI='1'; node \"$(git rev-parse --show-toplevel)/.claude/hooks/track-work.js\" --copilot-cli"
-      }
-    ],
-    "errorOccurred": [
-      {
-        "type": "command",
-        "bash": "COPILOT_CLI=1 node \"$(git rev-parse --show-toplevel)/.claude/hooks/on-error.js\" --copilot-cli",
-        "powershell": "$env:COPILOT_CLI='1'; node \"$(git rev-parse --show-toplevel)/.claude/hooks/on-error.js\" --copilot-cli"
-      }
-    ]
-  }
-}
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "type": "command",
+        "bash": "COPILOT_CLI=1 node \".claude/hooks/session-start.js\" --copilot-cli",
+        "powershell": "$env:COPILOT_CLI='1'; node \".claude/hooks/session-start.js\" --copilot-cli"
+      }
+    ],
+    "sessionEnd": [
+      {
+        "type": "command",
+        "bash": "COPILOT_CLI=1 node \".claude/hooks/session-end.js\" --copilot-cli",
+        "powershell": "$env:COPILOT_CLI='1'; node \".claude/hooks/session-end.js\" --copilot-cli"
+      }
+    ],
+    "userPromptSubmitted": [
+      {
+        "type": "command",
+        "bash": "COPILOT_CLI=1 node \".claude/hooks/inject-context.js\" --copilot-cli",
+        "powershell": "$env:COPILOT_CLI='1'; node \".claude/hooks/inject-context.js\" --copilot-cli"
+      }
+    ],
+    "preToolUse": [
+      {
+        "type": "command",
+        "bash": "COPILOT_CLI=1 node \".claude/hooks/pre-tool-use.js\" --copilot-cli",
+        "powershell": "$env:COPILOT_CLI='1'; node \".claude/hooks/pre-tool-use.js\" --copilot-cli"
+      }
+    ],
+    "postToolUse": [
+      {
+        "type": "command",
+        "bash": "COPILOT_CLI=1 node \".claude/hooks/track-work.js\" --copilot-cli",
+        "powershell": "$env:COPILOT_CLI='1'; node \".claude/hooks/track-work.js\" --copilot-cli"
+      }
+    ],
+    "errorOccurred": [
+      {
+        "type": "command",
+        "bash": "COPILOT_CLI=1 node \".claude/hooks/on-error.js\" --copilot-cli",
+        "powershell": "$env:COPILOT_CLI='1'; node \".claude/hooks/on-error.js\" --copilot-cli"
+      }
+    ]
+  }
+}

package/templates/settings.json

@@ -1,81 +1,81 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$(git rev-parse --show-toplevel)/.claude/hooks/session-start.js\""
-          }
-        ]
-      }
-    ],
-    "SessionEnd": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$(git rev-parse --show-toplevel)/.claude/hooks/session-end.js\""
-          }
-        ]
-      }
-    ],
-    "UserPromptSubmit": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$(git rev-parse --show-toplevel)/.claude/hooks/inject-context.js\""
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$(git rev-parse --show-toplevel)/.claude/hooks/pre-tool-use.js\""
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$(git rev-parse --show-toplevel)/.claude/hooks/track-work.js\""
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$(git rev-parse --show-toplevel)/.claude/hooks/on-stop.js\""
-          }
-        ]
-      }
-    ],
-    "PostToolUseFailure": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$(git rev-parse --show-toplevel)/.claude/hooks/on-error.js\""
-          }
-        ]
-      }
-    ]
-  }
-}
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \".claude/hooks/session-start.js\""
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \".claude/hooks/session-end.js\""
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \".claude/hooks/inject-context.js\""
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \".claude/hooks/pre-tool-use.js\""
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \".claude/hooks/track-work.js\""
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \".claude/hooks/on-stop.js\""
+          }
+        ]
+      }
+    ],
+    "PostToolUseFailure": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \".claude/hooks/on-error.js\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/templates/sticky-note-config.json

@@ -7,5 +7,6 @@
   "mcp_servers": [],
   "skills": [],
   "conventions": [],
-  "hook_version": "2.5.0"
+  "hook_version": "2.5.0",
+  "min_version": "2.9.1"
 }