clay-server 2.19.0 → 2.20.0-beta.1

package/lib/project.js

@@ -129,7 +129,8 @@ function createProjectContext(opts) {
 
   // Convert imageRefs in history entries to images with URLs for the client
   function hydrateImageRefs(entry) {
-    if (!entry || entry.type !== "user_message" || !entry.imageRefs) return entry;
+    if (!entry || !entry.imageRefs) return entry;
+    if (entry.type !== "user_message" && entry.type !== "mention_user") return entry;
     var images = [];
     for (var ri = 0; ri < entry.imageRefs.length; ri++) {
       var ref = entry.imageRefs[ri];
@@ -419,6 +420,19 @@ function createProjectContext(opts) {
     isMate: isMate,
     dangerouslySkipPermissions: dangerouslySkipPermissions,
     onProcessingChanged: onProcessingChanged,
+    onTurnDone: isMate ? function (session, preview) { digestDmTurn(session, preview); } : null,
+    getAutoContinueSetting: function (session) {
+      // Per-user setting in multi-user mode
+      if (usersModule.isMultiUser() && session && session.ownerId) {
+        return usersModule.getAutoContinue(session.ownerId);
+      }
+      // Single-user: fall back to daemon config
+      if (typeof opts.onGetDaemonConfig === "function") {
+        var dc = opts.onGetDaemonConfig();
+        return !!dc.autoContinueOnRateLimit;
+      }
+      return false;
+    },
   });
 
   // --- Ralph Loop state ---
@@ -1381,6 +1395,22 @@ function createProjectContext(opts) {
       return;
     }
 
+    if (msg.type === "mention_stop") {
+      var session = getSessionForWs(ws);
+      if (session && session._mentionInProgress) {
+        // Abort the active mention session for this mate
+        var mateId = msg.mateId;
+        if (mateId && session._mentionSessions && session._mentionSessions[mateId]) {
+          session._mentionSessions[mateId].abort();
+          session._mentionSessions[mateId].close();
+          delete session._mentionSessions[mateId];
+        }
+        session._mentionInProgress = false;
+        sendToSession(session.localId, { type: "mention_done", mateId: mateId, stopped: true });
+      }
+      return;
+    }
+
     // --- Debate ---
     if (msg.type === "debate_start") {
       handleDebateStart(ws, msg);
@@ -1406,6 +1436,9 @@ function createProjectContext(opts) {
       try {
         var entries = fs.readdirSync(knowledgeDir);
         for (var ki = 0; ki < entries.length; ki++) {
+          if (entries[ki] === "session-digests.jsonl") continue;
+          if (entries[ki] === "sticky-notes.md") continue;
+          if (entries[ki] === "memory-summary.md") continue;
           if (entries[ki].endsWith(".md") || entries[ki].endsWith(".jsonl")) {
             var stat = fs.statSync(path.join(knowledgeDir, entries[ki]));
             files.push({ name: entries[ki], size: stat.size, mtime: stat.mtimeMs, common: false });
@@ -1559,6 +1592,56 @@ function createProjectContext(opts) {
       return;
     }
 
+    // --- Memory (session digests) management ---
+    if (msg.type === "memory_list") {
+      var digestFile = path.join(cwd, "knowledge", "session-digests.jsonl");
+      var summaryFile = path.join(cwd, "knowledge", "memory-summary.md");
+      var entries = [];
+      var summary = "";
+      try {
+        var raw = fs.readFileSync(digestFile, "utf8").trim();
+        if (raw) {
+          var lines = raw.split("\n");
+          for (var mi = 0; mi < lines.length; mi++) {
+            try {
+              var obj = JSON.parse(lines[mi]);
+              obj.index = mi;
+              entries.push(obj);
+            } catch (e) {}
+          }
+        }
+      } catch (e) { /* file may not exist */ }
+      try {
+        if (fs.existsSync(summaryFile)) {
+          summary = fs.readFileSync(summaryFile, "utf8").trim();
+        }
+      } catch (e) {}
+      // Return newest first
+      entries.reverse();
+      sendTo(ws, { type: "memory_list", entries: entries, summary: summary });
+      return;
+    }
+
+    if (msg.type === "memory_delete") {
+      if (typeof msg.index !== "number") return;
+      var digestFile = path.join(cwd, "knowledge", "session-digests.jsonl");
+      try {
+        var raw = fs.readFileSync(digestFile, "utf8").trim();
+        var lines = raw ? raw.split("\n") : [];
+        if (msg.index >= 0 && msg.index < lines.length) {
+          lines.splice(msg.index, 1);
+          if (lines.length === 0) {
+            fs.unlinkSync(digestFile);
+          } else {
+            fs.writeFileSync(digestFile, lines.join("\n") + "\n");
+          }
+        }
+      } catch (e) {}
+      sendTo(ws, { type: "memory_deleted", index: msg.index });
+      handleMessage(ws, { type: "memory_list" });
+      return;
+    }
+
     if (msg.type === "push_subscribe") {
       if (pushModule && msg.subscription) pushModule.addSubscription(msg.subscription, msg.replaceEndpoint);
       return;
@@ -1802,6 +1885,8 @@ function createProjectContext(opts) {
         if (v && isNewer(v, currentVersion)) {
           latestVersion = v;
           sendTo(ws, { type: "update_available", version: v });
+        } else {
+          sendTo(ws, { type: "up_to_date", version: currentVersion });
         }
       }).catch(function () {});
       return;
@@ -1908,11 +1993,6 @@ function createProjectContext(opts) {
     }
 
     if (msg.type === "set_permission_mode" && msg.mode) {
-      // When dangerouslySkipPermissions is active, don't allow UI to change mode
-      if (dangerouslySkipPermissions) {
-        send({ type: "config_state", model: sm.currentModel || "", mode: "bypassPermissions", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
-        return;
-      }
       sm.currentPermissionMode = msg.mode;
       var session = getSessionForWs(ws);
       if (session) {
@@ -1926,14 +2006,12 @@ function createProjectContext(opts) {
       if (typeof opts.onSetServerDefaultMode === "function") {
         opts.onSetServerDefaultMode(msg.mode);
       }
-      if (!dangerouslySkipPermissions) {
-        sm.currentPermissionMode = msg.mode;
-        var session = getSessionForWs(ws);
-        if (session) {
-          sdk.setPermissionMode(session, msg.mode);
-        }
-        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      sm.currentPermissionMode = msg.mode;
+      var session = getSessionForWs(ws);
+      if (session) {
+        sdk.setPermissionMode(session, msg.mode);
       }
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       return;
     }
 
@@ -1941,14 +2019,12 @@ function createProjectContext(opts) {
       if (typeof opts.onSetProjectDefaultMode === "function") {
         opts.onSetProjectDefaultMode(slug, msg.mode);
       }
-      if (!dangerouslySkipPermissions) {
-        sm.currentPermissionMode = msg.mode;
-        var session = getSessionForWs(ws);
-        if (session) {
-          sdk.setPermissionMode(session, msg.mode);
-        }
-        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      sm.currentPermissionMode = msg.mode;
+      var session = getSessionForWs(ws);
+      if (session) {
+        sdk.setPermissionMode(session, msg.mode);
       }
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       return;
     }
 
@@ -2127,7 +2203,7 @@ function createProjectContext(opts) {
       var pending = session.pendingAskUser[toolId];
       if (!pending) return;
       delete session.pendingAskUser[toolId];
-      sm.sendAndRecord(session, { type: "ask_user_answered", toolId: toolId });
+      sm.sendAndRecord(session, { type: "ask_user_answered", toolId: toolId, answers: answers });
       pending.resolve({
         behavior: "allow",
         updatedInput: Object.assign({}, pending.input, { answers: answers }),
@@ -2324,7 +2400,7 @@ function createProjectContext(opts) {
 
     // --- Browse directories (for add-project autocomplete) ---
     if (msg.type === "browse_dir") {
-      var rawPath = (msg.path || "").replace(/^~/, process.env.HOME || "/");
+      var rawPath = (msg.path || "").replace(/^~/, require("./config").REAL_HOME);
       var absTarget = path.resolve(rawPath);
       var parentDir, prefix;
       try {
@@ -2363,7 +2439,7 @@ function createProjectContext(opts) {
 
     // --- Add project from web UI ---
     if (msg.type === "add_project") {
-      var addPath = (msg.path || "").replace(/^~/, process.env.HOME || "/");
+      var addPath = (msg.path || "").replace(/^~/, require("./config").REAL_HOME);
       var addAbs = path.resolve(addPath);
       try {
         var addStat = fs.statSync(addAbs);
@@ -2545,7 +2621,7 @@ function createProjectContext(opts) {
 
     // --- Daemon config / server management (admin-only in multi-user mode) ---
     if (msg.type === "get_daemon_config" || msg.type === "set_pin" || msg.type === "set_keep_awake" ||
-        msg.type === "set_image_retention" || msg.type === "shutdown_server" || msg.type === "restart_server") {
+        msg.type === "set_auto_continue" || msg.type === "set_image_retention" || msg.type === "shutdown_server" || msg.type === "restart_server") {
       if (usersModule.isMultiUser()) {
         var _wsUser = ws._clayUser;
         if (!_wsUser || _wsUser.role !== "admin") {
@@ -2580,6 +2656,15 @@ function createProjectContext(opts) {
       return;
     }
 
+    if (msg.type === "set_auto_continue") {
+      if (typeof opts.onSetAutoContinue === "function") {
+        var acResult = opts.onSetAutoContinue(msg.value);
+        sendTo(ws, { type: "set_auto_continue_result", ok: acResult.ok, autoContinueOnRateLimit: acResult.autoContinueOnRateLimit });
+        send({ type: "auto_continue_changed", autoContinueOnRateLimit: acResult.autoContinueOnRateLimit });
+      }
+      return;
+    }
+
     if (msg.type === "set_image_retention") {
       if (typeof opts.onSetImageRetention === "function") {
         var irResult = opts.onSetImageRetention(msg.days);
@@ -2781,8 +2866,7 @@ function createProjectContext(opts) {
 
     // --- Global CLAUDE.md ---
     if (msg.type === "read_global_claude_md") {
-      var os = require("os");
-      var globalMdPath = path.join(os.homedir(), ".claude", "CLAUDE.md");
+      var globalMdPath = path.join(require("./config").REAL_HOME, ".claude", "CLAUDE.md");
       try {
         var globalMdContent = fs.readFileSync(globalMdPath, "utf8");
         sendTo(ws, { type: "global_claude_md_result", content: globalMdContent });
@@ -2793,8 +2877,7 @@ function createProjectContext(opts) {
     }
 
     if (msg.type === "write_global_claude_md") {
-      var os2 = require("os");
-      var globalMdDir = path.join(os2.homedir(), ".claude");
+      var globalMdDir = path.join(require("./config").REAL_HOME, ".claude");
       var globalMdWritePath = path.join(globalMdDir, "CLAUDE.md");
       try {
         if (!fs.existsSync(globalMdDir)) {
@@ -3037,22 +3120,53 @@ function createProjectContext(opts) {
     }
 
     // --- Sticky notes ---
+    function syncNotesKnowledge() {
+      if (!isMate) return;
+      try {
+        var knDir = path.join(cwd, "knowledge");
+        var knFile = path.join(knDir, "sticky-notes.md");
+        var text = nm.getActiveNotesText();
+        if (text) {
+          fs.mkdirSync(knDir, { recursive: true });
+          fs.writeFileSync(knFile, text);
+        } else {
+          try { fs.unlinkSync(knFile); } catch (e) {}
+        }
+      } catch (e) {
+        console.error("[project] Failed to sync sticky-notes.md:", e.message);
+      }
+    }
+
     if (msg.type === "note_create") {
       var note = nm.create(msg);
-      if (note) send({ type: "note_created", note: note });
+      if (note) {
+        send({ type: "note_created", note: note });
+        syncNotesKnowledge();
+      }
       return;
     }
 
     if (msg.type === "note_update") {
       if (!msg.id) return;
       var updated = nm.update(msg.id, msg);
-      if (updated) send({ type: "note_updated", note: updated });
+      if (updated) {
+        send({ type: "note_updated", note: updated });
+        if (msg.text !== undefined || msg.hidden !== undefined) syncNotesKnowledge();
+      }
       return;
     }
 
     if (msg.type === "note_delete") {
       if (!msg.id) return;
-      if (nm.remove(msg.id)) send({ type: "note_deleted", id: msg.id });
+      if (nm.remove(msg.id)) {
+        send({ type: "note_deleted", id: msg.id });
+        syncNotesKnowledge();
+      }
+      return;
+    }
+
+    if (msg.type === "note_list_request") {
+      sendTo(ws, { type: "notes_list", notes: nm.list() });
       return;
     }
 
@@ -3556,6 +3670,7 @@ function createProjectContext(opts) {
     }
 
     var userMsg = { type: "user_message", text: msg.text || "" };
+    var savedImagePaths = [];
     if (msg.images && msg.images.length > 0) {
       userMsg.imageCount = msg.images.length;
       // Save images as files, store URL references in history
@@ -3565,6 +3680,7 @@ function createProjectContext(opts) {
         var savedName = saveImageFile(img.mediaType, img.data);
         if (savedName) {
           imageRefs.push({ mediaType: img.mediaType, file: savedName });
+          savedImagePaths.push(path.join(imagesDir, savedName));
         }
       }
       if (imageRefs.length > 0) {
@@ -3593,6 +3709,11 @@ function createProjectContext(opts) {
     }
 
     var fullText = msg.text || "";
+    // Prepend saved image paths so Claude can copy/save them
+    if (savedImagePaths.length > 0) {
+      var imgPathLines = savedImagePaths.map(function (p) { return "[Uploaded image: " + p + "]"; }).join("\n");
+      fullText = imgPathLines + (fullText ? "\n" + fullText : "");
+    }
     if (msg.pastes && msg.pastes.length > 0) {
       for (var pi = 0; pi < msg.pastes.length; pi++) {
         if (fullText) fullText += "\n\n";
@@ -3719,63 +3840,226 @@ function createProjectContext(opts) {
     var mateDir = matesModule.getMateDir(mateCtx, mateId);
     var knowledgeDir = path.join(mateDir, "knowledge");
 
-    var digestPrompt = [
-      "[SYSTEM: Session Digest Request]",
-      "The conversation has ended. Summarize this session from YOUR perspective for your long-term memory.",
-      "Output ONLY a single valid JSON object (no markdown, no code fences, no extra text).",
-      "Schema:",
-      "{",
-      '  "date": "YYYY-MM-DD",',
-      '  "topic": "short topic description",',
-      '  "my_position": "what I said/recommended",',
-      '  "other_perspectives": "other mates or user perspectives if relevant",',
-      '  "decisions": "what was decided, or null if pending",',
-      '  "open_items": "what remains unresolved",',
-      '  "user_sentiment": "how the user seemed to feel about this topic"',
-      "}",
-      "",
-      "IMPORTANT: Output ONLY the JSON object. Nothing else.",
-    ].join("\n");
+    // Migration: generate initial summary if missing
+    var summaryFile = path.join(knowledgeDir, "memory-summary.md");
+    var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
+    if (!fs.existsSync(summaryFile) && fs.existsSync(digestFile)) {
+      initMemorySummary(mateCtx, mateId, function () {});
+    }
 
-    var digestText = "";
-    mentionSession.pushMessage(digestPrompt, {
-      onActivity: function () {},
-      onDelta: function (delta) {
-        digestText += delta;
-      },
-      onDone: function () {
-        var digestObj = null;
-        try {
-          var cleaned = digestText.trim();
-          if (cleaned.indexOf("```") === 0) {
-            cleaned = cleaned.replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "").trim();
+    // Build conversation content for gate check (500 char cap each side)
+    var userQ = userQuestion || "(unknown)";
+    var mateR = mateResponse || "(unknown)";
+    var conversationContent = "User: " + (userQ.length > 500 ? userQ.substring(0, 500) + "..." : userQ) +
+      "\nMate: " + (mateR.length > 500 ? mateR.substring(0, 500) + "..." : mateR);
+
+    // Gate check: ask Haiku if this is worth remembering
+    gateMemory(mateCtx, mateId, conversationContent, function (shouldRemember) {
+      if (!shouldRemember) {
+        console.log("[digest] Gate declined memory for mention, mate " + mateId);
+        return;
+      }
+
+      var digestPrompt = [
+        "[SYSTEM: Session Digest]",
+        "Summarize this conversation from YOUR perspective for your long-term memory.",
+        "Output ONLY a single valid JSON object (no markdown, no code fences, no extra text).",
+        "",
+        "Schema:",
+        "{",
+        '  "date": "YYYY-MM-DD",',
+        '  "type": "mention",',
+        '  "topic": "short topic description",',
+        '  "my_position": "what I said/recommended",',
+        '  "decisions": "what was decided, or null if pending",',
+        '  "open_items": "what remains unresolved",',
+        '  "user_sentiment": "how the user seemed to feel",',
+        '  "other_perspectives": "key points from others",',
+        '  "confidence": "high | medium | low",',
+        '  "revisit_later": true/false,',
+        '  "tags": ["relevant", "topic", "tags"]',
+        "}",
+        "",
+        "IMPORTANT: Output ONLY the JSON object. Nothing else.",
+      ].join("\n");
+
+      var digestText = "";
+      mentionSession.pushMessage(digestPrompt, {
+        onActivity: function () {},
+        onDelta: function (delta) {
+          digestText += delta;
+        },
+        onDone: function () {
+          var digestObj = null;
+          try {
+            var cleaned = digestText.trim();
+            if (cleaned.indexOf("```") === 0) {
+              cleaned = cleaned.replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "").trim();
+            }
+            digestObj = JSON.parse(cleaned);
+          } catch (e) {
+            console.error("[digest] Failed to parse digest JSON for mate " + mateId + ":", e.message);
+            digestObj = {
+              date: new Date().toISOString().slice(0, 10),
+              topic: "parse_failed",
+              raw: digestText.substring(0, 500),
+            };
           }
-          digestObj = JSON.parse(cleaned);
-        } catch (e) {
-          console.error("[digest] Failed to parse digest JSON for mate " + mateId + ":", e.message);
-          digestObj = {
-            date: new Date().toISOString().slice(0, 10),
-            topic: "parse_failed",
-            raw: digestText.substring(0, 500),
-          };
-        }
 
-        try {
-          fs.mkdirSync(knowledgeDir, { recursive: true });
-          var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
-          fs.appendFileSync(digestFile, JSON.stringify(digestObj) + "\n");
-        } catch (e) {
-          console.error("[digest] Failed to write digest for mate " + mateId + ":", e.message);
-        }
-      },
-      onError: function (err) {
-        console.error("[digest] Digest generation failed for mate " + mateId + ":", err);
-      },
+          try {
+            fs.mkdirSync(knowledgeDir, { recursive: true });
+            var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
+            fs.appendFileSync(digestFile, JSON.stringify(digestObj) + "\n");
+          } catch (e) {
+            console.error("[digest] Failed to write digest for mate " + mateId + ":", e.message);
+          }
+
+          // Update memory summary
+          updateMemorySummary(mateCtx, mateId, digestObj);
+        },
+        onError: function (err) {
+          console.error("[digest] Digest generation failed for mate " + mateId + ":", err);
+        },
+      });
+    });
+  }
+
+  // Digest DM turn for mate projects - uses Haiku gate + conditional digest + summary update
+  var _dmDigestPending = false;
+  function digestDmTurn(session, responsePreview) {
+    if (!isMate || _dmDigestPending) return;
+    var mateId = path.basename(cwd);
+    var mateCtx = matesModule.buildMateCtx(projectOwnerId);
+    if (!matesModule.isMate(mateCtx, mateId)) return;
+
+    // Extract last user message from history
+    var lastUserText = "";
+    for (var hi = session.history.length - 1; hi >= 0; hi--) {
+      var entry = session.history[hi];
+      if (entry.type === "user_message" && entry.text) {
+        lastUserText = entry.text;
+        break;
+      }
+    }
+
+    // Use responsePreview (full accumulated response) instead of delta fragments
+    var lastResponseText = responsePreview || "";
+    if (!lastUserText && !lastResponseText) return;
+
+    var mateDir = matesModule.getMateDir(mateCtx, mateId);
+    var knowledgeDir = path.join(mateDir, "knowledge");
+
+    // Migration: if memory-summary.md missing but digests exist, generate initial summary
+    var summaryFile = path.join(knowledgeDir, "memory-summary.md");
+    var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
+    if (!fs.existsSync(summaryFile) && fs.existsSync(digestFile)) {
+      initMemorySummary(mateCtx, mateId, function () {
+        console.log("[memory-migrate] Initial summary generated for mate " + mateId);
+      });
+    }
+
+    var conversationContent = "User: " + (lastUserText.length > 500 ? lastUserText.substring(0, 500) + "..." : lastUserText) +
+      "\nMate: " + (lastResponseText.length > 500 ? lastResponseText.substring(0, 500) + "..." : lastResponseText);
+
+    _dmDigestPending = true;
+
+    // Gate check: ask Haiku if this is worth remembering
+    gateMemory(mateCtx, mateId, conversationContent, function (shouldRemember) {
+      if (!shouldRemember) {
+        _dmDigestPending = false;
+        console.log("[dm-digest] Gate declined memory for DM, mate " + mateId);
+        return;
+      }
+
+      var digestContext = [
+        "[SYSTEM: Session Digest]",
+        "Summarize this conversation from YOUR perspective for your long-term memory.",
+        "",
+        conversationContent,
+      ].join("\n");
+
+      var digestPrompt = [
+        "Output ONLY a single valid JSON object (no markdown, no code fences, no extra text).",
+        "",
+        "Schema:",
+        "{",
+        '  "date": "YYYY-MM-DD",',
+        '  "type": "dm",',
+        '  "topic": "short topic description",',
+        '  "my_position": "what I said/recommended",',
+        '  "decisions": "what was decided, or null if pending",',
+        '  "open_items": "what remains unresolved",',
+        '  "user_sentiment": "how the user seemed to feel",',
+        '  "user_intent": "what the user wanted",',
+        '  "confidence": "high | medium | low",',
+        '  "revisit_later": true/false,',
+        '  "tags": ["relevant", "topic", "tags"]',
+        "}",
+        "",
+        "IMPORTANT: Output ONLY the JSON object. Nothing else.",
+      ].join("\n");
+
+      var digestText = "";
+      var _digestSession = null;
+      sdk.createMentionSession({
+        claudeMd: "",
+        model: "haiku",
+        initialContext: digestContext,
+        initialMessage: digestPrompt,
+        onActivity: function () {},
+        onDelta: function (delta) {
+          digestText += delta;
+        },
+        onDone: function () {
+          _dmDigestPending = false;
+          var digestObj = null;
+          try {
+            var cleaned = digestText.trim();
+            if (cleaned.indexOf("```") === 0) {
+              cleaned = cleaned.replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "").trim();
+            }
+            digestObj = JSON.parse(cleaned);
+          } catch (e) {
+            console.error("[dm-digest] Failed to parse digest JSON for mate " + mateId + ":", e.message);
+            digestObj = {
+              date: new Date().toISOString().slice(0, 10),
+              type: "dm",
+              topic: "parse_failed",
+              raw: digestText.substring(0, 500),
+            };
+          }
+
+          try {
+            fs.mkdirSync(knowledgeDir, { recursive: true });
+            var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
+            fs.appendFileSync(digestFile, JSON.stringify(digestObj) + "\n");
+          } catch (e) {
+            console.error("[dm-digest] Failed to write digest for mate " + mateId + ":", e.message);
+          }
+
+          // Update memory summary
+          updateMemorySummary(mateCtx, mateId, digestObj);
+
+          if (_digestSession) try { _digestSession.close(); } catch (e) {}
+        },
+        onError: function (err) {
+          _dmDigestPending = false;
+          console.error("[dm-digest] Digest generation failed for mate " + mateId + ":", err);
+          if (_digestSession) try { _digestSession.close(); } catch (e) {}
+        },
+      }).then(function (ds) {
+        _digestSession = ds;
+        if (!ds) _dmDigestPending = false;
+      }).catch(function (err) {
+        _dmDigestPending = false;
+        console.error("[dm-digest] Failed to create digest session for mate " + mateId + ":", err);
+      });
     });
   }
 
   function handleMention(ws, msg) {
-    if (!msg.mateId || !msg.text) return;
+    if (!msg.mateId) return;
+    if (!msg.text && (!msg.images || msg.images.length === 0) && (!msg.pastes || msg.pastes.length === 0)) return;
 
     var session = getSessionForWs(ws);
     if (!session) return;
@@ -3806,7 +4090,7 @@ function createProjectContext(opts) {
     var avatarSeed = (mate.profile && mate.profile.avatarSeed) || mate.id;
 
     // Build full mention text (include pasted content)
-    var mentionFullInput = msg.text;
+    var mentionFullInput = msg.text || "";
     if (msg.pastes && msg.pastes.length > 0) {
       for (var pi = 0; pi < msg.pastes.length; pi++) {
         if (mentionFullInput) mentionFullInput += "\n\n";
@@ -3814,12 +4098,25 @@ function createProjectContext(opts) {
       }
     }
 
+    // Save images to disk (same pattern as regular messages)
+    var imageRefs = [];
+    if (msg.images && msg.images.length > 0) {
+      for (var imgIdx = 0; imgIdx < msg.images.length; imgIdx++) {
+        var img = msg.images[imgIdx];
+        var savedName = saveImageFile(img.mediaType, img.data);
+        if (savedName) {
+          imageRefs.push({ mediaType: img.mediaType, file: savedName });
+        }
+      }
+    }
+
     // Save mention user message to session history
     var mentionUserEntry = { type: "mention_user", text: msg.text, mateId: msg.mateId, mateName: mateName };
     if (msg.pastes && msg.pastes.length > 0) mentionUserEntry.pastes = msg.pastes;
+    if (imageRefs.length > 0) mentionUserEntry.imageRefs = imageRefs;
     session.history.push(mentionUserEntry);
     sm.appendToSessionFile(session, mentionUserEntry);
-    sendToSessionOthers(ws, session.localId, mentionUserEntry);
+    sendToSessionOthers(ws, session.localId, hydrateImageRefs(mentionUserEntry));
 
     // Extract recent turns for continuity check
     var recentTurns = getRecentTurns(session, MENTION_WINDOW);
@@ -3912,7 +4209,7 @@ function createProjectContext(opts) {
       // Continue existing mention session with middle context
       var middleContext = buildMiddleContext(recentTurns, msg.mateId);
       var continuationText = middleContext ? middleContext + "\n\n" + mentionFullInput : mentionFullInput;
-      existingSession.pushMessage(continuationText, mentionCallbacks);
+      existingSession.pushMessage(continuationText, mentionCallbacks, msg.images);
     } else {
       // Clean up old session if it exists
       if (existingSession) {
@@ -3929,26 +4226,8 @@ function createProjectContext(opts) {
         // CLAUDE.md may not exist for new mates
       }
 
-      // Load recent session digests for context continuity
-      var recentDigests = "";
-      try {
-        var digestFile = path.join(mateDir, "knowledge", "session-digests.jsonl");
-        if (fs.existsSync(digestFile)) {
-          var allLines = fs.readFileSync(digestFile, "utf8").trim().split("\n");
-          var recent = allLines.slice(-5); // last 5 digests
-          if (recent.length > 0) {
-            recentDigests = "\n\nYour recent session memories (from past @mentions):\n";
-            for (var di = 0; di < recent.length; di++) {
-              try {
-                var d = JSON.parse(recent[di]);
-                recentDigests += "- [" + (d.date || "?") + "] " + (d.topic || "unknown") + ": " + (d.my_position || "") +
-                  (d.decisions ? " | Decisions: " + d.decisions : "") +
-                  (d.open_items ? " | Open: " + d.open_items : "") + "\n";
-              } catch (e) {}
-            }
-          }
-        }
-      } catch (e) {}
+      // Load session digests (unified: uses memory-summary.md if available)
+      var recentDigests = loadMateDigests(mateCtx, msg.mateId);
 
       // Build initial mention context
       var mentionContext = buildMentionContext(userName, recentTurns) + recentDigests;
@@ -3958,6 +4237,7 @@ function createProjectContext(opts) {
         claudeMd: claudeMd,
         initialContext: mentionContext,
         initialMessage: mentionFullInput,
+        initialImages: msg.images || null,
         onActivity: mentionCallbacks.onActivity,
         onDelta: mentionCallbacks.onDelta,
         onDone: mentionCallbacks.onDone,
@@ -4035,11 +4315,17 @@ function createProjectContext(opts) {
     // Sort by length descending to match longest name first
     names.sort(function (a, b) { return b.length - a.length; });
     var mentioned = [];
+    // Strip markdown inline formatting so **@Name**, ~~@Name~~, `@Name`, [@Name](url) etc. still match
+    var cleaned = text
+      .replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")   // [text](url) -> text
+      .replace(/`([^`]*)`/g, "$1")                // `code` -> code
+      .replace(/(\*{1,3}|_{1,3}|~{2})/g, "");    // bold, italic, strikethrough markers
     console.log("[debate-mention] nameMap keys:", JSON.stringify(names));
-    console.log("[debate-mention] text snippet:", text.slice(0, 200));
+    console.log("[debate-mention] text snippet:", cleaned.slice(0, 200));
     for (var i = 0; i < names.length; i++) {
-      var pattern = new RegExp("@" + escapeRegex(names[i]) + "(?=[\\s,.:;!?()\\]}>\"']|$)", "i");
-      var matched = pattern.test(text);
+      // Match @Name followed by any non-name character (not alphanumeric, not Korean, not dash/underscore)
+      var pattern = new RegExp("@" + escapeRegex(names[i]) + "(?![\\p{L}\\p{N}_-])", "iu");
+      var matched = pattern.test(cleaned);
       console.log("[debate-mention] testing @" + names[i] + " pattern=" + pattern.toString() + " matched=" + matched);
       if (matched) {
         var mateId = nameMap[names[i]];
@@ -4071,27 +4357,369 @@ function createProjectContext(opts) {
     }
   }
 
+  function formatRawDigests(rawLines, headerLabel) {
+    if (!rawLines || rawLines.length === 0) return "";
+    var lines = ["\n\n" + (headerLabel || "Your recent session memories:")];
+    for (var i = 0; i < rawLines.length; i++) {
+      try {
+        var d = JSON.parse(rawLines[i]);
+        if (d.type === "debate" && d.my_role) {
+          // Debate memories are role-played positions, not genuine opinions
+          lines.push("- [" + (d.date || "?") + "] DEBATE (role: " + d.my_role + ") " + (d.topic || "unknown") +
+            ": argued " + (d.my_position || "N/A") + " (assigned role, not my actual opinion)" +
+            (d.outcome ? " | Outcome: " + d.outcome : "") +
+            (d.open_items ? " | Open: " + d.open_items : ""));
+        } else {
+          lines.push("- [" + (d.date || "?") + "] " + (d.topic || "unknown") + ": " + (d.my_position || "") +
+            (d.decisions ? " | Decisions: " + d.decisions : "") +
+            (d.open_items ? " | Open: " + d.open_items : ""));
+        }
+      } catch (e) {}
+    }
+    return lines.join("\n");
+  }
+
   function loadMateDigests(mateCtx, mateId) {
     var mateDir = matesModule.getMateDir(mateCtx, mateId);
+    var knowledgeDir = path.join(mateDir, "knowledge");
+
+    // Check for memory-summary.md first
+    var summaryFile = path.join(knowledgeDir, "memory-summary.md");
+    var hasSummary = false;
+    var summaryContent = "";
     try {
-      var digestFile = path.join(mateDir, "knowledge", "session-digests.jsonl");
-      if (!fs.existsSync(digestFile)) return "";
-      var allLines = fs.readFileSync(digestFile, "utf8").trim().split("\n");
+      if (fs.existsSync(summaryFile)) {
+        summaryContent = fs.readFileSync(summaryFile, "utf8").trim();
+        if (summaryContent) hasSummary = true;
+      }
+    } catch (e) {}
+
+    // Load raw digests
+    var allLines = [];
+    try {
+      var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
+      if (fs.existsSync(digestFile)) {
+        allLines = fs.readFileSync(digestFile, "utf8").trim().split("\n").filter(function (l) { return l.trim(); });
+      }
+    } catch (e) {}
+
+    if (hasSummary) {
+      // Load summary + latest 3 raw digests
+      var recent = allLines.slice(-3);
+      var result = "\n\nYour memory summary:\n" + summaryContent;
+      if (recent.length > 0) {
+        result += formatRawDigests(recent, "Latest raw session memories:");
+      }
+      return result;
+    } else {
+      // Backward compatible: latest 5 raw digests
       var recent = allLines.slice(-5);
-      if (recent.length === 0) return "";
-      var lines = ["\n\nYour recent session memories:"];
-      for (var i = 0; i < recent.length; i++) {
+      return formatRawDigests(recent, "Your recent session memories:");
+    }
+  }
+
+  // Gate check: ask Haiku whether this conversation contains anything worth remembering
+  function gateMemory(mateCtx, mateId, conversationContent, callback, opts) {
+    opts = opts || {};
+    var mateDir = matesModule.getMateDir(mateCtx, mateId);
+    var knowledgeDir = path.join(mateDir, "knowledge");
+
+    // Load mate role/activities from mate.yaml (lightweight, no full CLAUDE.md)
+    var mateRole = "";
+    var mateActivities = "";
+    try {
+      var yamlRaw = fs.readFileSync(path.join(mateDir, "mate.yaml"), "utf8");
+      var roleMatch = yamlRaw.match(/^relationship:\s*(.+)$/m);
+      var actMatch = yamlRaw.match(/^activities:\s*(.+)$/m);
+      if (roleMatch) mateRole = roleMatch[1].trim();
+      if (actMatch) mateActivities = actMatch[1].trim();
+    } catch (e) {}
+
+    // Load existing memory summary if available
+    var summaryContent = "";
+    try {
+      var summaryFile = path.join(knowledgeDir, "memory-summary.md");
+      if (fs.existsSync(summaryFile)) {
+        summaryContent = fs.readFileSync(summaryFile, "utf8").trim();
+      }
+    } catch (e) {}
+
+    // Cap conversation content for gate (500 chars each side)
+    var cappedContent = conversationContent;
+    if (cappedContent.length > 1200) {
+      cappedContent = cappedContent.substring(0, 1200) + "...";
+    }
+
+    var gateContext = [
+      "[SYSTEM: Memory Gate]",
+      "You are a memory filter for an AI Mate.",
+      "",
+      "Mate role: " + (mateRole || "assistant"),
+      "Mate activities: " + (mateActivities || "general"),
+      "",
+      "Current memory summary:",
+      summaryContent || "No memory summary yet.",
+      "",
+      "Conversation just ended:",
+      cappedContent,
+    ].join("\n");
+
+    var gatePrompt = opts.gatePrompt || [
+      'Should this conversation be saved to long-term memory?',
+      'Answer "yes" ONLY if there is:',
+      "- A new decision or commitment",
+      "- A change in position or strategy",
+      "- New information relevant to this Mate's role",
+      "- A user preference or pattern not already in the summary",
+      "",
+      'Answer "no" if:',
+      "- It duplicates what is already in the memory summary",
+      "- It is casual/trivial conversation",
+      "- It is not relevant to this Mate's role",
+      "",
+      'Answer with ONLY "yes" or "no". Nothing else.',
+    ].join("\n");
+    var defaultOnError = !!opts.defaultYes;
+
+    var gateText = "";
+    var _gateSession = null;
+    sdk.createMentionSession({
+      claudeMd: "",
+      model: "haiku",
+      initialContext: gateContext,
+      initialMessage: gatePrompt,
+      onActivity: function () {},
+      onDelta: function (delta) {
+        gateText += delta;
+      },
+      onDone: function () {
+        var answer = gateText.trim().toLowerCase();
+        var shouldRemember = answer.indexOf("yes") !== -1;
+        if (_gateSession) try { _gateSession.close(); } catch (e) {}
+        callback(shouldRemember);
+      },
+      onError: function (err) {
+        console.error("[memory-gate] Gate check failed for mate " + mateId + ":", err);
+        if (_gateSession) try { _gateSession.close(); } catch (e) {}
+        callback(defaultOnError);
+      },
+    }).then(function (gs) {
+      _gateSession = gs;
+      if (!gs) callback(defaultOnError);
+    }).catch(function (err) {
+      console.error("[memory-gate] Failed to create gate session for mate " + mateId + ":", err);
+      callback(defaultOnError);
+    });
+  }
+
+  // Update (or create) memory-summary.md based on a new digest
+  function updateMemorySummary(mateCtx, mateId, digestObj) {
+    var mateDir = matesModule.getMateDir(mateCtx, mateId);
+    var knowledgeDir = path.join(mateDir, "knowledge");
+    var summaryFile = path.join(knowledgeDir, "memory-summary.md");
+
+    // Check if summary exists; if not, try initial generation first
+    var summaryExists = false;
+    var summaryContent = "";
+    try {
+      if (fs.existsSync(summaryFile)) {
+        summaryContent = fs.readFileSync(summaryFile, "utf8").trim();
+        if (summaryContent) summaryExists = true;
+      }
+    } catch (e) {}
+
+    if (!summaryExists) {
+      // Try initial summary generation from existing digests (migration)
+      initMemorySummary(mateCtx, mateId, function () {
+        // After init, do incremental update with the new digest
+        doIncrementalUpdate(mateCtx, mateId, knowledgeDir, summaryFile, digestObj);
+      });
+    } else {
+      doIncrementalUpdate(mateCtx, mateId, knowledgeDir, summaryFile, digestObj);
+    }
+  }
+
+  // Incremental update of memory-summary.md with a single new digest
+  function doIncrementalUpdate(mateCtx, mateId, knowledgeDir, summaryFile, digestObj) {
+    var existingSummary = "";
+    try {
+      if (fs.existsSync(summaryFile)) {
+        existingSummary = fs.readFileSync(summaryFile, "utf8").trim();
+      }
+    } catch (e) {}
+
+    var updateContext = [
+      "[SYSTEM: Memory Summary Update]",
+      "You are updating an AI Mate's long-term memory summary.",
+      "",
+      "Current summary:",
+      existingSummary || "(empty, this is the first entry)",
+      "",
+      "New session digest to incorporate:",
+      JSON.stringify(digestObj, null, 2),
+    ].join("\n");
+
+    var updatePrompt = [
+      "Update the summary by:",
+      "1. Adding new information from this session",
+      "2. Updating existing entries if positions changed",
+      "3. Moving resolved open threads out of \"Open Threads\"",
+      "4. Adding to \"My Track Record\" if a past prediction/recommendation can now be evaluated",
+      "5. Removing outdated or redundant information",
+      "",
+      "Maintain this structure:",
+      "",
+      "# Memory Summary",
+      "Last updated: YYYY-MM-DD (session count: N+1)",
+      "",
+      "## User Patterns",
+      "## Key Decisions",
+      "## My Track Record",
+      "## Open Threads",
+      "## Recurring Topics",
+      "",
+      "Keep it concise. Each section should have at most 10 bullet points.",
+      "Drop the oldest/least relevant if needed.",
+      "Output ONLY the updated markdown. Nothing else.",
+    ].join("\n");
+
+    var updateText = "";
+    var _updateSession = null;
+    sdk.createMentionSession({
+      claudeMd: "",
+      model: "haiku",
+      initialContext: updateContext,
+      initialMessage: updatePrompt,
+      onActivity: function () {},
+      onDelta: function (delta) {
+        updateText += delta;
+      },
+      onDone: function () {
         try {
-          var d = JSON.parse(recent[i]);
-          lines.push("- [" + (d.date || "?") + "] " + (d.topic || "unknown") + ": " + (d.my_position || "") +
-            (d.decisions ? " | Decisions: " + d.decisions : "") +
-            (d.open_items ? " | Open: " + d.open_items : "") );
-        } catch (e) {}
+          var cleaned = updateText.trim();
+          if (cleaned.indexOf("```") === 0) {
+            cleaned = cleaned.replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "").trim();
+          }
+          fs.mkdirSync(knowledgeDir, { recursive: true });
+          fs.writeFileSync(summaryFile, cleaned + "\n", "utf8");
+          console.log("[memory-summary] Updated memory-summary.md for mate " + mateId);
+        } catch (e) {
+          console.error("[memory-summary] Failed to write memory-summary.md for mate " + mateId + ":", e.message);
+        }
+        if (_updateSession) try { _updateSession.close(); } catch (e) {}
+      },
+      onError: function (err) {
+        console.error("[memory-summary] Summary update failed for mate " + mateId + ":", err);
+        if (_updateSession) try { _updateSession.close(); } catch (e) {}
+      },
+    }).then(function (us) {
+      _updateSession = us;
+    }).catch(function (err) {
+      console.error("[memory-summary] Failed to create summary update session for mate " + mateId + ":", err);
+    });
+  }
+
+  // Initial summary generation (migration): read latest 20 digests and generate first summary
+  function initMemorySummary(mateCtx, mateId, callback) {
+    var mateDir = matesModule.getMateDir(mateCtx, mateId);
+    var knowledgeDir = path.join(mateDir, "knowledge");
+    var summaryFile = path.join(knowledgeDir, "memory-summary.md");
+    var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
+
+    // Check if digests exist
+    var allLines = [];
+    try {
+      if (fs.existsSync(digestFile)) {
+        allLines = fs.readFileSync(digestFile, "utf8").trim().split("\n").filter(function (l) { return l.trim(); });
       }
-      return lines.join("\n");
-    } catch (e) {
-      return "";
+    } catch (e) {}
+
+    if (allLines.length === 0) {
+      // No digests to summarize, just callback
+      callback();
+      return;
+    }
+
+    var recent = allLines.slice(-20);
+    var digestsText = [];
+    for (var i = 0; i < recent.length; i++) {
+      try {
+        var d = JSON.parse(recent[i]);
+        digestsText.push(JSON.stringify(d));
+      } catch (e) {}
+    }
+
+    if (digestsText.length === 0) {
+      callback();
+      return;
     }
+
+    var initContext = [
+      "[SYSTEM: Initial Memory Summary]",
+      "You are creating the first long-term memory summary for an AI Mate.",
+      "",
+      "Here are the most recent session digests (up to 20):",
+      digestsText.join("\n"),
+    ].join("\n");
+
+    var initPrompt = [
+      "Create a memory summary from these sessions.",
+      "",
+      "Structure:",
+      "",
+      "# Memory Summary",
+      "Last updated: YYYY-MM-DD (session count: N)",
+      "",
+      "## User Patterns",
+      "## Key Decisions",
+      "## My Track Record",
+      "## Open Threads",
+      "## Recurring Topics",
+      "",
+      "Keep it concise. Focus on patterns and decisions, not individual session details.",
+      "Each section should have at most 10 bullet points.",
+      "Set session count to " + digestsText.length + ".",
+      "Output ONLY the markdown. Nothing else.",
+    ].join("\n");
+
+    var initText = "";
+    var _initSession = null;
+    sdk.createMentionSession({
+      claudeMd: "",
+      model: "haiku",
+      initialContext: initContext,
+      initialMessage: initPrompt,
+      onActivity: function () {},
+      onDelta: function (delta) {
+        initText += delta;
+      },
+      onDone: function () {
+        try {
+          var cleaned = initText.trim();
+          if (cleaned.indexOf("```") === 0) {
+            cleaned = cleaned.replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "").trim();
+          }
+          fs.mkdirSync(knowledgeDir, { recursive: true });
+          fs.writeFileSync(summaryFile, cleaned + "\n", "utf8");
+          console.log("[memory-summary] Generated initial memory-summary.md for mate " + mateId + " from " + digestsText.length + " digests");
+        } catch (e) {
+          console.error("[memory-summary] Failed to write initial memory-summary.md for mate " + mateId + ":", e.message);
+        }
+        if (_initSession) try { _initSession.close(); } catch (e) {}
+        callback();
+      },
+      onError: function (err) {
+        console.error("[memory-summary] Initial summary generation failed for mate " + mateId + ":", err);
+        if (_initSession) try { _initSession.close(); } catch (e) {}
+        callback();
+      },
+    }).then(function (is) {
+      _initSession = is;
+      if (!is) callback();
+    }).catch(function (err) {
+      console.error("[memory-summary] Failed to create init summary session for mate " + mateId + ":", err);
+      callback();
+    });
   }
 
   function buildModeratorContext(debate) {
@@ -4372,7 +5000,11 @@ function createProjectContext(opts) {
         if (h.type === "debate_conclude_confirm") hasConclude = true;
         if (h.type === "debate_turn_done" && h.role === "moderator") lastModText = h.text || "";
       }
-      if (!hasEnded && !hasConclude && lastModText !== null) {
+      // conclude_confirm in history without a subsequent ended = still awaiting user decision
+      if (hasConclude && !hasEnded) {
+        debate.awaitingConcludeConfirm = true;
+      } else if (!hasEnded && !hasConclude && lastModText !== null) {
+        // No explicit entry yet; infer from last moderator text having no @mentions
         var mentions = detectMentions(lastModText, debate.nameMap);
         if (mentions.length === 0) {
           debate.awaitingConcludeConfirm = true;
@@ -4646,6 +5278,7 @@ function createProjectContext(opts) {
       console.log("[debate] No mentions detected, requesting user confirmation to end.");
       debate.turnInProgress = false;
       debate.awaitingConcludeConfirm = true;
+      persistDebateState(session);
       var concludeEntry = { type: "debate_conclude_confirm", topic: debate.topic, round: debate.round };
       session.history.push(concludeEntry);
       sm.appendToSessionFile(session, concludeEntry);
@@ -5254,68 +5887,86 @@ function createProjectContext(opts) {
     var mateDir = matesModule.getMateDir(debate.mateCtx, mateId);
     var knowledgeDir = path.join(mateDir, "knowledge");
 
-    var digestPrompt = [
-      "[SYSTEM: Debate Session Digest Request]",
-      "The debate has ended. Summarize this debate from YOUR perspective for your long-term memory.",
-      "Topic: " + debate.topic,
-      "Your role: " + role,
-      "Output ONLY a single valid JSON object (no markdown, no code fences, no extra text).",
-      "Schema:",
-      "{",
-      '  "date": "YYYY-MM-DD",',
-      '  "type": "debate",',
-      '  "topic": "the debate topic",',
-      '  "my_role": "your role in the debate",',
-      '  "my_position": "what you argued/said",',
-      '  "other_perspectives": "key points from other participants",',
-      '  "outcome": "how the debate concluded",',
-      '  "open_items": "unresolved points"',
-      "}",
-      "",
-      "IMPORTANT: Output ONLY the JSON object. Nothing else.",
-    ].join("\n");
+    // Migration: generate initial summary if missing
+    var summaryFile = path.join(knowledgeDir, "memory-summary.md");
+    var digestFileCheck = path.join(knowledgeDir, "session-digests.jsonl");
+    if (!fs.existsSync(summaryFile) && fs.existsSync(digestFileCheck)) {
+      initMemorySummary(debate.mateCtx, mateId, function () {});
+    }
+
+    // Debates are user-initiated structured events. The moderator already
+    // synthesizes a summary, so skip the memory gate and always create a digest.
+    (function () {
+      var digestPrompt = [
+        "[SYSTEM: Session Digest]",
+        "Summarize this conversation from YOUR perspective for your long-term memory.",
+        "Output ONLY a single valid JSON object (no markdown, no code fences, no extra text).",
+        "",
+        "Schema:",
+        "{",
+        '  "date": "YYYY-MM-DD",',
+        '  "type": "debate",',
+        '  "topic": "short topic description",',
+        '  "my_position": "what I said/recommended",',
+        '  "decisions": "what was decided, or null if pending",',
+        '  "open_items": "what remains unresolved",',
+        '  "user_sentiment": "how the user seemed to feel",',
+        '  "my_role": "' + role + '",',
+        '  "other_perspectives": "key points from others",',
+        '  "outcome": "how the debate concluded",',
+        '  "confidence": "high | medium | low",',
+        '  "revisit_later": true/false,',
+        '  "tags": ["relevant", "topic", "tags"]',
+        "}",
+        "",
+        "IMPORTANT: Output ONLY the JSON object. Nothing else.",
+      ].join("\n");
+
+      var digestText = "";
+      mentionSession.pushMessage(digestPrompt, {
+        onActivity: function () {},
+        onDelta: function (delta) {
+          digestText += delta;
+        },
+        onDone: function () {
+          var digestObj = null;
+          try {
+            var cleaned = digestText.trim();
+            if (cleaned.indexOf("```") === 0) {
+              cleaned = cleaned.replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "").trim();
+            }
+            digestObj = JSON.parse(cleaned);
+          } catch (e) {
+            console.error("[debate-digest] Failed to parse digest JSON for mate " + mateId + ":", e.message);
+            digestObj = {
+              date: new Date().toISOString().slice(0, 10),
+              type: "debate",
+              topic: debate.topic,
+              my_role: role,
+              raw: digestText.substring(0, 500),
+            };
+          }
 
-    var digestText = "";
-    mentionSession.pushMessage(digestPrompt, {
-      onActivity: function () {},
-      onDelta: function (delta) {
-        digestText += delta;
-      },
-      onDone: function () {
-        var digestObj = null;
-        try {
-          var cleaned = digestText.trim();
-          if (cleaned.indexOf("```") === 0) {
-            cleaned = cleaned.replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "").trim();
+          try {
+            fs.mkdirSync(knowledgeDir, { recursive: true });
+            var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
+            fs.appendFileSync(digestFile, JSON.stringify(digestObj) + "\n");
+          } catch (e) {
+            console.error("[debate-digest] Failed to write digest for mate " + mateId + ":", e.message);
           }
-          digestObj = JSON.parse(cleaned);
-        } catch (e) {
-          console.error("[debate-digest] Failed to parse digest JSON for mate " + mateId + ":", e.message);
-          digestObj = {
-            date: new Date().toISOString().slice(0, 10),
-            type: "debate",
-            topic: debate.topic,
-            my_role: role,
-            raw: digestText.substring(0, 500),
-          };
-        }
 
-        try {
-          fs.mkdirSync(knowledgeDir, { recursive: true });
-          var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
-          fs.appendFileSync(digestFile, JSON.stringify(digestObj) + "\n");
-        } catch (e) {
-          console.error("[debate-digest] Failed to write digest for mate " + mateId + ":", e.message);
-        }
+          // Update memory summary
+          updateMemorySummary(debate.mateCtx, mateId, digestObj);
 
-        // Close the session after digest
-        mentionSession.close();
-      },
-      onError: function (err) {
-        console.error("[debate-digest] Digest generation failed for mate " + mateId + ":", err);
-        mentionSession.close();
-      },
-    });
+          // Close the session after digest
+          mentionSession.close();
+        },
+        onError: function (err) {
+          console.error("[debate-digest] Digest generation failed for mate " + mateId + ":", err);
+          mentionSession.close();
+        },
+      });
+    })();
   }
 
   // --- Session presence (who is viewing which session) ---
@@ -5568,7 +6219,7 @@ function createProjectContext(opts) {
           return;
         }
         var skillUserInfo = getOsUserInfoForReq(req);
-        var spawnCwd = scope === "global" ? (skillUserInfo ? skillUserInfo.home : os.homedir()) : cwd;
+        var spawnCwd = scope === "global" ? (skillUserInfo ? skillUserInfo.home : require("./config").REAL_HOME) : cwd;
         var scopeFlag = scope === "global" ? "--global" : "--project";
         var skillSpawnOpts = {
           cwd: spawnCwd,
@@ -5658,7 +6309,7 @@ function createProjectContext(opts) {
           return;
         }
         var uninstallUserInfo = getOsUserInfoForReq(req);
-        var baseDir = scope === "global" ? (uninstallUserInfo ? uninstallUserInfo.home : os.homedir()) : cwd;
+        var baseDir = scope === "global" ? (uninstallUserInfo ? uninstallUserInfo.home : require("./config").REAL_HOME) : cwd;
         var skillDir = path.join(baseDir, ".claude", "skills", skill);
         // Safety: ensure skillDir is inside the expected .claude/skills directory
         var expectedParent = path.join(baseDir, ".claude", "skills");
@@ -5709,7 +6360,7 @@ function createProjectContext(opts) {
     // Installed skills (global + project)
     if (req.method === "GET" && urlPath === "/api/installed-skills") {
       var installed = {};
-      var globalDir = path.join(os.homedir(), ".claude", "skills");
+      var globalDir = path.join(require("./config").REAL_HOME, ".claude", "skills");
       var projectDir = path.join(cwd, ".claude", "skills");
       var scanDirs = [
         { dir: globalDir, scope: "global" },
@@ -5763,7 +6414,7 @@ function createProjectContext(opts) {
           return;
         }
         // Read installed versions
-        var globalSkillsDir = path.join(os.homedir(), ".claude", "skills");
+        var globalSkillsDir = path.join(require("./config").REAL_HOME, ".claude", "skills");
         var projectSkillsDir = path.join(cwd, ".claude", "skills");
         var results = [];
         var pending = skills.length;
@@ -5992,6 +6643,7 @@ function createProjectContext(opts) {
     };
     if (isMate) {
       status.isMate = true;
+      status.mateId = path.basename(cwd);
     }
     if (worktreeMeta) {
       status.isWorktree = true;
@@ -6037,7 +6689,20 @@ function createProjectContext(opts) {
     // Enforce immediately on startup
     try { matesModule.enforceTeamAwareness(claudeMdPath); } catch (e) {}
     try { matesModule.enforceSessionMemory(claudeMdPath); } catch (e) {}
+    try { matesModule.enforceStickyNotes(claudeMdPath); } catch (e) {}
     try { crisisSafety.enforce(claudeMdPath); } catch (e) {}
+    // Sync sticky notes knowledge file on startup
+    try {
+      var knDir = path.join(cwd, "knowledge");
+      var knFile = path.join(knDir, "sticky-notes.md");
+      var notesText = nm.getActiveNotesText();
+      if (notesText) {
+        fs.mkdirSync(knDir, { recursive: true });
+        fs.writeFileSync(knFile, notesText);
+      } else {
+        try { fs.unlinkSync(knFile); } catch (e) {}
+      }
+    } catch (e) {}
     // Watch for changes
     try {
       crisisWatcher = fs.watch(claudeMdPath, function () {
@@ -6046,6 +6711,7 @@ function createProjectContext(opts) {
           crisisDebounce = null;
           try { matesModule.enforceTeamAwareness(claudeMdPath); } catch (e) {}
           try { matesModule.enforceSessionMemory(claudeMdPath); } catch (e) {}
+          try { matesModule.enforceStickyNotes(claudeMdPath); } catch (e) {}
           try { crisisSafety.enforce(claudeMdPath); } catch (e) {}
         }, 500);
       });