sticky-note-cli 3.1.41 → 3.1.43

package/bin/cli.js

@@ -1071,10 +1071,11 @@ async function cmdInit() {
     print("  ⏭️  .gitignore already configured");
   }
 
-  // Add .gitattributes merge strategy
+  // Add .gitattributes merge strategy for both thread data and config
   const gitattrsPath = path.join(process.cwd(), ".gitattributes");
   const oldMergeRule = ".sticky-note/sticky-note.json merge=union";
   const mergeRule = ".sticky-note/sticky-note.json merge=sticky-note";
+  const configMergeRule = ".sticky-note/sticky-note-config.json merge=sticky-note";
   let gitattrsContent = "";
   if (fs.existsSync(gitattrsPath)) {
     gitattrsContent = fs.readFileSync(gitattrsPath, "utf-8");
@@ -1089,10 +1090,18 @@ async function cmdInit() {
       ? `\n# Sticky Note - JSON-aware thread merge\n${mergeRule}\n`
       : `\n\n# Sticky Note - JSON-aware thread merge\n${mergeRule}\n`;
     fs.appendFileSync(gitattrsPath, addition);
+    gitattrsContent += addition;
     print("  [OK] .gitattributes updated (merge=sticky-note)");
   } else {
     print("  ⏭️  .gitattributes already configured");
   }
+  // Also protect sticky-note-config.json — merge conflicts here silently break
+  // cloud transport and hook loading for the entire team.
+  if (!gitattrsContent.includes(configMergeRule)) {
+    const addition = `${configMergeRule}\n`;
+    fs.appendFileSync(gitattrsPath, addition);
+    print("  [OK] .gitattributes: sticky-note-config.json protected from merge conflicts");
+  }
 
   // Install merge driver script and git config
   const mergeDriverSrc = path.join(TEMPLATES_DIR, "merge-driver.js");
@@ -1452,14 +1461,25 @@ async function cmdUpdate() {
     }
   }
 
-  if (fs.existsSync(gitattrsPath)) {
-    let gitattrsContent = fs.readFileSync(gitattrsPath, "utf-8");
+  {
+    let gitattrsContent = fs.existsSync(gitattrsPath)
+      ? fs.readFileSync(gitattrsPath, "utf-8") : "";
     const oldRule = ".sticky-note/sticky-note.json merge=union";
     const newRule = ".sticky-note/sticky-note.json merge=sticky-note";
+    const configRule = ".sticky-note/sticky-note-config.json merge=sticky-note";
     if (gitattrsContent.includes(oldRule)) {
       gitattrsContent = gitattrsContent.replace(oldRule, newRule);
       fs.writeFileSync(gitattrsPath, gitattrsContent, "utf-8");
       print("  [OK] .gitattributes upgraded (merge=union -> merge=sticky-note)");
+    } else if (!gitattrsContent.includes(newRule)) {
+      const addition = `\n# Sticky Note - JSON-aware thread merge\n${newRule}\n`;
+      fs.appendFileSync(gitattrsPath, addition);
+      gitattrsContent += addition;
+      print("  [OK] .gitattributes updated (merge=sticky-note)");
+    }
+    if (!gitattrsContent.includes(configRule)) {
+      fs.appendFileSync(gitattrsPath, `${configRule}\n`);
+      print("  [OK] .gitattributes: sticky-note-config.json protected from merge conflicts");
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sticky-note-cli",
-  "version": "3.1.41",
+  "version": "3.1.43",
   "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/data-branch.js

@@ -237,22 +237,28 @@ function pushDataBranch(remote, branchName, maxRetries, localMemPath, loadJsonFn
           ).trim();
 
           // Build merged file map: start with remote files as base, then
-          // overlay local files so this user's audit/presence are preserved
+          // overlay local files so this user's audit/presence are preserved.
+          // Capture remote sticky-note.json BEFORE the local overlay so we
+          // have the actual remote content to merge (not the local overwrite).
           const fileMap = {};
           const localRef = "refs/heads/" + branchName;
+          let remoteStickyContent = null;
           for (const f of listFilesInBranch(fetchResult.remoteRef)) {
             const content = readFileFromBranch(fetchResult.remoteRef, f);
-            if (content !== null) fileMap[f] = content;
+            if (content !== null) {
+              fileMap[f] = content;
+              if (f === "sticky-note.json") remoteStickyContent = content;
+            }
           }
           for (const f of listFilesInBranch(localRef)) {
             const content = readFileFromBranch(localRef, f);
             if (content !== null) fileMap[f] = content;
           }
 
-          // Merge sticky-note.json from both sides
-          if (localMemPath && fileMap["sticky-note.json"]) {
+          // Merge sticky-note.json from both sides using captured remote content
+          if (localMemPath && remoteStickyContent) {
             mergeAndSaveFromRemote(
-              localMemPath, fileMap["sticky-note.json"], loadJsonFn, saveJsonFn
+              localMemPath, remoteStickyContent, loadJsonFn, saveJsonFn
             );
             fileMap["sticky-note.json"] = fs.readFileSync(localMemPath, "utf-8");
           }
@@ -263,9 +269,12 @@ function pushDataBranch(remote, branchName, maxRetries, localMemPath, loadJsonFn
         }
       } catch (_) {}
 
-      // Brief exponential backoff (busy-wait — synchronous context)
-      const end = Date.now() + Math.pow(2, attempt) * 300;
-      while (Date.now() < end) {}
+      // Brief exponential backoff — use Atomics.wait to block without CPU spin
+      try {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.pow(2, attempt) * 300);
+      } catch (_) {
+        // Atomics.wait unavailable (e.g. SharedArrayBuffer disabled) — skip delay
+      }
     }
   }
   return { ok: false, error: "max retries exceeded" };
