sticky-note-cli 3.1.33 → 3.1.35

package/bin/cli.js

@@ -3462,6 +3462,84 @@ function cmdDeployBackend() {
 }
 
 // ──────────────────────────────────────────────
+// CLOSE command — explicit goal completion signal
+// ──────────────────────────────────────────────
+
+async function cmdClose() {
+  const summary = process.argv.slice(3).join(" ").trim();
+  if (!summary) {
+    print("  Usage: npx sticky-note close \"what was accomplished\"");
+    print("  Also:  npx sticky-note done \"what was accomplished\"");
+    process.exit(1);
+  }
+
+  const stickyDir = getActiveStickyDir();
+  const sessionFile = path.join(stickyDir, ".sticky-session");
+  if (!fs.existsSync(sessionFile)) {
+    print("  [ERR] No active session found (.sticky-session missing).");
+    print("        This command is meant to be called during an active Claude Code session.");
+    process.exit(1);
+  }
+  const sessionId = fs.readFileSync(sessionFile, "utf-8").trim();
+  if (!sessionId) {
+    print("  [ERR] .sticky-session is empty.");
+    process.exit(1);
+  }
+
+  const memoryPath = path.join(stickyDir, "sticky-note.json");
+  const memory = readJsonSafe(memoryPath, { version: "2", threads: [] });
+  const threads = memory.threads || [];
+  const thread = threads.find(t => t.session_id === sessionId);
+
+  if (!thread) {
+    print(`  [ERR] No thread found for session ${sessionId}.`);
+    process.exit(1);
+  }
+
+  const now = new Date().toISOString();
+  thread.status = "closed";
+  thread.goal_achieved = true;
+  thread.handoff_summary = summary;
+  thread.closed_at = now;
+  thread.last_activity_at = now;
+  thread.last_note = summary.substring(0, 200);
+
+  memory.threads = threads;
+  fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2) + "\n");
+  print(`  [OK] Thread ${thread.id.slice(0, 8)} marked complete.`);
+  print(`  [OK] goal_achieved = true`);
+  print(`  [OK] Handoff: ${summary.substring(0, 120)}`);
+
+  // Push to cloud
+  const envStickyPath = path.join(process.cwd(), ".env.sticky");
+  if (fs.existsSync(envStickyPath)) {
+    let stickyUrl = "", stickyApiKey = "";
+    for (const line of fs.readFileSync(envStickyPath, "utf-8").split(/\r?\n/)) {
+      const t = line.trim();
+      if (t.startsWith("STICKY_URL=")) stickyUrl = t.slice("STICKY_URL=".length);
+      if (t.startsWith("STICKY_API_KEY=")) stickyApiKey = t.slice("STICKY_API_KEY=".length);
+    }
+    if (stickyUrl) {
+      try {
+        let projectName = "default";
+        try {
+          const remote = execFileSync("git", ["remote", "get-url", "origin"], {
+            encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+          }).trim();
+          const match = remote.match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+          if (match) projectName = match[1];
+        } catch (_) {}
+        const headers = { "Content-Type": "application/json", "X-Sticky-Project": projectName };
+        if (stickyApiKey) headers["X-Sticky-API-Key"] = stickyApiKey;
+        await fetch(`${stickyUrl}/threads/${thread.id}`, {
+          method: "PUT", headers, body: JSON.stringify(thread),
+        });
+        print(`  [OK] Pushed to cloud.`);
+      } catch (_) { /* non-fatal */ }
+    }
+  }
+}
+
 // MIGRATE --to cloud command (V3 cloud migration)
 // ──────────────────────────────────────────────
 
@@ -4995,6 +5073,10 @@ async function main() {
     case "migrate":
       await cmdMigrate();
       break;
+    case "close":
+    case "done":
+      await cmdClose();
+      break;
     case "--version":
     case "-v":
       print(`sticky-note v${VERSION}`);

package/bin/mcp-server.js

@@ -359,10 +359,34 @@ function toolSearchThreads(params) {
     return q.split(/\s+/).every((word) => searchable.includes(word));
   });
 
+  // Return summarized thread objects — full objects can exceed token limits
+  // when failed_approaches accumulates dozens of entries per thread.
+  const summarized = matches.map((t) => ({
+    id: t.id,
+    status: t.status,
+    user: t.user,
+    tool: t.tool,
+    branch: t.branch,
+    work_type: t.work_type,
+    goal_achieved: t.goal_achieved || false,
+    created_at: t.created_at,
+    last_activity_at: t.last_activity_at,
+    narrative: (t.narrative || "").substring(0, 300),
+    last_note: (t.last_note || "").substring(0, 200),
+    handoff_summary: (t.handoff_summary || "").substring(0, 300),
+    files_touched: (t.files_touched || []).slice(0, 20),
+    failed_approaches: (t.failed_approaches || []).slice(-3).map((f) => ({
+      description: typeof f === "string"
+        ? f.substring(0, 150)
+        : (f.description || "").substring(0, 150),
+      error: typeof f === "string" ? "" : (f.error || "").substring(0, 100),
+    })),
+  }));
+
   return {
     query,
-    count: matches.length,
-    threads: matches,
+    count: summarized.length,
+    threads: summarized,
   };
 }
 
