clay-server 2.17.0 → 2.18.0-beta.10

package/lib/daemon.js

@@ -979,7 +979,7 @@ if (usersModule.isMultiUser()) {
       var mateName = (m.profile && m.profile.displayName) || m.name || "New Mate";
       if (fs.existsSync(mateDir)) {
         console.log("[daemon] Adding mate project:", mateSlug);
-        relay.addProject(mateDir, mateSlug, mateName, null, m.createdBy, null, { isMate: true });
+        relay.addProject(mateDir, mateSlug, mateName, null, m.createdBy, null, { isMate: true, mateDisplayName: mateName });
       }
     }
   }
@@ -994,7 +994,7 @@ if (usersModule.isMultiUser()) {
     var mateName = (m.profile && m.profile.displayName) || m.name || "New Mate";
     if (fs.existsSync(mateDir)) {
       console.log("[daemon] Adding mate project:", mateSlug);
-      relay.addProject(mateDir, mateSlug, mateName, null, m.createdBy, null, { isMate: true });
+      relay.addProject(mateDir, mateSlug, mateName, null, m.createdBy, null, { isMate: true, mateDisplayName: mateName });
     }
   }
 }

package/lib/mates.js

@@ -135,6 +135,7 @@ function createMate(ctx, seedData) {
   }
   claudeMd += "- Autonomy: " + (seedData.autonomy || "always_ask") + "\n";
   claudeMd += TEAM_SECTION;
+  claudeMd += SESSION_MEMORY_SECTION;
   claudeMd += crisisSafety.getSection();
   fs.writeFileSync(path.join(mateDir, "CLAUDE.md"), claudeMd);
 
