sticky-note-cli 2.6.9 → 2.6.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "2.6.9",
+  "version": "2.6.10",
   "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

@@ -54,6 +54,7 @@ const {
   getResumeThreadId, findThreadById, getSessionId,
   appendAuditLine, detectTool, getConfigPath,
   isThreadInjected, markThreadInjected, normalizeSep,
+  writeOverlapSignal, isOverlapDismissed,
 } = utils;
 
 // ── Git helpers ───────────────────────────────────────────
@@ -528,6 +529,10 @@ function main() {
     // Even with no scored threads, check for overlaps
     const overlapWarning = detectAndFormatOverlaps(threads, currentUser);
     if (overlapWarning) {
+      // Write signal file for preToolUse deny (user-visible in Copilot CLI)
+      if (_isCopilotCli() && !isOverlapDismissed()) {
+        writeOverlapSignal(overlapWarning);
+      }
       _auditInject("no_scored_threads", 0);
       _emit(overlapWarning);
       return;
@@ -585,6 +590,10 @@ function main() {
   // Prepend overlap warning if other users' threads touch the same files
   const overlapWarning = detectAndFormatOverlaps(threads, currentUser);
   if (overlapWarning) {
+    // Write signal file for preToolUse deny (user-visible in Copilot CLI)
+    if (_isCopilotCli() && !isOverlapDismissed()) {
+      writeOverlapSignal(overlapWarning);
+    }
     output = overlapWarning + "\n" + output;
   }
 

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

@@ -61,11 +61,8 @@ const {
   appendAuditLine,
   isThreadInjected,
   markThreadInjected,
-  isOverlapWarned,
-  markOverlapWarned,
-  getMemoryPath,
-  loadJson,
-  normalizeSep,
+  readAndDeleteOverlapSignal,
+  markOverlapDismissed,
 } = utils;
 
 // ── File path extraction from tool input ──────────────────
@@ -136,107 +133,49 @@ 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;
-}
+// ── Overlap deny via signal file (Copilot CLI only) ───────
+// inject-context.js writes .overlap-pending with the warning text.
+// We read+delete it atomically and return a deny. No shared state,
+// no TTL, no session-ID issues.
 
-function _checkOverlapsAndDeny(hookInput) {
+function _checkOverlapSignal() {
   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 });
+  const signalContent = readAndDeleteOverlapSignal();
+  if (!signalContent) return null;
+
+  // Extract a concise version for the deny reason
+  // The signal file contains the full markdown warning from detectAndFormatOverlaps
+  const lines = signalContent.split("\n").filter((l) => l.trim());
+  const denyLines = ["⚠️ OVERLAP DETECTED — someone else is working on files you're touching:"];
+  for (const line of lines) {
+    // Include lines that show user/file info (start with "- [")
+    if (line.trimStart().startsWith("- [")) {
+      denyLines.push("  " + line.trim().replace(/^- /, ""));
+    }
   }
-
-  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 : ""}`);
+  if (denyLines.length === 1) {
+    // Fallback: just use first 300 chars of signal
+    denyLines.push(signalContent.substring(0, 300));
   }
-  lines.push("Consider coordinating before proceeding. This tool call will be auto-retried.");
+  denyLines.push("Consider coordinating before proceeding. This tool call will be auto-retried.");
 
-  // Mark as warned so subsequent tool calls aren't blocked
-  markOverlapWarned(sessionId);
+  // Mark as dismissed so inject-context doesn't re-create signal for 5 minutes
+  markOverlapDismissed();
 
-  // Audit the overlap deny
+  // Audit
   try {
     appendAuditLine({
       type: "overlap_deny",
-      user: currentUser,
+      user: getUser(),
       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,
-      })),
+      session_id: getSessionId({}),
     });
   } catch (_) { /* ignore */ }
 
   return {
     permissionDecision: "deny",
-    permissionDecisionReason: lines.join("\n"),
+    permissionDecisionReason: denyLines.join("\n"),
   };
 }
 
@@ -256,8 +195,8 @@ 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);
+  // Check if inject-context.js wrote a pending overlap signal file.
+  const denyResult = _checkOverlapSignal();
   if (denyResult) {
     process.stdout.write(JSON.stringify(denyResult) + "\n");
     return;

package/templates/hooks/sticky-utils.js

@@ -590,32 +590,50 @@ function markThreadInjected(threadId, sessionId) {
   saveInjectedSet(data);
 }
 
-// ── Overlap-warned tracking (V2.6) ────────────────────────
+// ── Overlap signal file (V2.6.10) ─────────────────────────
+// Signal file approach: inject-context.js writes .overlap-pending with the
+// warning text. pre-tool-use.js reads+deletes it atomically and returns a
+// deny with the content. This avoids shared-state / TTL / session-ID issues.
 
-function isOverlapWarned(sessionId) {
-  const data = loadInjectedSet();
-  // Session-scoped check: different session → not warned
-  if (sessionId && data.session_id && data.session_id !== sessionId) {
-    return false;
+const _overlapPendingPath = () => path.join(_stickyDir(), ".overlap-pending");
+const _overlapDismissedPath = () => path.join(_stickyDir(), ".overlap-dismissed");
+
+function writeOverlapSignal(text) {
+  try {
+    fs.writeFileSync(_overlapPendingPath(), text, "utf-8");
+  } catch (_) { /* ignore */ }
+}
+
+function readAndDeleteOverlapSignal() {
+  try {
+    const content = fs.readFileSync(_overlapPendingPath(), "utf-8");
+    fs.unlinkSync(_overlapPendingPath());
+    return content || null;
+  } catch (_) {
+    return null;
   }
-  // Time-based fallback: if warned more than 60s ago, treat as new session.
-  // Copilot CLI sessions share session IDs (via .sticky-session file), so
-  // we can't rely on session_id alone to distinguish separate sessions.
-  if (data.overlap_warned_at) {
-    const elapsed = Date.now() - new Date(data.overlap_warned_at).getTime();
-    if (elapsed > 60000) return false;
+}
+
+function isOverlapDismissed(ttlMs) {
+  try {
+    const raw = fs.readFileSync(_overlapDismissedPath(), "utf-8").trim();
+    const elapsed = Date.now() - new Date(raw).getTime();
+    return elapsed < (ttlMs || 300000); // default 5 minutes
+  } catch (_) {
+    return false;
   }
-  return !!data.overlap_warned;
 }
 
-function markOverlapWarned(sessionId) {
-  const data = loadInjectedSet();
-  data.session_id = sessionId || data.session_id;
-  data.overlap_warned = true;
-  data.overlap_warned_at = new Date().toISOString();
-  saveInjectedSet(data);
+function markOverlapDismissed() {
+  try {
+    fs.writeFileSync(_overlapDismissedPath(), new Date().toISOString(), "utf-8");
+  } catch (_) { /* ignore */ }
 }
 
+// Legacy stubs — kept for API compat
+function isOverlapWarned() { return false; }
+function markOverlapWarned() { /* no-op */ }
+
 // ── Active resumed thread tracking (V2.5) ─────────────────
 
 const _activeResumePath = () => path.join(_stickyDir(), ".sticky-active-resume");
@@ -702,6 +720,11 @@ module.exports = {
   // V2.6: overlap warning tracking
   isOverlapWarned,
   markOverlapWarned,
+  // V2.6.10: overlap signal file
+  writeOverlapSignal,
+  readAndDeleteOverlapSignal,
+  isOverlapDismissed,
+  markOverlapDismissed,
   // V2.5: cross-platform path helper
   normalizeSep,
 };