sticky-note-cli 2.6.6 → 2.6.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "2.6.6",
+  "version": "2.6.8",
   "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/inject-context.js

@@ -181,6 +181,25 @@ function detectAndFormatOverlaps(threads, currentUser) {
   lines.push(
     "\n**Consider coordinating with these teammates before starting work.**\n"
   );
+
+  // Write a visible banner directly to stderr so the user sees it in
+  // their terminal regardless of whether the AI surfaces it.
+  const stderrLines = ["\n⚠️  OVERLAP DETECTED — someone else is touching your files:"];
+  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 > 80
+      ? narrative.substring(0, 80) + "…"
+      : narrative;
+    stderrLines.push(
+      `   [${status}] ${user}: ${overlap.join(", ")}` +
+      (narrativeSnip ? ` — ${narrativeSnip}` : "")
+    );
+  }
+  stderrLines.push("");
+  process.stderr.write(stderrLines.join("\n") + "\n");
+
   return lines.join("\n");
 }
 

package/templates/hooks/pre-tool-use.js

@@ -61,6 +61,11 @@ const {
   appendAuditLine,
   isThreadInjected,
   markThreadInjected,
+  isOverlapWarned,
+  markOverlapWarned,
+  getMemoryPath,
+  loadJson,
+  normalizeSep,
 } = utils;
 
 // ── File path extraction from tool input ──────────────────
@@ -131,6 +136,110 @@ function formatThreadForInjection(threadData, file) {
   return lines.join("\n");
 }
 
+// ── Overlap detection via preToolUse deny (Copilot CLI only) ──
+// Copilot CLI ignores output from all hooks except preToolUse "deny".
+// On the FIRST tool call of a session, if we detect file overlaps with
+// other users' threads, we deny the tool call with the overlap warning
+// as the reason. The AI reports the denial to the user, then retries.
+// Subsequent tool calls proceed normally.
+
+const { execSync } = require("child_process");
+
+function _getRecentlyModifiedFiles() {
+  const files = new Set();
+  for (const target of ["HEAD~5", "HEAD~1"]) {
+    try {
+      const result = execSync(`git diff --name-only ${target}`, {
+        encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+      });
+      for (const f of result.trim().split(/\r?\n/)) {
+        if (f.trim()) files.add(f.trim());
+      }
+      break;
+    } catch (_) { /* target doesn't exist */ }
+  }
+  try {
+    const result = execSync("git diff --name-only", {
+      encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+    });
+    for (const f of result.trim().split(/\r?\n/)) {
+      if (f.trim()) files.add(f.trim());
+    }
+  } catch (_) { /* ignore */ }
+  return files;
+}
+
+function _checkOverlapsAndDeny(hookInput) {
+  if (!_isCopilotCli()) return null;
+
+  const sessionId = getSessionId(hookInput);
+  if (isOverlapWarned(sessionId)) return null;
+
+  // Load threads
+  let threads;
+  try {
+    const memPath = getMemoryPath();
+    const data = loadJson(memPath);
+    threads = data.threads || [];
+  } catch (_) {
+    return null;
+  }
+
+  const currentUser = getUser();
+  const modifiedFiles = _getRecentlyModifiedFiles();
+  if (modifiedFiles.size === 0) return null;
+
+  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;
+    const threadFiles = (thread.files_touched || []).map(normalizeSep);
+    const overlap = threadFiles.filter((f) => modifiedFiles.has(f));
+    if (overlap.length === 0) continue;
+    warnings.push({ thread, overlap });
+  }
+
+  if (warnings.length === 0) return null;
+
+  // Build a concise deny reason
+  const lines = ["⚠️ OVERLAP DETECTED — someone else is working on files you're touching:"];
+  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 snip = narrative.length > 80 ? narrative.substring(0, 80) + "…" : narrative;
+    lines.push(`  [${status}] ${user}: ${overlap.join(", ")}${snip ? " — " + snip : ""}`);
+  }
+  lines.push("Consider coordinating before proceeding. This tool call will be auto-retried.");
+
+  // Mark as warned so subsequent tool calls aren't blocked
+  markOverlapWarned(sessionId);
+
+  // Audit the overlap deny
+  try {
+    appendAuditLine({
+      type: "overlap_deny",
+      user: currentUser,
+      ts: new Date().toISOString(),
+      session_id: sessionId,
+      warnings_count: warnings.length,
+      threads: warnings.map((w) => ({
+        user: w.thread.user || w.thread.author,
+        files: w.overlap,
+      })),
+    });
+  } catch (_) { /* ignore */ }
+
+  return {
+    permissionDecision: "deny",
+    permissionDecisionReason: lines.join("\n"),
+  };
+}
+
 // ── Main ──────────────────────────────────────────────────
 
 function main() {
@@ -146,6 +255,14 @@ function main() {
 
   const sessionId = getSessionId(hookInput);
 
+  // ── Overlap deny gate (Copilot CLI only) ──
+  // On first tool call, deny with overlap warning if applicable.
+  const denyResult = _checkOverlapsAndDeny(hookInput);
+  if (denyResult) {
+    process.stdout.write(JSON.stringify(denyResult) + "\n");
+    return;
+  }
+
   // Extract file path from tool input
   const filePath = extractFilePath(hookInput);
   if (!filePath) {

package/templates/hooks/session-start.js

@@ -394,6 +394,24 @@ function formatOverlapWarnings(threads, currentUser, memory) {
   lines.push(
     "\n**Consider coordinating with these teammates before starting work.**"
   );
+
+  // Write a visible banner directly to stderr so the user sees it
+  const stderrLines = ["\n⚠️  OVERLAP DETECTED — someone else is touching your files:"];
+  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 > 80
+      ? narrative.substring(0, 80) + "…"
+      : narrative;
+    stderrLines.push(
+      `   [${status}] ${user}: ${overlap.join(", ")}` +
+      (narrativeSnip ? ` — ${narrativeSnip}` : "")
+    );
+  }
+  stderrLines.push("");
+  process.stderr.write(stderrLines.join("\n") + "\n");
+
   return lines.join("\n");
 }
 

package/templates/hooks/sticky-utils.js

@@ -590,6 +590,23 @@ function markThreadInjected(threadId, sessionId) {
   saveInjectedSet(data);
 }
 
+// ── Overlap-warned tracking (V2.6) ────────────────────────
+
+function isOverlapWarned(sessionId) {
+  const data = loadInjectedSet();
+  if (sessionId && data.session_id && data.session_id !== sessionId) {
+    return false;
+  }
+  return !!data.overlap_warned;
+}
+
+function markOverlapWarned(sessionId) {
+  const data = loadInjectedSet();
+  data.session_id = sessionId || data.session_id;
+  data.overlap_warned = true;
+  saveInjectedSet(data);
+}
+
 // ── Active resumed thread tracking (V2.5) ─────────────────
 
 const _activeResumePath = () => path.join(_stickyDir(), ".sticky-active-resume");
@@ -673,6 +690,9 @@ module.exports = {
   getActiveResumeThreadId,
   setActiveResumeThreadId,
   clearActiveResumeThreadId,
+  // V2.6: overlap warning tracking
+  isOverlapWarned,
+  markOverlapWarned,
   // V2.5: cross-platform path helper
   normalizeSep,
 };