@@ -299,28 +300,104 @@ function enforceTeamAwareness(filePath) {
   // Check if already present and correct
   var teamIdx = content.indexOf(TEAM_MARKER);
   if (teamIdx !== -1) {
-    // Extract existing team section (up to next system marker or ## heading)
+    // Extract existing team section (up to next system marker or end)
     var afterTeam = content.substring(teamIdx);
+    // Find the nearest following system marker (session memory or crisis safety)
+    var nextMarkerIdx = -1;
+    var memIdx = afterTeam.indexOf(SESSION_MEMORY_MARKER);
     var crisisIdx = afterTeam.indexOf(crisisSafety.MARKER);
+    if (memIdx !== -1 && (crisisIdx === -1 || memIdx < crisisIdx)) {
+      nextMarkerIdx = memIdx;
+    } else if (crisisIdx !== -1) {
+      nextMarkerIdx = crisisIdx;
+    }
     var existing;
-    if (crisisIdx !== -1) {
-      existing = afterTeam.substring(0, crisisIdx).trimEnd();
+    if (nextMarkerIdx !== -1) {
+      existing = afterTeam.substring(0, nextMarkerIdx).trimEnd();
     } else {
       existing = afterTeam.trimEnd();
     }
     if (existing === TEAM_SECTION.trimStart().trimEnd()) return false; // already correct
 
     // Strip the existing team section
-    var endOfTeam = crisisIdx !== -1 ? teamIdx + crisisIdx : content.length;
+    var endOfTeam = nextMarkerIdx !== -1 ? teamIdx + nextMarkerIdx : content.length;
     content = content.substring(0, teamIdx).trimEnd() + content.substring(endOfTeam);
   }
 
+  // Insert before session memory or crisis safety section if present, otherwise append
+  var sessionMemPos = content.indexOf(SESSION_MEMORY_MARKER);
+  var crisisPos = content.indexOf(crisisSafety.MARKER);
+  var insertBefore = -1;
+  if (sessionMemPos !== -1) {
+    insertBefore = sessionMemPos;
+  } else if (crisisPos !== -1) {
+    insertBefore = crisisPos;
+  }
+  if (insertBefore !== -1) {
+    content = content.substring(0, insertBefore).trimEnd() + TEAM_SECTION + "\n\n" + content.substring(insertBefore);
+  } else {
+    content = content.trimEnd() + TEAM_SECTION;
+  }
+
+  fs.writeFileSync(filePath, content, "utf8");
+  return true;
+}
+
+// --- Session memory ---
+
+var SESSION_MEMORY_MARKER = "<!-- SESSION_MEMORY_MANAGED_BY_SYSTEM -->";
+
+var SESSION_MEMORY_SECTION =
+  "\n\n" + SESSION_MEMORY_MARKER + "\n" +
+  "## Session Memory\n\n" +
+  "**This section is managed by the system and cannot be removed.**\n\n" +
+  "Your `knowledge/session-digests.jsonl` file may contain summaries of your participation " +
+  "in project sessions via @mentions. Each line is a JSON object recording your perspective " +
+  "from that session, including your positions, disagreements with other mates, decisions made, " +
+  "and open items.\n\n" +
+  "When a user references a previous conversation, asks what you discussed before, or when " +
+  "continuity with a past session is relevant, read this file to recall context. " +
+  "Do not read this file proactively on every conversation start.\n";
+
+function hasSessionMemory(content) {
+  return content.indexOf(SESSION_MEMORY_MARKER) !== -1;
+}
+
+/**
+ * Enforce the session memory section on a mate's CLAUDE.md.
+ * Inserts after team awareness section and before crisis safety section.
+ * Returns true if the file was modified.
+ */
+function enforceSessionMemory(filePath) {
+  if (!fs.existsSync(filePath)) return false;
+
+  var content = fs.readFileSync(filePath, "utf8");
+
+  // Check if already present and correct
+  var memIdx = content.indexOf(SESSION_MEMORY_MARKER);
+  if (memIdx !== -1) {
+    // Extract existing section (up to next system marker or end)
+    var afterMem = content.substring(memIdx);
+    var crisisIdx = afterMem.indexOf(crisisSafety.MARKER);
+    var existing;
+    if (crisisIdx !== -1) {
+      existing = afterMem.substring(0, crisisIdx).trimEnd();
+    } else {
+      existing = afterMem.trimEnd();
+    }
+    if (existing === SESSION_MEMORY_SECTION.trimStart().trimEnd()) return false; // already correct
+
+    // Strip the existing session memory section
+    var endOfMem = crisisIdx !== -1 ? memIdx + crisisIdx : content.length;
+    content = content.substring(0, memIdx).trimEnd() + content.substring(endOfMem);
+  }
+
   // Insert before crisis safety section if present, otherwise append
   var crisisPos = content.indexOf(crisisSafety.MARKER);
   if (crisisPos !== -1) {
-    content = content.substring(0, crisisPos).trimEnd() + TEAM_SECTION + "\n\n" + content.substring(crisisPos);
+    content = content.substring(0, crisisPos).trimEnd() + SESSION_MEMORY_SECTION + "\n\n" + content.substring(crisisPos);
   } else {
-    content = content.trimEnd() + TEAM_SECTION;
+    content = content.trimEnd() + SESSION_MEMORY_SECTION;
   }
 
   fs.writeFileSync(filePath, content, "utf8");
@@ -471,6 +548,8 @@ module.exports = {
   formatSeedContext: formatSeedContext,
   enforceTeamAwareness: enforceTeamAwareness,
   TEAM_MARKER: TEAM_MARKER,
+  enforceSessionMemory: enforceSessionMemory,
+  SESSION_MEMORY_MARKER: SESSION_MEMORY_MARKER,
   loadCommonKnowledge: loadCommonKnowledge,
   promoteKnowledge: promoteKnowledge,
   depromoteKnowledge: depromoteKnowledge,

package/lib/project.js

@@ -3,7 +3,7 @@ var path = require("path");
 var os = require("os");
 var crypto = require("crypto");
 var { createSessionManager } = require("./sessions");
-var { createSDKBridge } = require("./sdk-bridge");
+var { createSDKBridge, createMessageQueue } = require("./sdk-bridge");
 var { createTerminalManager } = require("./terminal-manager");
 var { createNotesManager } = require("./notes");
 var { fetchLatestVersion, fetchVersion, isNewer } = require("./updater");
@@ -415,6 +415,7 @@ function createProjectContext(opts) {
     pushModule: pushModule,
     getSDK: getSDK,
     mateDisplayName: opts.mateDisplayName || "",
+    isMate: isMate,
     dangerouslySkipPermissions: dangerouslySkipPermissions,
     onProcessingChanged: onProcessingChanged,
   });
@@ -687,8 +688,9 @@ function createProjectContext(opts) {
         console.error("[loop-registry] PROMPT.md missing for " + loopId);
         return;
       }
-      // Set the loopId and start
+      // Set the loopId and start — clear wizardData so stale crafting names don't leak into session titles
       loopState.loopId = loopId;
+      loopState.wizardData = null;
       activeRegistryId = record.id;
       console.log("[loop-registry] Auto-starting loop: " + record.name + " (" + loopId + ")");
       send({ type: "schedule_run_started", recordId: record.id });
@@ -780,8 +782,8 @@ function createProjectContext(opts) {
     }
 
     var session = sm.createSession();
-    var loopName = (loopState.wizardData && loopState.wizardData.name) || "";
     var loopSource = loopRegistry.getById(loopState.loopId);
+    var loopName = (loopState.wizardData && loopState.wizardData.name) || (loopSource && loopSource.name) || "";
     var loopSourceTag = (loopSource && loopSource.source) || null;
     var isRalphLoop = loopSourceTag === "ralph";
     session.loop = { active: true, iteration: loopState.iteration, role: "coder", loopId: loopState.loopId, name: loopName, source: loopSourceTag, startedAt: loopState.startedAt };
@@ -1336,6 +1338,12 @@ function createProjectContext(opts) {
       return;
     }
 
+    // --- @Mention: invoke another Mate inline ---
+    if (msg.type === "mention") {
+      handleMention(ws, msg);
+      return;
+    }
+
     // --- Knowledge file management ---
     if (msg.type === "knowledge_list") {
       var knowledgeDir = path.join(cwd, "knowledge");
@@ -3468,6 +3476,13 @@ function createProjectContext(opts) {
       }
     }
 
+    // Inject pending @mention context so the current agent sees the exchange
+    if (session.pendingMentionContexts && session.pendingMentionContexts.length > 0) {
+      var mentionPrefix = session.pendingMentionContexts.join("\n\n");
+      session.pendingMentionContexts = [];
+      fullText = mentionPrefix + "\n\n" + fullText;
+    }
+
     if (!session.isProcessing) {
       session.isProcessing = true;
       onProcessingChanged();
@@ -3484,6 +3499,386 @@ function createProjectContext(opts) {
     sm.broadcastSessionList();
   }
 
+  // --- @Mention handler ---
+  var MENTION_WINDOW = 15; // turns to check for session continuity
+
+  function getRecentTurns(session, n) {
+    var turns = [];
+    var history = session.history;
+    // Walk backwards through history, collect user/assistant/mention text turns
+    var assistantBuffer = "";
+    for (var i = history.length - 1; i >= 0 && turns.length < n; i--) {
+      var entry = history[i];
+      if (entry.type === "user_message") {
+        if (assistantBuffer) {
+          turns.push({ role: "assistant", text: assistantBuffer.trim() });
+          assistantBuffer = "";
+        }
+        turns.push({ role: "user", text: entry.text || "" });
+      } else if (entry.type === "delta" || entry.type === "text") {
+        assistantBuffer = (entry.text || "") + assistantBuffer;
+      } else if (entry.type === "mention_response") {
+        if (assistantBuffer) {
+          turns.push({ role: "assistant", text: assistantBuffer.trim() });
+          assistantBuffer = "";
+        }
+        turns.push({ role: "@" + (entry.mateName || "Mate"), text: entry.text || "", mateId: entry.mateId });
+      } else if (entry.type === "mention_user") {
+        if (assistantBuffer) {
+          turns.push({ role: "assistant", text: assistantBuffer.trim() });
+          assistantBuffer = "";
+        }
+        turns.push({ role: "user", text: "@" + (entry.mateName || "Mate") + " " + (entry.text || ""), mateId: entry.mateId });
+      }
+    }
+    if (assistantBuffer) {
+      turns.push({ role: "assistant", text: assistantBuffer.trim() });
+    }
+    turns.reverse();
+    return turns;
+  }
+
+  // Check if the given mate has a mention response in the recent window
+  function hasMateInWindow(recentTurns, mateId) {
+    for (var i = 0; i < recentTurns.length; i++) {
+      if (recentTurns[i].mateId === mateId && recentTurns[i].role.charAt(0) === "@") {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Build the "middle context": conversation turns since the mate's last response
+  function buildMiddleContext(recentTurns, mateId) {
+    // Find the last mention response from this mate
+    var lastIdx = -1;
+    for (var i = recentTurns.length - 1; i >= 0; i--) {
+      if (recentTurns[i].mateId === mateId && recentTurns[i].role.charAt(0) === "@") {
+        lastIdx = i;
+        break;
+      }
+    }
+    if (lastIdx === -1 || lastIdx >= recentTurns.length - 1) return "";
+
+    // Collect turns after the last mention response
+    var lines = ["[Conversation since your last response:]", "---"];
+    for (var j = lastIdx + 1; j < recentTurns.length; j++) {
+      var turn = recentTurns[j];
+      lines.push(turn.role + ": " + turn.text);
+    }
+    lines.push("---");
+    return lines.join("\n");
+  }
+
+  function buildMentionContext(userName, recentTurns) {
+    var lines = [
+      "You were @mentioned in a project session by " + userName + ".",
+      "You are responding inline in their conversation. Keep your response focused on what was asked.",
+      "You have read-only access to the project files but cannot make changes.",
+      "",
+      "Recent conversation context:",
+      "---",
+    ];
+    for (var i = 0; i < recentTurns.length; i++) {
+      var turn = recentTurns[i];
+      lines.push(turn.role + ": " + turn.text);
+    }
+    lines.push("---");
+    return lines.join("\n");
+  }
+
+  function digestMentionSession(session, mateId, mateCtx, mateResponse, userQuestion) {
+    if (!session._mentionSessions || !session._mentionSessions[mateId]) return;
+    var mentionSession = session._mentionSessions[mateId];
+    if (!mentionSession.isAlive()) return;
+
+    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");
+
+    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),
+          };
+        }
+
+        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);
+      },
+    });
+  }
+
+  function handleMention(ws, msg) {
+    if (!msg.mateId || !msg.text) return;
+
+    var session = getSessionForWs(ws);
+    if (!session) return;
+
+    // Check if a mention is already in progress for this session
+    if (session._mentionInProgress) {
+      sendTo(ws, { type: "mention_error", mateId: msg.mateId, error: "A mention is already in progress." });
+      return;
+    }
+
+    var userId = ws._clayUser ? ws._clayUser.id : null;
+    var mateCtx = matesModule.buildMateCtx(userId);
+    var mate = matesModule.getMate(mateCtx, msg.mateId);
+    if (!mate) {
+      sendTo(ws, { type: "mention_error", mateId: msg.mateId, error: "Mate not found" });
+      return;
+    }
+
+    var mateName = (mate.profile && mate.profile.displayName) || mate.name || "Mate";
+    var avatarColor = (mate.profile && mate.profile.avatarColor) || "#6c5ce7";
+    var avatarStyle = (mate.profile && mate.profile.avatarStyle) || "bottts";
+    var avatarSeed = (mate.profile && mate.profile.avatarSeed) || mate.id;
+
+    // Build full mention text (include pasted content)
+    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";
+        mentionFullInput += msg.pastes[pi];
+      }
+    }
+
+    // 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;
+    session.history.push(mentionUserEntry);
+    sm.appendToSessionFile(session, mentionUserEntry);
+    sendToSessionOthers(ws, session.localId, mentionUserEntry);
+
+    // Extract recent turns for continuity check
+    var recentTurns = getRecentTurns(session, MENTION_WINDOW);
+
+    // Determine user name for context
+    var userName = "User";
+    if (ws._clayUser) {
+      var p = ws._clayUser.profile || {};
+      userName = p.name || ws._clayUser.displayName || ws._clayUser.username || "User";
+    }
+
+    session._mentionInProgress = true;
+
+    // Send mention start indicator
+    sendToSession(session.localId, {
+      type: "mention_start",
+      mateId: msg.mateId,
+      mateName: mateName,
+      avatarColor: avatarColor,
+      avatarStyle: avatarStyle,
+      avatarSeed: avatarSeed,
+    });
+
+    // Shared callbacks for both new and continued sessions
+    var mentionCallbacks = {
+      onActivity: function (activity) {
+        sendToSession(session.localId, {
+          type: "mention_activity",
+          mateId: msg.mateId,
+          activity: activity,
+        });
+      },
+      onDelta: function (delta) {
+        sendToSession(session.localId, {
+          type: "mention_stream",
+          mateId: msg.mateId,
+          mateName: mateName,
+          delta: delta,
+        });
+      },
+      onDone: function (fullText) {
+        session._mentionInProgress = false;
+
+        // Save mention response to session history
+        var mentionResponseEntry = {
+          type: "mention_response",
+          mateId: msg.mateId,
+          mateName: mateName,
+          text: fullText,
+          avatarColor: avatarColor,
+          avatarStyle: avatarStyle,
+          avatarSeed: avatarSeed,
+        };
+        session.history.push(mentionResponseEntry);
+        sm.appendToSessionFile(session, mentionResponseEntry);
+
+        // Queue mention context for injection into the current agent's next turn
+        if (!session.pendingMentionContexts) session.pendingMentionContexts = [];
+        session.pendingMentionContexts.push(
+          "[Context: @" + mateName + " was mentioned and responded]\n\n" +
+          "User asked @" + mateName + ": " + msg.text + "\n" +
+          mateName + " responded: " + fullText + "\n\n" +
+          "[End of @mention context. This is for your reference only. Do not re-execute or repeat this response.]"
+        );
+
+        sendToSession(session.localId, { type: "mention_done", mateId: msg.mateId });
+
+        // Generate session digest for mate's long-term memory
+        digestMentionSession(session, msg.mateId, mateCtx, fullText, msg.text);
+      },
+      onError: function (errMsg) {
+        session._mentionInProgress = false;
+        // Clean up dead session
+        if (session._mentionSessions && session._mentionSessions[msg.mateId]) {
+          delete session._mentionSessions[msg.mateId];
+        }
+        console.error("[mention] Error for mate " + msg.mateId + ":", errMsg);
+        sendToSession(session.localId, { type: "mention_error", mateId: msg.mateId, error: errMsg });
+      },
+    };
+
+    // Initialize mention sessions map if needed
+    if (!session._mentionSessions) session._mentionSessions = {};
+
+    // Session continuity: check if this mate has a response in the recent window
+    var existingSession = session._mentionSessions[msg.mateId];
+    var canContinue = existingSession && existingSession.isAlive() && hasMateInWindow(recentTurns, msg.mateId);
+
+    if (canContinue) {
+      // 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);
+    } else {
+      // Clean up old session if it exists
+      if (existingSession) {
+        existingSession.close();
+        delete session._mentionSessions[msg.mateId];
+      }
+
+      // Load Mate CLAUDE.md
+      var mateDir = matesModule.getMateDir(mateCtx, msg.mateId);
+      var claudeMd = "";
+      try {
+        claudeMd = fs.readFileSync(path.join(mateDir, "CLAUDE.md"), "utf8");
+      } catch (e) {
+        // 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) {}
+
+      // Build initial mention context
+      var mentionContext = buildMentionContext(userName, recentTurns) + recentDigests;
+
+      // Create new persistent mention session
+      sdk.createMentionSession({
+        claudeMd: claudeMd,
+        initialContext: mentionContext,
+        initialMessage: mentionFullInput,
+        onActivity: mentionCallbacks.onActivity,
+        onDelta: mentionCallbacks.onDelta,
+        onDone: mentionCallbacks.onDone,
+        onError: mentionCallbacks.onError,
+        canUseTool: function (toolName, input, toolOpts) {
+          var autoAllow = { Read: true, Glob: true, Grep: true };
+          if (autoAllow[toolName]) {
+            return Promise.resolve({ behavior: "allow", updatedInput: input });
+          }
+          // Route through the project session's permission system
+          return new Promise(function (resolve) {
+            var requestId = crypto.randomUUID();
+            session.pendingPermissions[requestId] = {
+              resolve: resolve,
+              requestId: requestId,
+              toolName: toolName,
+              toolInput: input,
+              toolUseId: toolOpts ? toolOpts.toolUseID : undefined,
+              decisionReason: (toolOpts && toolOpts.decisionReason) || "",
+            };
+            sendToSession(session.localId, {
+              type: "permission_request",
+              requestId: requestId,
+              toolName: toolName,
+              toolInput: input,
+              toolUseId: toolOpts ? toolOpts.toolUseID : undefined,
+              decisionReason: (toolOpts && toolOpts.decisionReason) || "",
+            });
+            onProcessingChanged();
+            if (toolOpts && toolOpts.signal) {
+              toolOpts.signal.addEventListener("abort", function () {
+                delete session.pendingPermissions[requestId];
+                sendToSession(session.localId, { type: "permission_cancel", requestId: requestId });
+                onProcessingChanged();
+                resolve({ behavior: "deny", message: "Request cancelled" });
+              });
+            }
+          });
+        },
+      }).then(function (mentionSession) {
+        if (mentionSession) {
+          session._mentionSessions[msg.mateId] = mentionSession;
+        }
+      }).catch(function (err) {
+        session._mentionInProgress = false;
+        console.error("[mention] Failed to create session for mate " + msg.mateId + ":", err.message || err);
+        sendToSession(session.localId, { type: "mention_error", mateId: msg.mateId, error: "Failed to create mention session." });
+      });
+    }
+  }
+
   // --- Session presence (who is viewing which session) ---
   function broadcastPresence() {
     if (!usersModule.isMultiUser()) return;
@@ -4056,7 +4451,7 @@ function createProjectContext(opts) {
     loopRegistry.stopTimer();
     stopFileWatch();
     stopAllDirWatches();
-    // Abort all active sessions
+    // Abort all active sessions and clean up mention sessions
     sm.sessions.forEach(function (session) {
       session.destroying = true;
       if (session.abortController) {
@@ -4065,6 +4460,14 @@ function createProjectContext(opts) {
       if (session.messageQueue) {
         try { session.messageQueue.end(); } catch (e) {}
       }
+      // Close all mention SDK sessions to prevent zombie processes
+      if (session._mentionSessions) {
+        var mateIds = Object.keys(session._mentionSessions);
+        for (var mi = 0; mi < mateIds.length; mi++) {
+          try { session._mentionSessions[mateIds[mi]].close(); } catch (e) {}
+        }
+        session._mentionSessions = {};
+      }
     });
     // Kill all terminals
     tm.destroyAll();
@@ -4149,6 +4552,7 @@ function createProjectContext(opts) {
     var claudeMdPath = path.join(cwd, "CLAUDE.md");
     // Enforce immediately on startup
     try { matesModule.enforceTeamAwareness(claudeMdPath); } catch (e) {}
+    try { matesModule.enforceSessionMemory(claudeMdPath); } catch (e) {}
     try { crisisSafety.enforce(claudeMdPath); } catch (e) {}
     // Watch for changes
     try {
@@ -4157,6 +4561,7 @@ function createProjectContext(opts) {
         crisisDebounce = setTimeout(function () {
           crisisDebounce = null;
           try { matesModule.enforceTeamAwareness(claudeMdPath); } catch (e) {}
+          try { matesModule.enforceSessionMemory(claudeMdPath); } catch (e) {}
           try { crisisSafety.enforce(claudeMdPath); } catch (e) {}
         }, 500);
       });