@@ -706,6 +730,81 @@ function toolGetThreadContextForFiles(params) {
   };
 }
 
+// ──────────────────────────────────────────────
+// close_thread — explicit goal completion signal
+// ──────────────────────────────────────────────
+
+async function toolCloseThread(params) {
+  const { summary } = params;
+  if (!summary || !summary.trim()) {
+    return { error: "summary is required" };
+  }
+
+  // Find current session ID from .sticky-session file
+  const sessionFile = path.join(stickyDir(), ".sticky-session");
+  let sessionId = null;
+  if (fs.existsSync(sessionFile)) {
+    sessionId = fs.readFileSync(sessionFile, "utf-8").trim();
+  }
+  if (!sessionId) {
+    return { error: "No active session found — .sticky-note/.sticky-session missing or empty" };
+  }
+
+  // Find thread by session_id in local memory
+  const memoryPath = path.join(stickyDir(), "sticky-note.json");
+  const memory = readJsonSafe(memoryPath, { version: "2", threads: [] });
+  const threads = memory.threads || [];
+  const thread = threads.find(t => t.session_id === sessionId);
+
+  if (!thread) {
+    return { error: `No thread found for session ${sessionId}` };
+  }
+
+  const now = new Date().toISOString();
+  thread.status = "closed";
+  thread.goal_achieved = true;
+  thread.handoff_summary = summary.trim();
+  thread.closed_at = now;
+  thread.last_activity_at = now;
+  thread.last_note = summary.trim().substring(0, 200);
+
+  // Save locally
+  memory.threads = threads;
+  try {
+    fs.writeFileSync(memoryPath, JSON.stringify(memory, null, 2) + "\n");
+  } catch (err) {
+    return { error: "Failed to save: " + err.message };
+  }
+
+  // Push to cloud if configured
+  const { url, apiKey } = getCloudConfig();
+  if (url) {
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Sticky-Project": getProjectName(),
+      };
+      if (apiKey) headers["X-Sticky-API-Key"] = apiKey;
+      const controller = new AbortController();
+      const t = setTimeout(() => controller.abort(), 8000);
+      await fetch(`${url}/threads/${thread.id}`, {
+        method: "PUT",
+        headers,
+        body: JSON.stringify(thread),
+        signal: controller.signal,
+      }).finally(() => clearTimeout(t));
+    } catch (_) { /* non-fatal — local save already succeeded */ }
+  }
+
+  return {
+    status: "closed",
+    goal_achieved: true,
+    thread_id: thread.id,
+    summary: summary.trim(),
+    message: "Thread marked complete. Thank you — this signal helps improve future sessions.",
+  };
+}
+
 // ──────────────────────────────────────────────
 // Tool registry
 // ──────────────────────────────────────────────
@@ -852,6 +951,22 @@ const TOOLS = {
     },
     handler: toolGetThreadContextForFiles,
   },
+  close_thread: {
+    description:
+      "Mark the current session's thread as explicitly completed by Claude. Sets goal_achieved=true and records a handoff summary. Call this when you have fully completed the user's stated goal — not just when the session ends. This is the signal used to measure whether AI sessions actually succeed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          description:
+            "What was accomplished. Be specific: what was built/fixed/answered, what files were changed, what the outcome was. This becomes the handoff_summary for teammates.",
+        },
+      },
+      required: ["summary"],
+    },
+    handler: toolCloseThread,
+  },
 };
 
 // ──────────────────────────────────────────────

package/package.json

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

@@ -25,6 +25,7 @@ cat .sticky-note/sticky-note.json
 | `narrative`        | Summary of what happened                   |
 | `failed_approaches`| What was tried and didn't work             |
 | `handoff_summary`  | Handoff notes for teammates                |
+| `goal_achieved`    | true if Claude explicitly completed the stated goal (via close_thread) |
 | `last_note`        | Most recent status note                    |
 | `work_type`        | bug-fix, feature, debugging, refactor, etc.|
 | `prompts`          | User prompts from the session (for cross-tool resume) |
@@ -268,6 +269,13 @@ You have access to a `sticky-note` MCP server. Use it:
    `get_full_transcript(id)` to get the verbatim session transcript(s) for
    a thread, when `narrative` or `prompts` aren't enough detail.
 
+6. **When you have fully completed the user's stated goal**: Call
+   `close_thread(summary)` with a specific description of what was accomplished.
+   This is the most important signal sticky-note collects — it distinguishes
+   sessions where the goal was actually achieved from sessions that merely ended.
+   Be specific: what was built/fixed, which files changed, what the outcome was.
+   Do NOT call this if the task is only partially done or if you are unsure.
+
 These tools are the primary way sticky-note communicates with you.
 Hook-injected context supplements but does not replace MCP tool calls.
 

package/templates/hooks/session-end.js

@@ -1141,7 +1141,9 @@ async function main() {
     existing.last_activity_at = now;
     // Copilot CLI fires SessionEnd per-turn, not per-session.
     // Keep thread open so it isn't prematurely closed between turns.
-    if (!isCopilotCli) {
+    // If goal_achieved is already set (via close_thread MCP or CLI), the
+    // thread was explicitly completed — preserve that signal, don't overwrite.
+    if (!isCopilotCli && !existing.goal_achieved) {
       existing.status = "closed";
       existing.closed_at = now;
     }