sticky-note-cli 2.5.3 → 2.6.0

package/bin/cli.js

@@ -1372,6 +1372,282 @@ function _relativeTime(tsStr) {
   }
 }
 
+// ──────────────────────────────────────────────
+// OVERLAP command — detect file overlaps with open/stuck threads
+// ──────────────────────────────────────────────
+
+function cmdOverlap() {
+  const args = process.argv.slice(3);
+  const stickyDir = path.join(process.cwd(), ".sticky-note");
+  const memoryPath = path.join(stickyDir, "sticky-note.json");
+
+  if (!fs.existsSync(memoryPath)) {
+    print("  [ERR] No sticky-note.json found. Run `npx sticky-note init` first.");
+    process.exit(1);
+  }
+
+  printBanner();
+
+  // Get files to check: either --files flag or git diff
+  let filesToCheck = new Set();
+  const filesIdx = args.indexOf("--files");
+  if (filesIdx !== -1 && args.length > filesIdx + 1) {
+    for (const f of args.slice(filesIdx + 1)) {
+      if (f.startsWith("--")) break;
+      filesToCheck.add(_normSep(f));
+    }
+  } else {
+    // Use git diff (uncommitted + recent commits)
+    try {
+      const uncommitted = execSync("git diff --name-only", {
+        encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+      for (const f of uncommitted.split(/\r?\n/)) {
+        if (f.trim()) filesToCheck.add(_normSep(f.trim()));
+      }
+    } catch (_) {}
+    try {
+      const staged = execSync("git diff --name-only --cached", {
+        encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+      for (const f of staged.split(/\r?\n/)) {
+        if (f.trim()) filesToCheck.add(_normSep(f.trim()));
+      }
+    } catch (_) {}
+    const diffTargets = ["HEAD~5", "HEAD~1"];
+    for (const target of diffTargets) {
+      try {
+        const result = execSync(`git diff --name-only ${target}`, {
+          encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        for (const f of result.split(/\r?\n/)) {
+          if (f.trim()) filesToCheck.add(_normSep(f.trim()));
+        }
+        break;
+      } catch (_) {}
+    }
+  }
+
+  if (filesToCheck.size === 0) {
+    print("  No modified files detected. Use --files <file1> <file2> to check specific files.\n");
+    return;
+  }
+
+  const currentUserNames = _getCurrentUserNames();
+  const isMe = (user) => currentUserNames.has(user || "");
+  const memory = readJsonSafe(memoryPath, { threads: [] });
+  const threads = (memory.threads || []).filter(
+    (t) => t.status === "open" || t.status === "stuck"
+  );
+
+  // Find overlaps
+  const overlaps = [];
+  for (const thread of threads) {
+    const threadFiles = (thread.files_touched || []).map(_normSep);
+    const threadFileSet = new Set(threadFiles);
+    const matching = [];
+    for (const f of filesToCheck) {
+      if (threadFileSet.has(f)) matching.push(f);
+    }
+    if (matching.length > 0) {
+      overlaps.push({ thread, matching });
+    }
+  }
+
+  print(`  Checking ${filesToCheck.size} file(s) against ${threads.length} open/stuck thread(s):\n`);
+
+  if (overlaps.length === 0) {
+    print("  ✅ No overlaps found. You're clear to work.\n");
+    return;
+  }
+
+  // Sort: other users first, then stuck before open, then by overlap count
+  overlaps.sort((a, b) => {
+    const aOther = !isMe(a.thread.user) ? 1 : 0;
+    const bOther = !isMe(b.thread.user) ? 1 : 0;
+    if (aOther !== bOther) return bOther - aOther;
+    if (a.thread.status !== b.thread.status) {
+      return a.thread.status === "stuck" ? -1 : 1;
+    }
+    return b.matching.length - a.matching.length;
+  });
+
+  for (const { thread, matching } of overlaps) {
+    const user = thread.user || thread.author || "unknown";
+    const icon = statusIcon(thread.status);
+    const isSelf = isMe(user);
+    const prefix = isSelf ? "  " : "  ⚠️ ";
+    const suffix = isSelf ? " (you)" : "";
+    const narrative = thread.narrative || thread.last_note || "";
+    const narrativeSnip = narrative.length > 80
+      ? narrative.substring(0, 80) + "…"
+      : narrative;
+    const branch = thread.branch ? ` on ${thread.branch}` : "";
+    const ago = thread.last_activity_at ? _relativeTime(thread.last_activity_at) : "";
+    const agoLabel = ago ? ` (${ago})` : "";
+
+    print(`${prefix}${icon} ${user}${suffix}${branch}${agoLabel}`);
+    if (narrativeSnip) {
+      print(`         "${narrativeSnip}"`);
+    }
+    print(`         overlapping: ${matching.join(", ")}`);
+    if (thread.failed_approaches && thread.failed_approaches.length > 0) {
+      print(`         ⚠️  ${thread.failed_approaches.length} failed approach(es)`);
+    }
+    const threadId = (thread.id || "").substring(0, 8);
+    if (!isSelf && threadId) {
+      print(`         → npx sticky-note resume ${threadId}`);
+    }
+    print("");
+  }
+
+  const otherUserOverlaps = overlaps.filter(
+    (o) => !isMe(o.thread.user)
+  );
+  if (otherUserOverlaps.length > 0) {
+    print(`  ⚠️  ${otherUserOverlaps.length} thread(s) from other users overlap with your files.`);
+    print("  Consider coordinating before diving in.\n");
+  }
+}
+
+function _normSep(p) {
+  return typeof p === "string" ? p.replace(/\\/g, "/") : p;
+}
+
+function _getGitUserName() {
+  try {
+    return execSync("git config user.name", {
+      encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch (_) {
+    return process.env.USER || process.env.USERNAME || "unknown";
+  }
+}
+
+function _getCurrentUserNames() {
+  const names = new Set();
+  const envUser = process.env.USER || process.env.USERNAME || "";
+  if (envUser) names.add(envUser);
+  try {
+    const gitName = execSync("git config user.name", {
+      encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (gitName) names.add(gitName);
+  } catch (_) {}
+  try {
+    const gitEmail = execSync("git config user.email", {
+      encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (gitEmail) names.add(gitEmail);
+  } catch (_) {}
+  return names;
+}
+
+// ──────────────────────────────────────────────
+// CLAIM command — declare intent to work on files
+// ──────────────────────────────────────────────
+
+function cmdClaim() {
+  const args = process.argv.slice(3);
+  const stickyDir = path.join(process.cwd(), ".sticky-note");
+  const memoryPath = path.join(stickyDir, "sticky-note.json");
+
+  if (!fs.existsSync(memoryPath)) {
+    print("  [ERR] No sticky-note.json found. Run `npx sticky-note init` first.");
+    process.exit(1);
+  }
+
+  // Parse: npx sticky-note claim <file1> [file2...] "description"
+  // or: npx sticky-note claim --clear
+  if (args.includes("--clear")) {
+    const memory = readJsonSafe(memoryPath, { threads: [], claims: [] });
+    const userNames = _getCurrentUserNames();
+    const before = (memory.claims || []).length;
+    memory.claims = (memory.claims || []).filter((c) => !userNames.has(c.user));
+    const removed = before - memory.claims.length;
+    fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2));
+    print(`  [OK] Cleared ${removed} claim(s).`);
+    return;
+  }
+
+  if (args.includes("--list")) {
+    const memory = readJsonSafe(memoryPath, { threads: [], claims: [] });
+    const claims = memory.claims || [];
+    if (claims.length === 0) {
+      print("  No active claims.");
+      return;
+    }
+    printBanner();
+    print("  Active Claims:\n");
+    for (const c of claims) {
+      const ago = c.claimed_at ? _relativeTime(c.claimed_at) : "";
+      const agoLabel = ago ? ` (${ago})` : "";
+      print(`  📌 ${c.user}${agoLabel}: ${c.files.join(", ")}`);
+      if (c.description) print(`      "${c.description}"`);
+    }
+    print("");
+    return;
+  }
+
+  if (args.length === 0) {
+    print("  Usage: npx sticky-note claim <file1> [file2...] \"description\"");
+    print("         npx sticky-note claim --list");
+    print("         npx sticky-note claim --clear");
+    return;
+  }
+
+  // Parse files and description (last quoted arg or last arg is description)
+  const files = [];
+  let description = "";
+  for (const a of args) {
+    if (a.startsWith("--")) continue;
+    // If it looks like a file path (has a dot or slash), treat as file
+    if (a.includes("/") || a.includes("\\") || a.includes(".")) {
+      files.push(_normSep(a));
+    } else {
+      // Treat as part of description
+      description += (description ? " " : "") + a;
+    }
+  }
+
+  if (files.length === 0) {
+    print("  [ERR] No files specified. Usage: npx sticky-note claim <file> \"description\"");
+    return;
+  }
+
+  const currentUser = process.env.USER || process.env.USERNAME || _getGitUserName();
+  const userNames = _getCurrentUserNames();
+  const memory = readJsonSafe(memoryPath, { threads: [], claims: [] });
+  if (!memory.claims) memory.claims = [];
+
+  // Remove existing claims from this user for these files
+  memory.claims = memory.claims.filter(
+    (c) => !userNames.has(c.user) || !c.files.some((f) => files.includes(f))
+  );
+
+  memory.claims.push({
+    user: currentUser,
+    files,
+    description,
+    claimed_at: new Date().toISOString(),
+    branch: _getCurrentBranch(),
+  });
+
+  fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2));
+  print(`  ✅ Claimed ${files.join(", ")}${description ? ` — "${description}"` : ""}`);
+  print(`  Others will see this at session start. Commit + push to share.`);
+}
+
+function _getCurrentBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+  } catch (_) {
+    return "";
+  }
+}
+
 // ──────────────────────────────────────────────
 // SWITCH command — safe branch switching
 // ──────────────────────────────────────────────
@@ -1954,6 +2230,12 @@ async function main() {
     case "checkpoint":
       cmdCheckpoint();
       break;
+    case "overlap":
+      cmdOverlap();
+      break;
+    case "claim":
+      cmdClaim();
+      break;
     case "--version":
     case "-v":
       print(`sticky-note v${VERSION}`);
@@ -1977,6 +2259,8 @@ async function main() {
       print("    reset              Wipe all threads and start fresh (--force, --keep-audit)");
       print("    get-line-attribution  File→thread attribution with line ranges (--file, --lines)");
       print("    checkpoint         Set work-topic checkpoint for attribution (--topic, --show, --clear)");
+      print("    overlap            Detect file overlaps with open/stuck threads");
+      print("    claim              Claim ownership of files you're working on (--list, --clear)");
       print("");
       print("  Options:");
       print("    --version  Show version");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "2.5.3",
+  "version": "2.6.0",
   "description": "Human-to-human handoff for AI coding assistants. Git-backed shared memory for Claude Code and Copilot CLI.",
   "license": "MIT",
   "bin": {

package/templates/hooks/on-stop.js

@@ -8,6 +8,7 @@
  */
 
 const crypto = require("crypto");
+const { execFileSync } = require("child_process");
 
 function safeExit() {
   try {
@@ -35,8 +36,117 @@ const {
   getBranch,
   getSessionId,
   detectTool,
+  extractSessionFromAudit,
+  readHeadSha,
+  normalizeSep,
+  useCloud,
+  cloudReadThreads,
+  cloudWriteThread,
+  cloudAppendAudit,
 } = utils;
 
+// Files that belong to sticky-note internals — exclude from files_touched.
+const STICKY_FILES_PREFIX = [
+  ".sticky-note/sticky-note.json",
+  ".sticky-note/sticky-note-audit.jsonl",
+  ".sticky-note/audit/",
+  ".sticky-note/presence/",
+  ".sticky-note/.sticky-session",
+  ".sticky-note/.sticky-head",
+  ".sticky-note/.sticky-resume",
+  ".sticky-note/.sticky-debug.jsonl",
+  ".sticky-note/sticky-note-config.json",
+  ".sticky-note/.sticky-presence.json",
+  ".sticky-note/.sticky-injected",
+  ".sticky-note/.sticky-active-resume",
+];
+
+/**
+ * Collect files changed since session start using git diff.
+ * Mirrors getGitFilesTouched() from session-end.js.
+ */
+function getGitFilesTouched() {
+  const files = new Set();
+  const savedSha = readHeadSha();
+
+  try {
+    if (savedSha && /^[0-9a-f]+$/i.test(savedSha)) {
+      const result = execFileSync("git", ["diff", "--name-only", savedSha, "HEAD"], {
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      for (const f of result.trim().split(/\r?\n/)) {
+        const trimmed = f.trim();
+        if (trimmed) files.add(trimmed);
+      }
+    }
+
+    const unstaged = execFileSync("git", ["diff", "--name-only"], {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    for (const f of unstaged.trim().split(/\r?\n/)) {
+      const trimmed = f.trim();
+      if (trimmed) files.add(trimmed);
+    }
+
+    const staged = execFileSync("git", ["diff", "--cached", "--name-only"], {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    for (const f of staged.trim().split(/\r?\n/)) {
+      const trimmed = f.trim();
+      if (trimmed) files.add(trimmed);
+    }
+  } catch (_) {
+    // ignore — git may not be available
+  }
+
+  return Array.from(files).filter((f) => {
+    const normalized = normalizeSep(f);
+    return !STICKY_FILES_PREFIX.some((p) => normalized === p || normalized.startsWith(p));
+  });
+}
+
+/**
+ * Build a narrative string from audit trail prompts.
+ * Mirrors the audit-fallback path from session-end.js extractNarrative().
+ */
+function buildNarrativeFromAudit(auditData) {
+  const prompts = auditData.prompts || [];
+  if (!prompts.length) return "";
+  if (prompts.length === 1) return prompts[0].substring(0, 300).trim();
+  let summary = prompts[0].substring(0, 150).trim();
+  if (prompts.length > 2) {
+    summary += ` ... (${prompts.length} prompts total) ... ${prompts[prompts.length - 1].substring(0, 100).trim()}`;
+  } else {
+    summary += ` -> ${prompts[prompts.length - 1].substring(0, 100).trim()}`;
+  }
+  return summary.substring(0, 300);
+}
+
+/**
+ * Classify work type from audit tool counts (lightweight version of
+ * analyzeSessionActivities from session-end.js).
+ */
+function classifyWorkType(auditData) {
+  const tools = auditData.tools || {};
+  const files = auditData.files || [];
+  const editLike = new Set(["edit", "create", "write", "Edit", "Write", "Create", "MultiEdit", "multi_edit"]);
+  let editCount = 0;
+  for (const [t, c] of Object.entries(tools)) {
+    if (editLike.has(t)) editCount += c;
+  }
+  const readCount = tools["Read"] || tools["read"] || 0;
+  if (editCount > 0) return "feature-development";
+  if (readCount > 0 && editCount === 0) return "code-review";
+  if (files.length > 0) return "general";
+  return "general";
+}
+
 function buildHandoffSummary(thread, reason) {
   const parts = [];
   const files = thread.files_touched || [];
@@ -67,7 +177,7 @@ function buildHandoffSummary(thread, reason) {
   return parts.length ? parts.join(" | ") : "Session stopped -- no summary available";
 }
 
-function main() {
+async function main() {
   let hookInput = {};
   try {
     if (!process.stdin.isTTY) {
@@ -85,15 +195,53 @@ function main() {
   const now = new Date().toISOString();
   const reason = hookInput.reason || "";
 
+  const cloud = useCloud();
   const memoryPath = getMemoryPath();
   const memory = loadJson(memoryPath, { version: "2", project: "", threads: [] });
 
+  if (cloud) {
+    const cloudThreads = await cloudReadThreads();
+    if (cloudThreads) memory.threads = cloudThreads;
+  }
+
+  // Extract session data from audit trail and git (the key fix —
+  // previously this hook created bare threads with no context).
+  const auditData = extractSessionFromAudit(sessionId);
+  const auditFiles = auditData.files || [];
+  const gitFiles = getGitFilesTouched();
+  const allFiles = [...new Set([...auditFiles, ...gitFiles])];
+  const narrative = buildNarrativeFromAudit(auditData);
+  const workType = classifyWorkType(auditData);
+
   const threads = memory.threads || [];
   let found = false;
 
   for (const thread of threads) {
     if (thread.session_id === sessionId && (thread.status === "open" || thread.status === "stuck")) {
       thread.last_activity_at = now;
+      // Enrich with extracted data
+      if (allFiles.length) {
+        thread.files_touched = [...new Set([...(thread.files_touched || []), ...allFiles])];
+      }
+      if (narrative && !thread.narrative) {
+        thread.narrative = narrative;
+      }
+      if (workType !== "general" || !thread.work_type) {
+        thread.work_type = workType;
+      }
+      // Merge audit tool counts
+      const auditTools = auditData.tools || {};
+      const prevCalls = thread.tool_calls || {};
+      for (const [tn, cnt] of Object.entries(auditTools)) {
+        prevCalls[tn] = (prevCalls[tn] || 0) + cnt;
+      }
+      thread.tool_calls = prevCalls;
+      // Store prompts if not already present
+      const storedPrompts = (auditData.prompts || []).slice(0, 20).map((p) => p.substring(0, 300));
+      if (storedPrompts.length && !(thread.prompts || []).length) {
+        thread.prompts = storedPrompts;
+      }
+
       thread.handoff_summary = buildHandoffSummary(thread, reason);
       if (reason) {
         thread.last_note = reason.substring(0, 200);
@@ -104,6 +252,7 @@ function main() {
   }
 
   if (!found && sessionId !== "unknown") {
+    const storedPrompts = (auditData.prompts || []).slice(0, 20).map((p) => p.substring(0, 300));
     const thread = {
       id: crypto.randomUUID(),
       user,
@@ -113,29 +262,46 @@ function main() {
       created_at: now,
       closed_at: now,
       last_activity_at: now,
-      files_touched: [],
-      last_note: reason ? reason.substring(0, 200) : "Session stopped",
-      narrative: "",
+      files_touched: allFiles,
+      last_note: reason ? reason.substring(0, 200) : (narrative || "Session stopped"),
+      narrative,
       failed_approaches: [],
-      handoff_summary: buildHandoffSummary({}, reason),
+      handoff_summary: "",
       related_session_ids: [],
       tool: detectTool(hookInput),
       session_id: sessionId,
+      work_type: workType,
+      tool_calls: auditData.tools || {},
+      prompts: storedPrompts,
+      contributors: [user],
+      resume_history: [],
     };
+    thread.handoff_summary = buildHandoffSummary(thread, reason);
     threads.push(thread);
   }
 
-  appendAuditLine({
+  const auditEntry = {
     type: "stop",
     user,
     ts: now,
     session_id: sessionId,
     reason: reason ? reason.substring(0, 200) : "stop_checkpoint",
-  });
+  };
+  appendAuditLine(auditEntry);
+  if (cloud) {
+    cloudAppendAudit(auditEntry).catch(() => {});
+  }
 
   saveMemoryMerged(memoryPath, memory);
+  if (cloud) {
+    const threadToSync = threads.find(t => t.session_id === sessionId);
+    if (threadToSync) {
+      cloudWriteThread(threadToSync).catch(() => {});
+    }
+  }
   const reasonStr = reason ? reason.substring(0, 60) : "checkpoint";
-  const statusMsg = `[STICKY-NOTE] Session stopped - handoff saved (${reasonStr})`;
+  const fileCount = allFiles.length;
+  const statusMsg = `[STICKY-NOTE] Session stopped - handoff saved (${reasonStr}, ${fileCount} file${fileCount !== 1 ? "s" : ""})`;
   try {
     process.stdout.write(JSON.stringify({ output: statusMsg }) + "\n");
   } catch (_) {
@@ -144,8 +310,4 @@ function main() {
   process.exit(0);
 }
 
-try {
-  main();
-} catch (_) {
-  safeExit();
-}
+main().catch(() => safeExit());

package/templates/hooks/session-start.js

@@ -47,6 +47,7 @@ const {
   markThreadInjected,
   clearActiveResumeThreadId,
   getActiveResumeThreadId,
+  normalizeSep,
 } = utils;
 
 // ── Stale-thread ageing ───────────────────────────────────
@@ -75,6 +76,34 @@ function ageStaleThreads(memory, staleDays) {
   return changed;
 }
 
+// Auto-close Copilot CLI threads that have been inactive beyond a threshold.
+// Copilot CLI has no session-end signal, so threads stay open indefinitely.
+// This closes them after configurable inactivity (default 24h).
+function autoCloseCopilotCliThreads(memory, autoCloseHours) {
+  const now = Date.now();
+  let changed = false;
+  for (const thread of memory.threads || []) {
+    if (thread.status !== "open") continue;
+    if (thread.tool !== "copilot-cli") continue;
+    const tsField =
+      thread.last_activity_at || thread.updated_at || thread.created_at || "";
+    if (!tsField) continue;
+    try {
+      const ts = new Date(tsField).getTime();
+      if (isNaN(ts)) continue;
+      const diffHours = (now - ts) / (1000 * 60 * 60);
+      if (diffHours >= autoCloseHours) {
+        thread.status = "closed";
+        thread.closed_at = new Date().toISOString();
+        changed = true;
+      }
+    } catch (_) {
+      continue;
+    }
+  }
+  return changed;
+}
+
 // ── Formatting helpers ────────────────────────────────────
 
 function formatThreadsForInjection(threads, maxThreads, maxTokens) {
@@ -181,9 +210,26 @@ function loadAllPresence() {
   return data;
 }
 
-function formatPresence(presenceData) {
+function formatPresence(presenceData, threads) {
   const now = Date.now();
   const active = [];
+
+  // Build a map of user → most recent open/stuck thread
+  const userThreads = {};
+  for (const t of (threads || [])) {
+    if (t.status !== "open" && t.status !== "stuck") continue;
+    const user = t.user || t.author || "";
+    if (!user) continue;
+    const existing = userThreads[user];
+    if (!existing) {
+      userThreads[user] = t;
+    } else {
+      const existingTs = existing.last_activity_at || existing.created_at || "";
+      const thisTs = t.last_activity_at || t.created_at || "";
+      if (thisTs > existingTs) userThreads[user] = t;
+    }
+  }
+
   for (const [user, info] of Object.entries(presenceData || {})) {
     const lastSeen = info.last_seen || "";
     if (!lastSeen) continue;
@@ -192,7 +238,20 @@ function formatPresence(presenceData) {
       if (isNaN(ts)) continue;
       if (now - ts < 15 * 60 * 1000) {
         const files = (info.active_files || []).slice(0, 3).join(", ");
-        active.push(`- **${user}** active on: ${files}`);
+        const thread = userThreads[user];
+        let line = `- **${user}**`;
+        if (thread) {
+          const narrative = thread.narrative || thread.last_note || "";
+          const snip = narrative.length > 60
+            ? narrative.substring(0, 60) + "…"
+            : narrative;
+          const status = thread.status === "stuck" ? " [STUCK]" : "";
+          line += `${status}: ${snip || files}`;
+          if (snip && files) line += ` (${files})`;
+        } else {
+          line += ` active on: ${files}`;
+        }
+        active.push(line);
       }
     } catch (_) {
       continue;
@@ -202,6 +261,128 @@ function formatPresence(presenceData) {
   return "\n## Active Now\n" + active.join("\n");
 }
 
+// ── Overlap detection ─────────────────────────────────────
+
+function getRecentlyModifiedFiles() {
+  const files = new Set();
+  const diffTargets = ["HEAD~5", "HEAD~1"];
+  for (const target of diffTargets) {
+    try {
+      const result = require("child_process").execSync(
+        `git diff --name-only ${target}`,
+        { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }
+      );
+      for (const f of result.trim().split(/\r?\n/)) {
+        const trimmed = f.trim();
+        if (trimmed) files.add(normalizeSep(trimmed));
+      }
+      break;
+    } catch (_) {}
+  }
+  try {
+    const result = require("child_process").execSync("git diff --name-only", {
+      encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+    });
+    for (const f of result.trim().split(/\r?\n/)) {
+      const trimmed = f.trim();
+      if (trimmed) files.add(normalizeSep(trimmed));
+    }
+  } catch (_) {}
+  try {
+    const result = require("child_process").execSync(
+      "git diff --name-only --cached",
+      { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }
+    );
+    for (const f of result.trim().split(/\r?\n/)) {
+      const trimmed = f.trim();
+      if (trimmed) files.add(normalizeSep(trimmed));
+    }
+  } catch (_) {}
+  return files;
+}
+
+function detectOverlaps(threads, currentUser) {
+  const modifiedFiles = getRecentlyModifiedFiles();
+  if (modifiedFiles.size === 0) return { warnings: [], claims: [] };
+
+  const activeThreads = (threads || []).filter(
+    (t) => t.status === "open" || t.status === "stuck"
+  );
+
+  const warnings = [];
+  for (const thread of activeThreads) {
+    const threadUser = thread.user || thread.author || "";
+    if (threadUser === currentUser) continue; // skip own threads
+    const threadFiles = (thread.files_touched || []).map(normalizeSep);
+    const overlap = threadFiles.filter((f) => modifiedFiles.has(f));
+    if (overlap.length === 0) continue;
+    warnings.push({ thread, overlap });
+  }
+
+  // Sort: stuck first, then by overlap count
+  warnings.sort((a, b) => {
+    if (a.thread.status !== b.thread.status) {
+      return a.thread.status === "stuck" ? -1 : 1;
+    }
+    return b.overlap.length - a.overlap.length;
+  });
+
+  return { warnings, modifiedFiles };
+}
+
+function formatOverlapWarnings(threads, currentUser, memory) {
+  const { warnings, modifiedFiles } = detectOverlaps(threads, currentUser);
+  const claims = (memory.claims || []).filter((c) => {
+    if (c.user === currentUser) return false;
+    if (!modifiedFiles || modifiedFiles.size === 0) return false;
+    return (c.files || []).some((f) => modifiedFiles.has(normalizeSep(f)));
+  });
+
+  if (warnings.length === 0 && claims.length === 0) return "";
+
+  const lines = [
+    "## [STICKY-NOTE] ⚠️ OVERLAP DETECTED\n",
+    "Someone else is working on files you're touching:\n",
+  ];
+
+  for (const { thread, overlap } of warnings) {
+    const user = thread.user || thread.author || "unknown";
+    const status = thread.status === "stuck" ? "[STUCK]" : "[OPEN]";
+    const narrative = thread.narrative || thread.last_note || "";
+    const narrativeSnip = narrative.length > 100
+      ? narrative.substring(0, 100) + "…"
+      : narrative;
+    const branch = thread.branch ? ` on \`${thread.branch}\`` : "";
+    const threadId = (thread.id || "").substring(0, 8);
+
+    lines.push(`- ${status} **${user}**${branch}: ${overlap.join(", ")}`);
+    if (narrativeSnip) lines.push(`  _${narrativeSnip}_`);
+    const failed = thread.failed_approaches || [];
+    if (failed.length > 0) {
+      lines.push(`  ⚠️ ${failed.length} failed approach(es):`);
+      for (const fa of failed.slice(0, 2)) {
+        lines.push(`    - ${(fa.description || "").substring(0, 80)}`);
+      }
+    }
+    if (threadId) {
+      lines.push(`  → Resume: \`npx sticky-note resume ${threadId}\``);
+    }
+  }
+
+  for (const claim of claims) {
+    const ago = claim.claimed_at || "";
+    lines.push(
+      `- 📌 **${claim.user}** claimed: ${(claim.files || []).join(", ")}` +
+        (claim.description ? ` — "${claim.description}"` : "")
+    );
+  }
+
+  lines.push(
+    "\n**Consider coordinating with these teammates before starting work.**"
+  );
+  return lines.join("\n");
+}
+
 // ── Main ──────────────────────────────────────────────────
 
 function main() {
@@ -243,8 +424,13 @@ function main() {
   });
   const config = loadJson(getConfigPath(), { stale_days: 14 });
   const staleDays = config.stale_days != null ? config.stale_days : 14;
+  const autoCloseHours =
+    config.copilot_cli_auto_close_hours != null
+      ? config.copilot_cli_auto_close_hours
+      : 24;
 
   ageStaleThreads(memory, staleDays);
+  autoCloseCopilotCliThreads(memory, autoCloseHours);
 
   // ── Resume handling ───────────────────────────────────
   const resumeThreadId = getResumeThreadId();
@@ -280,7 +466,10 @@ function main() {
   const threadContext = threadResult.text;
   const configContext = formatConfigForInjection(config);
   const presenceData = loadAllPresence();
-  const presenceContext = formatPresence(presenceData);
+  const presenceContext = formatPresence(presenceData, memory.threads || []);
+  const overlapContext = formatOverlapWarnings(
+    memory.threads || [], getUser(), memory
+  );
 
   // V2.5: Mark eagerly-injected stuck threads so PreToolUse won't re-inject
   for (const threadId of threadResult.threadIds) {
@@ -378,6 +567,9 @@ function main() {
     parts.push(resumeLines.join("\n"));
   }
 
+  // Overlap warning comes first — most urgent signal
+  if (overlapContext) parts.push(overlapContext);
+
   if (threadContext) parts.push(threadContext);
   if (configContext) parts.push(configContext);
   if (presenceContext) parts.push(presenceContext);

package/templates/hooks/sticky-codex.sh

@@ -1,71 +1,71 @@
-#!/usr/bin/env bash
-# sticky-codex.sh — Codex wrapper for Sticky Note V2
-#
-# Captures Codex stdout/stderr to a temp session log.
-# On exit: calls session-end.js with the transcript for
-# narrative + failed_approaches extraction.
-#
-# Usage:
-#   sticky-codex [codex args...]
-#
-# Setup:
-#   npx sticky-note init --codex
-#   alias sticky-codex="/path/to/.claude/hooks/sticky-codex.sh"
-#
-# Limitation: Context is printed to terminal after Codex exits,
-# not injected into the Codex window. Per-prompt surfacing not available.
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-STICKY_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)/.sticky-note"
-SESSION_ID="codex-$(date +%s)-$$"
-TRANSCRIPT_FILE=$(mktemp "${TMPDIR:-/tmp}/sticky-codex-XXXXXX.log")
-USER="${USER:-${USERNAME:-unknown}}"
-
-# Ensure .sticky-note directory exists
-mkdir -p "$STICKY_DIR"
-
-# Print context from sticky-note before starting Codex
-echo ""
-echo "📌 Sticky Note — injecting context for Codex session $SESSION_ID"
-echo ""
-
-if [ -f "$STICKY_DIR/sticky-note.json" ]; then
-    node "$SCRIPT_DIR/session-start.js" <<EOF 2>/dev/null || true
-{"session_id": "$SESSION_ID"}
-EOF
-fi
-
-echo "─────────────────────────────────────────────"
-echo ""
-
-# Run Codex, capturing output
-codex "$@" 2>&1 | tee "$TRANSCRIPT_FILE"
-CODEX_EXIT=$?
-
-echo ""
-echo "─────────────────────────────────────────────"
-echo "📌 Sticky Note — processing Codex session..."
-
-# Parse transcript for narrative + failed_approaches
-PARSED=$(node "$SCRIPT_DIR/parse-transcript.js" "$TRANSCRIPT_FILE" 2>/dev/null || echo '{"narrative":"","failed_approaches":[]}')
-
-# Call session-end.js with the transcript info + parsed data
-node "$SCRIPT_DIR/session-end.js" <<EOF 2>/dev/null || true
-{
-    "session_id": "$SESSION_ID",
-    "transcript_path": "$TRANSCRIPT_FILE",
-    "parsed_transcript": ${PARSED},
-    "hook_event_name": "sessionEnd",
-    "reason": "codex_exit"
-}
-EOF
-
-# Cleanup transcript
-rm -f "$TRANSCRIPT_FILE"
-
-echo "[OK] Session $SESSION_ID recorded."
-echo ""
-
-exit $CODEX_EXIT
+#!/usr/bin/env bash
+# sticky-codex.sh — Codex wrapper for Sticky Note V2
+#
+# Captures Codex stdout/stderr to a temp session log.
+# On exit: calls session-end.js with the transcript for
+# narrative + failed_approaches extraction.
+#
+# Usage:
+#   sticky-codex [codex args...]
+#
+# Setup:
+#   npx sticky-note init --codex
+#   alias sticky-codex="/path/to/.claude/hooks/sticky-codex.sh"
+#
+# Limitation: Context is printed to terminal after Codex exits,
+# not injected into the Codex window. Per-prompt surfacing not available.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+STICKY_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)/.sticky-note"
+SESSION_ID="codex-$(date +%s)-$$"
+TRANSCRIPT_FILE=$(mktemp "${TMPDIR:-/tmp}/sticky-codex-XXXXXX.log")
+USER="${USER:-${USERNAME:-unknown}}"
+
+# Ensure .sticky-note directory exists
+mkdir -p "$STICKY_DIR"
+
+# Print context from sticky-note before starting Codex
+echo ""
+echo "📌 Sticky Note — injecting context for Codex session $SESSION_ID"
+echo ""
+
+if [ -f "$STICKY_DIR/sticky-note.json" ]; then
+    node "$SCRIPT_DIR/session-start.js" <<EOF 2>/dev/null || true
+{"session_id": "$SESSION_ID"}
+EOF
+fi
+
+echo "─────────────────────────────────────────────"
+echo ""
+
+# Run Codex, capturing output
+codex "$@" 2>&1 | tee "$TRANSCRIPT_FILE"
+CODEX_EXIT=$?
+
+echo ""
+echo "─────────────────────────────────────────────"
+echo "📌 Sticky Note — processing Codex session..."
+
+# Parse transcript for narrative + failed_approaches
+PARSED=$(node "$SCRIPT_DIR/parse-transcript.js" "$TRANSCRIPT_FILE" 2>/dev/null || echo '{"narrative":"","failed_approaches":[]}')
+
+# Call session-end.js with the transcript info + parsed data
+node "$SCRIPT_DIR/session-end.js" <<EOF 2>/dev/null || true
+{
+    "session_id": "$SESSION_ID",
+    "transcript_path": "$TRANSCRIPT_FILE",
+    "parsed_transcript": ${PARSED},
+    "hook_event_name": "sessionEnd",
+    "reason": "codex_exit"
+}
+EOF
+
+# Cleanup transcript
+rm -f "$TRANSCRIPT_FILE"
+
+echo "[OK] Session $SESSION_ID recorded."
+echo ""
+
+exit $CODEX_EXIT

package/templates/sticky-note-config.json

@@ -1,5 +1,6 @@
 {
   "stale_days": 14,
+  "copilot_cli_auto_close_hours": 24,
   "inject_token_budget": 1000,
   "mcp_servers": [],
   "skills": [],