sticky-note-cli 2.6.16 → 2.7.1

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "sticky-note-cli",
-  "version": "2.6.16",
+  "version": "2.7.1",
   "description": "Human-to-human handoff for AI coding assistants. Git-backed shared memory for Claude Code and Copilot CLI.",
   "license": "MIT",
   "bin": {
-    "sticky-note": "./bin/cli.js"
+    "sticky-note": "./bin/cli.js",
+    "sticky-note-mcp": "./bin/mcp-server.js"
   },
   "keywords": [
     "ai",

package/templates/CLAUDE.md

@@ -186,33 +186,54 @@ after. A raw `git checkout` or `git switch` will fail if sticky-note
 files have uncommitted changes. The alias `git sw <branch>` also works
 if set up by `npx sticky-note init`.
 
-### ⚠️ Overlap warnings (CRITICAL — always surface these)
+### ⚠️ Overlap warnings
 
-Sticky-note hooks detect when your files overlap with other teammates'
-open or stuck threads. Overlap warnings arrive through TWO channels:
+Sticky-note detects when your files overlap with other teammates'
+open or stuck threads. When the MCP server is available, use the
+`check_overlaps` tool before editing files for the most reliable detection.
+
+Hooks also inject overlap context through two fallback 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.
+   containing overlap details (Copilot CLI only).
 
-When you receive an overlap warning through EITHER channel, you **MUST**
-start your response with this exact banner format before doing ANYTHING else:
+When you detect an overlap (via MCP tool or hook), surface it to the user
+using this styled banner format:
 
 ```
-⚠️ Overlap detected: [user] is working on [files] — [narrative summary]
-   Status: [STUCK/OPEN] | Resume: npx sticky-note resume [id]
+⚠️ ━━━ OVERLAP DETECTED ━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  🔴 [user] (STUCK) · [branch]
+     Files: [file1], [file2], [file3]
+     "[narrative summary]"
+     → Resume: npx sticky-note resume [id]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
-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
+Use 🔴 for STUCK threads, 🟡 for OPEN threads. For multiple overlaps,
+add additional entries between the bars.
+
+## Sticky Note MCP Server
+
+You have access to a `sticky-note` MCP server. Use it:
+
+1. **At session start**: Call `get_stuck_threads()` and `get_environment_status()`
+   to check for team blockers and environment changes. Surface any warnings.
+
+2. **Before editing files**: Call `check_overlaps(files)` with the files you
+   plan to edit. If overlaps exist, warn the user before proceeding.
+
+3. **For prior work context**: Call `get_thread_context_for_files(files)` or
+   `search_threads(query)` to find relevant thread history.
+
+4. **For audit history**: Call `get_audit_trail(file)` to understand who
+   changed a file and when.
 
-This pattern exists to prevent two teammates from wasting hours on the
-same problem. Treat it like a system alert, not optional context.
+These tools are the primary way sticky-note communicates with you.
+Hook-injected context supplements but does not replace MCP tool calls.
 
 ### `[STICKY-NOTE]` tags
 

package/templates/copilot-instructions.md

@@ -2,7 +2,34 @@
 # Sticky Note — Copilot CLI Instructions
 
 This repository uses **Sticky Note** for team handoff context.
-All session threads are stored in `.sticky-note/sticky-note.json`.
+
+## ⚠️ MANDATORY: Sticky Note MCP Tools (DO THIS FIRST)
+
+You have a `sticky-note` MCP server connected. You MUST call these tools:
+
+### On EVERY session — before doing any work:
+```
+get_stuck_threads()          → surface stuck threads to user
+get_environment_status()     → check for missing MCP servers/secrets
+```
+
+### Before EVERY file edit:
+```
+check_overlaps(files)        → detect if teammates are working on same files
+```
+If overlaps are found, display the overlap banner BEFORE proceeding.
+
+### When you need context:
+```
+get_thread_context_for_files(files)  → who worked on these files, what happened
+search_threads(query)                → keyword search across all threads
+get_session_context(id)              → full thread payload by ID
+get_audit_trail(file, user, since)   → query per-user audit logs
+get_presence()                       → who is currently active
+```
+
+These MCP tools are the PRIMARY way sticky-note communicates with you.
+Do NOT skip them. Do NOT substitute with manual file reads.
 
 ## When asked about threads, sessions, or teammate activity
 
@@ -17,20 +44,18 @@ git history, your own session memory, or any other source.
 - [CLOSED] `closed` — completed
 - [EXPIRED] `expired` — tombstoned, minimal data remains
 
-### Proactive context injection (V2.5)
+### Fallback: Manual context injection (if MCP is unavailable)
 
-Copilot CLI does not have lifecycle hooks, so **you must self-serve context**.
-Follow these two rules every session:
+If the sticky-note MCP server is not connected, fall back to self-serve:
 
-#### 1. Eager: At session start, check for stuck/open threads
+#### 1. At session start, check for stuck/open threads
 
-Before doing any work, read `.sticky-note/sticky-note.json` and check for
-threads with status `stuck` or `open`. If any exist, briefly summarize them
-to the user (what's blocked, what files are involved).
+Read `.sticky-note/sticky-note.json` and check for threads with status
+`stuck` or `open`. If any exist, briefly summarize them to the user.
 
-#### 2. Lazy: Before editing a file, check for prior thread context
+#### 2. Before editing a file, check for prior thread context
 
-**The first time you edit or read a file in a session**, run:
+**The first time you edit a file in a session**, run:
 ```bash
 npx sticky-note get-line-attribution --file <path>
 ```
@@ -164,41 +189,35 @@ after. A raw `git checkout` or `git switch` will fail if sticky-note
 files have uncommitted changes. The alias `git sw <branch>` also works
 if set up by `npx sticky-note init`.
 
-### ⚠️ Overlap warnings (CRITICAL — always surface these)
+### ⚠️ Overlap warnings
+
+Sticky-note detects when your files overlap with other teammates'
+open or stuck threads. When the MCP server is available, use the
+`check_overlaps` tool before editing files for the most reliable detection.
 
-Sticky-note hooks detect when your files overlap with other teammates'
-open or stuck threads. Overlap warnings arrive through TWO channels:
+Hooks also inject overlap context through two fallback 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.
+2. **Tool call deny** — Your first tool call may be denied with overlap
+   details (Copilot CLI only). 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:
+When you detect an overlap (via MCP tool or hook), surface it to the user
+using this styled banner format:
 
 ```
-⚠️ Overlap detected: [user] is working on [files] — [narrative summary]
-   Status: [STUCK/OPEN] | Resume: npx sticky-note resume [id]
-```
+⚠️ ━━━ OVERLAP DETECTED ━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-Example:
-```
-⚠️ Overlap detected: alice is working on session-start.js, cli.js — fixing auth token refresh
-   Status: STUCK (tried retry logic, tokens expire mid-request) | Resume: npx sticky-note resume demo-ali
-```
+  🔴 [user] (STUCK) · [branch]
+     Files: [file1], [file2], [file3]
+     "[narrative summary]"
+     → Resume: npx sticky-note resume [id]
 
-Rules:
-- This banner MUST be the **very first thing** in your response
-- 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
-same problem. Treat it like a system alert, not optional context.
+Use 🔴 for STUCK threads, 🟡 for OPEN threads. For multiple overlaps,
+add additional entries between the bars.
 
 ### `[STICKY-NOTE]` tags
 
@@ -218,4 +237,19 @@ when sticky-note is acting on their behalf.
 ### Team config
 
 Check `.sticky-note/sticky-note-config.json` for team conventions and settings.
+
+### Team environment sync
+
+The team's vibe coding environment is defined in `.sticky-note/environment/`.
+Skills, agents, commands, MCP servers, and permissions are auto-provisioned
+by the session-start hook — no manual setup needed.
+
+- **Skills:** `.sticky-note/environment/skills/*.md` → auto-copied to plugin dirs
+- **Agents:** `.sticky-note/environment/agents/*.md` → auto-copied to plugin dirs
+- **Commands:** `.sticky-note/environment/commands/*.md` → auto-copied to plugin dirs
+- **MCP servers:** Defined in `manifest.json` → secret-free servers auto-provisioned
+- **Permissions:** Defined in `manifest.json` → merged into settings
+
+Use `get_environment_status()` MCP tool to check what's provisioned vs missing.
+If MCP servers need secrets, tell the user to run `npx sticky-note bootstrap`.
 <!-- sticky-note:end -->

package/templates/environment/manifest.json

@@ -0,0 +1,37 @@
+{
+  "version": "1",
+
+  "mcp_servers": {
+    "context7": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp@latest"],
+      "description": "Fetch up-to-date docs for any library",
+      "required": true
+    },
+    "github": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
+      },
+      "description": "GitHub API access",
+      "required": true
+    }
+  },
+
+  "permissions": [
+    "Bash(npx sticky-note:*)",
+    "Bash(npm test:*)",
+    "Bash(node:*)"
+  ],
+
+  "env_vars": {
+    "GITHUB_TOKEN": {
+      "description": "GitHub PAT with repo scope",
+      "docs_url": "https://github.com/settings/tokens",
+      "required": true
+    }
+  }
+}

package/templates/hooks/inject-context.js

@@ -149,56 +149,75 @@ function detectAndFormatOverlaps(threads, currentUser) {
     return b.overlap.length - a.overlap.length;
   });
 
+  const bar = "━".repeat(52);
   const lines = [
     "## [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",
+    "**You MUST display the banner below as the FIRST thing in your response.**\n",
+    "```",
+    `⚠️ ━━━ OVERLAP DETECTED ${bar.substring(0, 28)}`,
   ];
   for (const { thread, overlap } of warnings) {
     const user = thread.user || thread.author || "unknown";
-    const status = thread.status === "stuck" ? "[STUCK]" : "[OPEN]";
+    const statusEmoji = thread.status === "stuck" ? "🔴" : "🟡";
+    const statusLabel = 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 branch = thread.branch ? ` · ${thread.branch}` : "";
     const threadId = (thread.id || "").substring(0, 8);
 
-    lines.push(`- ${status} **${user}**${branch}: ${overlap.join(", ")}`);
-    if (narrativeSnip) lines.push(`  _${narrativeSnip}_`);
+    lines.push("");
+    lines.push(`  ${statusEmoji} ${user} (${statusLabel})${branch}`);
+    lines.push(`     Files: ${overlap.join(", ")}`);
+    if (narrativeSnip) lines.push(`     "${narrativeSnip}"`);
     const failed = thread.failed_approaches || [];
     if (failed.length > 0) {
-      lines.push(`  ⚠️ ${failed.length} failed approach(es):`);
+      lines.push(`     ⚠️ ${failed.length} failed approach(es):`);
       for (const fa of failed.slice(0, 2)) {
-        lines.push(`    - ${(fa.description || "").substring(0, 80)}`);
+        lines.push(`       • ${(fa.description || "").substring(0, 80)}`);
       }
     }
-    if (threadId) {
-      lines.push(`  → Resume: \`npx sticky-note resume ${threadId}\``);
-    }
+    lines.push(`     → Resume: npx sticky-note resume ${threadId}`);
   }
-
+  lines.push("");
+  lines.push(bar);
+  lines.push("```");
   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:"];
+  // Write a styled banner to stderr so the user sees it in their terminal
+  const R = "\x1b[0m";
+  const Y = "\x1b[33m";
+  const BY = "\x1b[1;33m";
+  const BR = "\x1b[1;31m";
+  const BG = "\x1b[1;32m";
+  const B = "\x1b[1m";
+  const C = "\x1b[36m";
+  const D = "\x1b[2m";
+  const stderrLines = [
+    "",
+    `${Y}${bar}${R}`,
+    `${BY}  ⚠️  OVERLAP DETECTED${R}`,
+    `${Y}${bar}${R}`,
+  ];
   for (const { thread, overlap } of warnings) {
     const user = thread.user || thread.author || "unknown";
-    const status = thread.status === "stuck" ? "STUCK" : "OPEN";
+    const statusColor = thread.status === "stuck" ? BR : BG;
+    const statusLabel = 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}` : "")
-    );
+    const branchStr = thread.branch ? ` ${D}·${R} ${C}${thread.branch}${R}` : "";
+    stderrLines.push(`${Y}  ┃${R}  ${statusColor}[${statusLabel}]${R} ${B}${user}${R}${branchStr}`);
+    stderrLines.push(`${Y}  ┃${R}    Files: ${overlap.join(", ")}`);
+    if (narrativeSnip) stderrLines.push(`${Y}  ┃${R}    ${D}"${narrativeSnip}"${R}`);
+    const threadId = (thread.id || "").substring(0, 8);
+    stderrLines.push(`${Y}  ┃${R}    → Resume: ${C}npx sticky-note resume ${threadId}${R}`);
   }
-  stderrLines.push("");
+  stderrLines.push(`${Y}${bar}${R}`, "");
   process.stderr.write(stderrLines.join("\n") + "\n");
 
   return lines.join("\n");

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

@@ -168,62 +168,10 @@ function _getRecentlyModifiedFiles() {
 }
 
 function _checkOverlapsAndDeny() {
-  if (!_isCopilotCli()) return null;
-  if (!process.env.COPILOT_LOADER_PID) return null;
-  if (isOverlapWarned()) return null;
-
-  let threads;
-  try {
-    const data = loadJson(getMemoryPath());
-    threads = (data.threads || []).filter(Boolean);
-  } catch (_) {
-    return null;
-  }
-
-  const currentUser = getUser();
-  const modifiedFiles = _getRecentlyModifiedFiles();
-  if (modifiedFiles.size === 0) return null;
-
-  const warnings = [];
-  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) warnings.push({ thread, overlap });
-  }
-
-  if (warnings.length === 0) return null;
-
-  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);
-    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("\nAfter displaying the warning, continue with the user's request. This tool call will be auto-retried.");
-
-  markOverlapWarned();
-
-  try {
-    appendAuditLine({
-      type: "overlap_deny",
-      user: currentUser,
-      ts: new Date().toISOString(),
-      copilot_pid: process.env.COPILOT_LOADER_PID,
-    });
-  } catch (_) { /* ignore */ }
-
-  return {
-    permissionDecision: "deny",
-    permissionDecisionReason: lines.join("\n"),
-  };
+  // Overlap alerting is now handled by the MCP server's check_overlaps tool.
+  // This deny-based approach was unreliable (deny reason consumed silently).
+  // Kept as no-op to avoid breaking the call site.
+  return null;
 }
 
 // ── Main ──────────────────────────────────────────────────

package/templates/hooks/session-end.js

@@ -937,10 +937,10 @@ function main() {
   saveMemoryMerged(memoryPath, memory);
 
   // Auto-sync: commit (and optionally push) .sticky-note/ changes
-  const config = loadJson(getConfigPath(), {});
-  if (config.auto_sync !== false) {
+  const syncConfig = loadJson(getConfigPath(), {});
+  if (syncConfig.auto_sync !== false) {
     try {
-      syncStickyNote({ push: config.auto_push === true });
+      syncStickyNote({ push: syncConfig.auto_push === true });
     } catch (_) {
       // Non-fatal — sync failure shouldn't block session-end
     }