sticky-note-cli 2.6.11 → 2.6.13

package/README.md

@@ -42,7 +42,14 @@ their next session by relevance.
 
 ---
 
-## What's New in V2.5
+## What's New in V2.6
+
+- **Overlap detection**: Warns when you're working on files another teammate has open/stuck threads on. Three delivery channels: injected context, stderr banner, and preToolUse deny (Copilot CLI)
+- **File claiming**: `npx sticky-note-cli claim src/auth.ts "refactoring auth flow"` — declare intent to work on files
+- **Auto-close Copilot CLI threads**: Threads from Copilot CLI sessions auto-close after configurable inactivity (default 24h), since Copilot CLI has no session-end signal
+- **PID-keyed session isolation**: Concurrent Copilot CLI sessions get independent overlap dedup via `COPILOT_LOADER_PID`
+
+### What's New in V2.5
 
 - **Smart injection (two-tier)**: Stuck threads injected eagerly at session start; all other threads injected lazily when you first touch a file they authored — via built-in git blame attribution
 - **Thread resume (local)**: `npx sticky-note-cli resume-thread --query "auth fix" --user alice` — natural language thread discovery with text similarity + file attribution ranking
@@ -148,7 +155,7 @@ injects the top 3–5 (under token budget) as additional context.
 
 | Signal | Weight | Description |
 |--------|--------|-------------|
-| File overlap | 3 | Thread files match your recent git changes |
+| File overlap | 3 per file (max 5) | Thread files match your recent git changes |
 | Branch match | 2 | Thread is on your current branch |
 | Recency | 2 | Decays 0.2 per day from last activity |
 | Stuck status | +2 | Boost for threads marked stuck |
@@ -321,6 +328,8 @@ npx sticky-note-cli resume --clear # Cancel active resume
 npx sticky-note-cli resume-thread  # Smart resume: --query, --user, --file (V2.5)
 npx sticky-note-cli audit          # Query merged audit trail (all users)
 npx sticky-note-cli who            # Show active and recent team members
+npx sticky-note-cli overlap        # Detect file overlaps with teammates (V2.6)
+npx sticky-note-cli claim <files>  # Declare intent to work on files (V2.6)
 npx sticky-note-cli switch <branch> # Safe branch switch (auto-stashes data)
 npx sticky-note-cli gc             # Tombstone expired threads
 npx sticky-note-cli reset          # Wipe all threads (--force, --keep-audit)
@@ -349,16 +358,20 @@ Edit `.sticky-note/sticky-note-config.json`:
 ```json
 {
   "stale_days": 14,
+  "copilot_cli_auto_close_hours": 24,
+  "inject_token_budget": 1000,
   "mcp_servers": [],
   "skills": [],
   "conventions": ["Use TypeScript strict mode", "Test before commit"],
-  "hook_version": "2.5.0"
+  "hook_version": "2.6.12"
 }
 ```
 
 | Key            | Description                              | Default |
 |----------------|------------------------------------------|---------|
 | `stale_days`   | Days before threads expire + gc cleanup  | `14`    |
+| `copilot_cli_auto_close_hours` | Hours before idle Copilot CLI threads auto-close | `24` |
+| `inject_token_budget` | Max tokens for per-prompt thread injection | `1000` |
 | `mcp_servers`  | Shared MCP server references             | `[]`    |
 | `skills`       | Team skill definitions                   | `[]`    |
 | `conventions`  | Team coding conventions (injected)       | `[]`    |

package/bin/cli.js

@@ -526,12 +526,29 @@ async function cmdInit() {
     gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
   }
 
+  // Fix overly broad .claude/ ignore that blocks hook sharing
+  let gitignoreChanged = false;
+  if (gitignoreContent) {
+    const lines = gitignoreContent.split(/\r?\n/);
+    const filtered = lines.filter((line) => {
+      const trimmed = line.trim();
+      // Remove lines that ignore all of .claude/ (but keep targeted entries)
+      return trimmed !== ".claude/" && trimmed !== ".claude";
+    });
+    if (filtered.length !== lines.length) {
+      gitignoreContent = filtered.join("\n");
+      fs.writeFileSync(gitignorePath, gitignoreContent);
+      gitignoreChanged = true;
+      print("  [OK] .gitignore: removed broad .claude/ ignore (hooks will be shared via git)");
+    }
+  }
+
   const missingEntries = ignoreAdditions.filter((e) => !gitignoreContent.includes(e.trim()));
   if (missingEntries.length > 0) {
     const block = "\n# Sticky Note\n" + missingEntries.join("\n") + "\n";
     fs.appendFileSync(gitignorePath, block);
     print("  [OK] .gitignore updated");
-  } else {
+  } else if (!gitignoreChanged) {
     print("  ⏭️  .gitignore already configured");
   }
 