@@ -313,9 +322,16 @@ function mergeAndSaveFromRemote(localMemPath, remoteContent, loadJsonFn, saveJso
     return; // corrupt remote — skip
   }
 
-  const localMemory = loadJsonFn
-    ? loadJsonFn(localMemPath, { ...EMPTY_MEMORY })
-    : { ...EMPTY_MEMORY };
+  let localMemory;
+  if (loadJsonFn) {
+    localMemory = loadJsonFn(localMemPath, { ...EMPTY_MEMORY });
+  } else {
+    try {
+      localMemory = JSON.parse(fs.readFileSync(localMemPath, "utf-8"));
+    } catch (_) {
+      localMemory = { ...EMPTY_MEMORY };
+    }
+  }
 
   const localThreads = Array.isArray(localMemory.threads) ? localMemory.threads.filter(Boolean) : [];
   const remoteThreads = Array.isArray(remoteMemory.threads) ? remoteMemory.threads.filter(Boolean) : [];

package/templates/hooks/session-end.js

@@ -954,7 +954,7 @@ function _collectDirFiles(dir, ext, prefix, fileMap) {
 }
 
 function commitAndPushDataBranch() {
-  if (!dataBranch) return;
+  if (!dataBranch) return null;
   try {
     const fileMap = {};
     const memPath = getMemoryPath();
@@ -966,7 +966,7 @@ function commitAndPushDataBranch() {
     _collectDirFiles(getPresenceDir(), ".json", "presence/", fileMap);
     _collectDirFiles(getTranscriptsDir(), ".jsonl", "transcripts/", fileMap);
 
-    if (Object.keys(fileMap).length === 0) return;
+    if (Object.keys(fileMap).length === 0) return null;
 
     dataBranch.commitFilesToBranch(dataBranch.DATA_BRANCH, fileMap);
 
@@ -976,16 +976,18 @@ function commitAndPushDataBranch() {
         remote, dataBranch.DATA_BRANCH, 3, getMemoryPath(), loadJson, saveJson
       );
       if (!pushResult.ok) {
-        process.stderr.write(
-          "[STICKY-NOTE] warning: failed to push data branch — " + pushResult.error + "\n" +
-          "[STICKY-NOTE] your data is safe locally in .git/sticky-note/\n"
-        );
+        const hint = pushResult.error && pushResult.error.includes("authentication")
+          ? " Add STICKY_PUSH_TOKEN=<github_pat> to .env.sticky to fix."
+          : "";
+        const msg = `[STICKY-NOTE] ⚠️ data branch push failed — ${pushResult.error}${hint}`;
+        logHookError("data-branch-push", new Error(pushResult.error));
+        return msg;
       }
     }
+    return null;
   } catch (err) {
-    process.stderr.write(
-      "[STICKY-NOTE] warning: data branch sync failed — " + err.message + "\n"
-    );
+    logHookError("data-branch-sync", err);
+    return `[STICKY-NOTE] ⚠️ data branch sync failed — ${err.message}`;
   }
 }
 
