sticky-note-cli 2.6.9 → 2.6.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "2.6.9",
+  "version": "2.6.11",
   "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/pre-tool-use.js

@@ -136,12 +136,10 @@ 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.
+// ── Overlap deny via COPILOT_LOADER_PID (Copilot CLI only) ──
+// Each Copilot CLI session has a unique COPILOT_LOADER_PID env var.
+// On the first tool call, if overlaps exist, deny with the warning.
+// The warned state is keyed by PID so concurrent sessions don't interfere.
 
 const { execSync } = require("child_process");
 
@@ -169,17 +167,14 @@ function _getRecentlyModifiedFiles() {
   return files;
 }
 
-function _checkOverlapsAndDeny(hookInput) {
+function _checkOverlapsAndDeny() {
   if (!_isCopilotCli()) return null;
+  if (!process.env.COPILOT_LOADER_PID) return null;
+  if (isOverlapWarned()) return null;
 
-  const sessionId = getSessionId(hookInput);
-  if (isOverlapWarned(sessionId)) return null;
-
-  // Load threads
   let threads;
   try {
-    const memPath = getMemoryPath();
-    const data = loadJson(memPath);
+    const data = loadJson(getMemoryPath());
     threads = data.threads || [];
   } catch (_) {
     return null;
@@ -189,48 +184,34 @@ function _checkOverlapsAndDeny(hookInput) {
   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) {
+  for (const thread of threads.filter((t) => t.status === "open" || t.status === "stuck")) {
     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 (overlap.length > 0) 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;
+    const snip = (thread.narrative || thread.last_note || "").substring(0, 80);
     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);
+  markOverlapWarned();
 
-  // 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,
-      })),
+      copilot_pid: process.env.COPILOT_LOADER_PID,
     });
   } catch (_) { /* ignore */ }
 
@@ -256,8 +237,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);
+  // Detect overlaps and deny on first tool call, keyed by COPILOT_LOADER_PID.
+  const denyResult = _checkOverlapsAndDeny();
   if (denyResult) {
     process.stdout.write(JSON.stringify(denyResult) + "\n");
     return;

package/templates/hooks/sticky-utils.js

@@ -590,32 +590,54 @@ function markThreadInjected(threadId, sessionId) {
   saveInjectedSet(data);
 }
 
-// ── Overlap-warned tracking (V2.6) ────────────────────────
+// ── Overlap warning tracking (V2.6.11) ────────────────────
+// Uses COPILOT_LOADER_PID to identify each Copilot CLI session uniquely.
+// Each session gets its own overlap-warned flag, preventing cross-session
+// poisoning. The flag file stores a JSON object keyed by PID.
 
-function isOverlapWarned(sessionId) {
-  const data = loadInjectedSet();
-  // Session-scoped check: different session → not warned
-  if (sessionId && data.session_id && data.session_id !== sessionId) {
+const _overlapFlagPath = () => path.join(_stickyDir(), ".overlap-warned");
+
+function _getCopilotPid() {
+  return process.env.COPILOT_LOADER_PID || null;
+}
+
+function isOverlapWarned() {
+  const pid = _getCopilotPid();
+  if (!pid) return false;
+  try {
+    const data = JSON.parse(fs.readFileSync(_overlapFlagPath(), "utf-8"));
+    return !!data[pid];
+  } catch (_) {
     return false;
   }
-  // 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;
-  }
-  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 markOverlapWarned() {
+  const pid = _getCopilotPid();
+  if (!pid) return;
+  let data = {};
+  try {
+    data = JSON.parse(fs.readFileSync(_overlapFlagPath(), "utf-8"));
+  } catch (_) { /* empty or missing */ }
+  // Clean up stale PIDs (older than 1 hour)
+  const now = Date.now();
+  for (const [k, v] of Object.entries(data)) {
+    if (now - v > 3600000) delete data[k];
+  }
+  data[pid] = now;
+  try {
+    fs.writeFileSync(_overlapFlagPath(), JSON.stringify(data), "utf-8");
+  } catch (_) { /* ignore */ }
 }
 
+// Signal file helpers — kept for backward compat but no longer primary
+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 (_) {} }
+function readAndDeleteOverlapSignal() { try { const c = fs.readFileSync(_overlapPendingPath(), "utf-8"); fs.unlinkSync(_overlapPendingPath()); return c || null; } catch (_) { return null; } }
+function isOverlapDismissed(ttlMs) { try { const e = Date.now() - new Date(fs.readFileSync(_overlapDismissedPath(), "utf-8").trim()).getTime(); return e < (ttlMs || 300000); } catch (_) { return false; } }
+function markOverlapDismissed() { try { fs.writeFileSync(_overlapDismissedPath(), new Date().toISOString(), "utf-8"); } catch (_) {} }
+
 // ── Active resumed thread tracking (V2.5) ─────────────────
 
 const _activeResumePath = () => path.join(_stickyDir(), ".sticky-active-resume");
@@ -702,6 +724,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,
 };