@@ -623,6 +640,17 @@ async function cmdInit() {
     print("  [OK] .git/hooks/post-rewrite (attribution survives rebase)");
   }
 
+  // Force-add .claude/hooks/ and .claude/settings.json so git tracks them
+  // (needed if .claude/ was previously in .gitignore)
+  try {
+    execFileSync("git", ["add", "--force", ".claude/hooks/", ".claude/settings.json"], {
+      cwd: process.cwd(), stdio: ["pipe", "pipe", "pipe"],
+    });
+    print("  [OK] .claude/hooks/ and .claude/settings.json staged for git");
+  } catch (err) {
+    debugLog("git add --force .claude/ failed: " + (err.message || err));
+  }
+
   // Done!
   print("\n  ✨ Sticky Note V2 initialized!\n");
   print("  Next steps:");
@@ -699,6 +727,44 @@ function cmdUpdate() {
 
   // Upgrade .gitattributes from merge=union to custom driver
   const gitattrsPath = path.join(process.cwd(), ".gitattributes");
+
+  // Fix overly broad .claude/ gitignore that blocks hook sharing
+  const gitignorePath = path.join(process.cwd(), ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    let gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+    const lines = gitignoreContent.split(/\r?\n/);
+    const filtered = lines.filter((line) => {
+      const trimmed = line.trim();
+      return trimmed !== ".claude/" && trimmed !== ".claude";
+    });
+    if (filtered.length !== lines.length) {
+      fs.writeFileSync(gitignorePath, filtered.join("\n"));
+      print("  [OK] .gitignore: removed broad .claude/ ignore (hooks will be shared via git)");
+
+      // Ensure targeted ignores are present
+      const ignoreAdditions = fs
+        .readFileSync(path.join(TEMPLATES_DIR, "gitignore-additions.txt"), "utf-8")
+        .trim()
+        .split(/\r?\n/)
+        .filter((l) => l.trim() && !l.startsWith("#"));
+      const updatedContent = fs.readFileSync(gitignorePath, "utf-8");
+      const missing = ignoreAdditions.filter((e) => !updatedContent.includes(e.trim()));
+      if (missing.length > 0) {
+        fs.appendFileSync(gitignorePath, "\n# Sticky Note\n" + missing.join("\n") + "\n");
+      }
+
+      // Force-add previously ignored hook files so git starts tracking them
+      try {
+        execFileSync("git", ["add", "--force", ".claude/hooks/", ".claude/settings.json"], {
+          cwd: process.cwd(), stdio: ["pipe", "pipe", "pipe"],
+        });
+        print("  [OK] git add --force .claude/hooks/ .claude/settings.json");
+      } catch (err) {
+        debugLog("git add --force .claude/ failed: " + (err.message || err));
+      }
+    }
+  }
+
   if (fs.existsSync(gitattrsPath)) {
     let gitattrsContent = fs.readFileSync(gitattrsPath, "utf-8");
     const oldRule = ".sticky-note/sticky-note.json merge=union";

package/package.json

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

package/templates/CLAUDE.md

@@ -189,9 +189,15 @@ if set up by `npx sticky-note init`.
 ### ⚠️ Overlap warnings (CRITICAL — always surface these)
 
 Sticky-note hooks detect when your files overlap with other teammates'
-open or stuck threads. When you see `[STICKY-NOTE] ⚠️ OVERLAP DETECTED`
-in your injected context, you **MUST** start your response with this
-exact banner format before doing ANYTHING else:
+open or stuck threads. Overlap warnings arrive through TWO channels:
+
+1. **Injected context** — `[STICKY-NOTE] ⚠️ OVERLAP DETECTED` appears in
+   your hook output. This fires on every user prompt.
+2. **Tool call deny** — Your first tool call may be denied with a reason
+   containing "CRITICAL INSTRUCTION" and the overlap details.
+
+When you receive an overlap warning through EITHER channel, you **MUST**
+start your response with this exact banner format before doing ANYTHING else:
 
 ```
 ⚠️ Overlap detected: [user] is working on [files] — [narrative summary]
@@ -202,6 +208,7 @@ Rules:
 - This banner MUST be the **very first thing** in your response
 - Do NOT bury it at the end or in a footnote
 - Do NOT rephrase it as "Also noted..." or "By the way..."
+- If a tool call was denied with overlap info, display the warning then proceed
 - Then continue with the user's actual request normally
 
 This pattern exists to prevent two teammates from wasting hours on the

package/templates/copilot-instructions.md

@@ -167,9 +167,16 @@ if set up by `npx sticky-note init`.
 ### ⚠️ Overlap warnings (CRITICAL — always surface these)
 
 Sticky-note hooks detect when your files overlap with other teammates'
-open or stuck threads. When you see `[STICKY-NOTE] ⚠️ OVERLAP DETECTED`
-in your injected context, you **MUST** start your response with this
-exact banner format before doing ANYTHING else:
+open or stuck threads. Overlap warnings arrive through TWO channels:
+
+1. **Injected context** — `[STICKY-NOTE] ⚠️ OVERLAP DETECTED` appears in
+   your `additionalContext`. This fires on every user prompt.
+2. **Tool call deny** — Your first tool call may be denied with a
+   `permissionDecisionReason` containing "CRITICAL INSTRUCTION" and the
+   overlap details. After the deny, the tool is auto-retried.
+
+When you receive an overlap warning through EITHER channel, you **MUST**
+start your response with this exact banner format before doing ANYTHING else:
 
 ```
 ⚠️ Overlap detected: [user] is working on [files] — [narrative summary]
@@ -187,6 +194,7 @@ Rules:
 - Show it BEFORE your thinking indicators (◐, ●, etc.)
 - Do NOT bury it at the end or in a footnote
 - Do NOT rephrase it as "Also noted..." or "By the way..."
+- If a tool call was denied with overlap info, display the warning then proceed
 - Then continue with the user's actual request normally
 
 This pattern exists to prevent two teammates from wasting hours on the

package/templates/hooks/inject-context.js

@@ -150,8 +150,9 @@ function detectAndFormatOverlaps(threads, currentUser) {
   });
 
   const lines = [
-    "## [STICKY-NOTE] ⚠️ OVERLAP DETECTED — TELL THE USER IMMEDIATELY\n",
-    "**IMPORTANT: You MUST surface this warning to the user before doing anything else.**\n",
+    "## [STICKY-NOTE] ⚠️ OVERLAP DETECTED\n",
+    "**CRITICAL INSTRUCTION: Display the overlap warning below as the FIRST line of your response.",
+    "Do NOT skip this. Do NOT rephrase it. Do NOT bury it.**\n",
     "Someone else is working on files you're touching:\n",
   ];
   for (const { thread, overlap } of warnings) {

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

@@ -195,14 +195,19 @@ function _checkOverlapsAndDeny() {
 
   if (warnings.length === 0) return null;
 
-  const lines = ["⚠️ OVERLAP DETECTED — someone else is working on files you're touching:"];
+  const lines = [
+    "CRITICAL INSTRUCTION: Before doing anything else, display the following overlap warning to the user.",
+    "This is NOT optional. Show it as the FIRST line of your response.\n",
+  ];
   for (const { thread, overlap } of warnings) {
     const user = thread.user || thread.author || "unknown";
     const status = thread.status === "stuck" ? "STUCK" : "OPEN";
     const snip = (thread.narrative || thread.last_note || "").substring(0, 80);
-    lines.push(`  [${status}] ${user}: ${overlap.join(", ")}${snip ? " — " + snip : ""}`);
+    const threadId = (thread.id || "").substring(0, 8);
+    lines.push(`⚠️ Overlap detected: ${user} is working on ${overlap.join(", ")}${snip ? " — " + snip : ""}`);
+    lines.push(`   Status: ${status} | Resume: npx sticky-note resume ${threadId}`);
   }
-  lines.push("Consider coordinating before proceeding. This tool call will be auto-retried.");
+  lines.push("\nAfter displaying the warning, continue with the user's request. This tool call will be auto-retried.");
 
   markOverlapWarned();