@@ -1306,7 +1308,9 @@ async function main() {
   if (cloud) {
     const threadToSync = threads.find(t => t.session_id === sessionId);
     if (threadToSync) {
-      cloudWriteThread(threadToSync).catch(() => {});
+      cloudWriteThread(threadToSync).catch(err => {
+        logHookError("session-end:cloud-write", err);
+      });
     }
   }
 
@@ -1320,14 +1324,15 @@ async function main() {
   }
 
   // Commit current data to sticky-note/data branch and push
-  commitAndPushDataBranch();
+  const dataBranchWarning = commitAndPushDataBranch();
 
   const fileCount = filesTouched.length;
   const commitCount = commitShas.length;
   const statusLabel = isCopilotCli ? "updated" : "closed";
   const statusMsg = `[STICKY-NOTE] Session ${statusLabel} - thread ${isCopilotCli ? "updated" : "created"} (${fileCount} file${fileCount !== 1 ? "s" : ""}${commitCount > 0 ? ", " + commitCount + " commit" + (commitCount !== 1 ? "s" : "") : ""})`;
+  const fullOutput = dataBranchWarning ? `${statusMsg}\n${dataBranchWarning}` : statusMsg;
   try {
-    process.stdout.write(JSON.stringify({ output: statusMsg }) + "\n");
+    process.stdout.write(JSON.stringify({ output: fullOutput }) + "\n");
   } catch (_) {
     process.stdout.write('{"output":""}\n');
   }

package/templates/hooks/session-start.js

@@ -69,15 +69,38 @@ function _installedCliVersion() {
 }
 function formatVersionWarning(config) {
   try {
-    const min = config && config.min_version;
-    if (!min) return "";
     const installed = _installedCliVersion();
     if (!installed) return "";
-    if (_cmpSemver(installed, min) >= 0) return "";
-    const msg =
-      `[STICKY-NOTE] ⚠️ Installed sticky-note-cli v${installed} is below ` +
-      `this project's min_version v${min}. Run \`npm i -D sticky-note-cli@latest\` ` +
-      `to update — features and schema may differ until you do.`;
+    const warnings = [];
+
+    // Check 1: installed version is below the project's required minimum.
+    const min = config && config.min_version;
+    if (min && _cmpSemver(installed, min) < 0) {
+      warnings.push(
+        `[STICKY-NOTE] ⚠️ sticky-note-cli v${installed} is below this project's ` +
+        `min_version v${min}. Run \`npm i -g sticky-note-cli@latest\` to update — ` +
+        `features and bug fixes are missing until you do.`
+      );
+    }
+
+    // Check 2: hook scripts in .claude/hooks/ are older than the installed CLI.
+    // This means the teammate installed a newer CLI but never ran `npx sticky-note update`
+    // to refresh the hook files — they're running old code with new expectations.
+    const hookVer = config && config.hook_version;
+    if (hookVer && _cmpSemver(installed, hookVer) > 0) {
+      const iv = _parseSemver(installed), hv = _parseSemver(hookVer);
+      // Warn on any minor or major gap — patch-only differences are usually safe.
+      if (iv && hv && (iv[0] !== hv[0] || iv[1] !== hv[1])) {
+        warnings.push(
+          `[STICKY-NOTE] ⚠️ Hook scripts are v${hookVer} but sticky-note-cli v${installed} ` +
+          `is installed. Run \`npx sticky-note update\` to get the latest fixes ` +
+          `(data branch push, identity, credential handling).`
+        );
+      }
+    }
+
+    if (warnings.length === 0) return "";
+    const msg = warnings.join("\n");
     try { process.stderr.write(msg + "\n"); } catch (_) { /* non-fatal */ }
     return msg;
   } catch (_) {

package/templates/hooks/sticky-utils.js

@@ -450,6 +450,20 @@ function clearResumeSignal() {
 function loadJson(filePath, defaultVal) {
   try {
     const raw = fs.readFileSync(filePath, "utf-8");
+    // Detect unresolved git merge conflict markers — JSON.parse would silently
+    // swallow the SyntaxError and return the default, hiding the real problem.
+    // This breaks useCloud(), thread loading, and config reading with no trace.
+    if (raw.includes("<<<<<<<") || raw.includes(">>>>>>>")) {
+      logHookError(
+        "loadJson",
+        new Error(
+          `Unresolved git merge conflict in ${filePath}. ` +
+          `Resolve the conflict and commit, or restore the file with ` +
+          `\`git checkout HEAD -- ${path.relative(process.cwd(), filePath) || filePath}\``
+        )
+      );
+      return defaultVal !== undefined ? defaultVal : {};
+    }
     return JSON.parse(raw);
   } catch (_) {
     return defaultVal !== undefined ? defaultVal : {};
@@ -644,7 +658,6 @@ function getUser() {
   // Prefer git config user.name — consistent across machines regardless of OS login name.
   // Fall back to OS env vars, then "unknown".
   try {
-    const { execFileSync } = require("child_process");
     const name = execFileSync("git", ["config", "user.name"], {
       encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
     }).trim();
@@ -1281,6 +1294,7 @@ function getCloudConfig() {
   return {
     url: process.env.STICKY_URL || envFile.STICKY_URL || "",
     apiKey: process.env.STICKY_API_KEY || envFile.STICKY_API_KEY || "",
+    pushToken: process.env.STICKY_PUSH_TOKEN || envFile.STICKY_PUSH_TOKEN || "",
   };
 }