clay-server 2.18.0-beta.9 → 2.18.0

package/lib/project.js

@@ -13,6 +13,7 @@ var usersModule = require("./users");
 var { resolveOsUserInfo, fsAsUser } = require("./os-users");
 var crisisSafety = require("./crisis-safety");
 var matesModule = require("./mates");
+var userPresence = require("./user-presence");
 var MAX_UPLOAD_BYTES = 50 * 1024 * 1024; // 50 MB
 
 // Validate environment variable string (KEY=VALUE per line)
@@ -670,30 +671,31 @@ function createProjectContext(opts) {
       }
 
       // For schedule records, resolve the linked task to get loop files
-      var loopId = record.id;
+      var loopFilesId = record.id;
       if (record.source === "schedule") {
         if (!record.linkedTaskId) {
           console.error("[loop-registry] Schedule has no linked task: " + record.name);
           return;
         }
-        loopId = record.linkedTaskId;
-        console.log("[loop-registry] Schedule triggered: " + record.name + " → linked task " + loopId);
+        loopFilesId = record.linkedTaskId;
+        console.log("[loop-registry] Schedule triggered: " + record.name + " → linked task " + loopFilesId);
       }
 
       // Verify the loop directory and PROMPT.md exist
-      var recDir = path.join(cwd, ".claude", "loops", loopId);
+      var recDir = path.join(cwd, ".claude", "loops", loopFilesId);
       try {
         fs.accessSync(path.join(recDir, "PROMPT.md"));
       } catch (e) {
-        console.error("[loop-registry] PROMPT.md missing for " + loopId);
+        console.error("[loop-registry] PROMPT.md missing for " + loopFilesId);
         return;
       }
-      // Set the loopId and start
-      loopState.loopId = loopId;
+      // Set the loopId to the schedule's own id (not the linked task) so sidebar groups correctly
+      loopState.loopId = record.id;
+      loopState.wizardData = null;
       activeRegistryId = record.id;
       console.log("[loop-registry] Auto-starting loop: " + record.name + " (" + loopId + ")");
       send({ type: "schedule_run_started", recordId: record.id });
-      startLoop({ maxIterations: record.maxIterations });
+      startLoop({ maxIterations: record.maxIterations, name: record.name });
     },
     onChange: function () {
       send({ type: "loop_registry_updated", records: getHubSchedules() });
@@ -752,18 +754,19 @@ function createProjectContext(opts) {
     loopState.promptText = promptText;
     loopState.judgeText = judgeText;
     loopState.iteration = 0;
-    loopState.maxIterations = judgeText ? (loopConfig.maxIterations || loopOpts.maxIterations || 20) : 1;
+    loopState.maxIterations = judgeText ? ((loopOpts.maxIterations >= 1 ? loopOpts.maxIterations : null) || loopConfig.maxIterations || 20) : 1;
     loopState.baseCommit = baseCommit;
     loopState.currentSessionId = null;
     loopState.judgeSessionId = null;
     loopState.results = [];
     loopState.stopping = false;
+    loopState.name = loopOpts.name || null;
     loopState.startedAt = Date.now();
     saveLoopState();
 
     stopClaudeDirWatch();
 
-    send({ type: "loop_started", maxIterations: loopState.maxIterations });
+    send({ type: "loop_started", maxIterations: loopState.maxIterations, name: loopState.name });
     runNextIteration();
   }
 
@@ -781,8 +784,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 };
@@ -830,7 +833,7 @@ function createProjectContext(opts) {
         setTimeout(function() { runNextIteration(); }, 2000);
         return;
       }
-      if (loopState.judgeText) {
+      if (loopState.judgeText && loopState.maxIterations > 1) {
         runJudge();
       } else {
         finishLoop("pass");
@@ -909,8 +912,8 @@ function createProjectContext(opts) {
       "- FAIL: [brief explanation of what is still missing]";
 
     var judgeSession = sm.createSession();
-    var judgeName = (loopState.wizardData && loopState.wizardData.name) || "";
     var judgeSource = loopRegistry.getById(loopState.loopId);
+    var judgeName = (loopState.wizardData && loopState.wizardData.name) || (judgeSource && judgeSource.name) || "";
     var judgeSourceTag = (judgeSource && judgeSource.source) || null;
     var isRalphJudge = judgeSourceTag === "ralph";
     judgeSession.loop = { active: true, iteration: loopState.iteration, role: "judge", loopId: loopState.loopId, name: judgeName, source: judgeSourceTag, startedAt: loopState.startedAt };
@@ -1187,6 +1190,7 @@ function createProjectContext(opts) {
       active: loopState.active,
       iteration: loopState.iteration,
       maxIterations: loopState.maxIterations,
+      name: loopState.name || null,
     });
 
     // Ralph phase state
@@ -1247,14 +1251,26 @@ function createProjectContext(opts) {
       }),
     });
 
-    // Restore active session for this client (check access)
-    var active = sm.getActiveSession();
-    if (active && usersModule.isMultiUser() && wsUser) {
-      if (!usersModule.canAccessSession(wsUser.id, active, { visibility: "public" })) {
+    // Restore active session for this client from server-side presence
+    var active = null;
+    var presenceKey = wsUser ? wsUser.id : "_default";
+    var storedPresence = userPresence.getPresence(slug, presenceKey);
+    if (storedPresence && storedPresence.sessionId) {
+      // Look up stored session by localId
+      if (sm.sessions.has(storedPresence.sessionId)) {
+        active = sm.sessions.get(storedPresence.sessionId);
+      } else {
+        // Try matching by cliSessionId (survives server restarts where localIds change)
+        sm.sessions.forEach(function (s) {
+          if (s.cliSessionId && s.cliSessionId === storedPresence.sessionId) active = s;
+        });
+      }
+      // Validate access
+      if (active && usersModule.isMultiUser() && wsUser) {
+        if (!usersModule.canAccessSession(wsUser.id, active, { visibility: "public" })) active = null;
+      } else if (active && !usersModule.isMultiUser() && active.ownerId) {
         active = null;
       }
-    } else if (active && !usersModule.isMultiUser() && active.ownerId) {
-      active = null;
     }
     // Fallback: pick the most recent accessible session
     if (!active && allSessions.length > 0) {
@@ -1269,13 +1285,13 @@ function createProjectContext(opts) {
     var autoCreated = false;
     if (!active) {
       var autoOpts = {};
-      if (wsUser) autoOpts.ownerId = wsUser.id;
+      if (wsUser && usersModule.isMultiUser()) autoOpts.ownerId = wsUser.id;
       active = sm.createSession(autoOpts, ws);
       autoCreated = true;
     }
     if (active && !autoCreated) {
-      // Backfill ownerId for legacy sessions restored without one
-      if (!active.ownerId && wsUser) {
+      // Backfill ownerId for legacy sessions restored without one (multi-user only)
+      if (!active.ownerId && wsUser && usersModule.isMultiUser()) {
         active.ownerId = wsUser.id;
         sm.saveSessionFile(active);
       }
@@ -1289,7 +1305,11 @@ function createProjectContext(opts) {
       }
       sendTo(ws, { type: "history_meta", total: total, from: fromIndex });
       for (var i = fromIndex; i < total; i++) {
-        sendTo(ws, hydrateImageRefs(active.history[i]));
+        var _hitem = active.history[i];
+        if (_hitem && (_hitem.type === "mention_user" || _hitem.type === "mention_response")) {
+          console.log("[DEBUG handleConnection] sending mention at index=" + i + " from=" + fromIndex + " total=" + total + " type=" + _hitem.type + " mate=" + (_hitem.mateName || "") + " slug=" + slug);
+        }
+        sendTo(ws, hydrateImageRefs(_hitem));
       }
       sendTo(ws, { type: "history_done" });
 
@@ -1306,12 +1326,24 @@ function createProjectContext(opts) {
           toolInput: p.toolInput,
           toolUseId: p.toolUseId,
           decisionReason: p.decisionReason,
+          mateId: p.mateId || undefined,
         });
       }
     }
 
+    // Record presence for this user + send mate DM restore hint if applicable
+    if (active) {
+      userPresence.setPresence(slug, presenceKey, active.localId, storedPresence ? storedPresence.mateDm : null);
+    }
+    if (storedPresence && storedPresence.mateDm) {
+      sendTo(ws, { type: "restore_mate_dm", mateId: storedPresence.mateDm });
+    }
+
     broadcastPresence();
 
+    // Restore debate state and brief watcher if a debate was in progress
+    restoreDebateState(ws);
+
     ws.on("message", function (raw) {
       var msg;
       try { msg = JSON.parse(raw.toString()); } catch (e) { return; }
@@ -1343,6 +1375,24 @@ function createProjectContext(opts) {
       return;
     }
 
+    // --- Debate ---
+    if (msg.type === "debate_start") {
+      handleDebateStart(ws, msg);
+      return;
+    }
+    if (msg.type === "debate_comment") {
+      handleDebateComment(ws, msg);
+      return;
+    }
+    if (msg.type === "debate_stop") {
+      handleDebateStop(ws);
+      return;
+    }
+    if (msg.type === "debate_conclude_response") {
+      handleDebateConcludeResponse(ws, msg);
+      return;
+    }
+
     // --- Knowledge file management ---
     if (msg.type === "knowledge_list") {
       var knowledgeDir = path.join(cwd, "knowledge");
@@ -1526,10 +1576,12 @@ function createProjectContext(opts) {
 
     if (msg.type === "new_session") {
       var sessionOpts = {};
-      if (ws._clayUser) sessionOpts.ownerId = ws._clayUser.id;
+      if (ws._clayUser && usersModule.isMultiUser()) sessionOpts.ownerId = ws._clayUser.id;
       if (msg.sessionVisibility) sessionOpts.sessionVisibility = msg.sessionVisibility;
       var newSess = sm.createSession(sessionOpts, ws);
       ws._clayActiveSession = newSess.localId;
+      var nsPresKey = ws._clayUser ? ws._clayUser.id : "_default";
+      userPresence.setPresence(slug, nsPresKey, newSess.localId, null);
       if (usersModule.isMultiUser()) {
         broadcastPresence();
       }
@@ -1660,10 +1712,18 @@ function createProjectContext(opts) {
           ws._clayActiveSession = msg.id;
           sm.switchSession(msg.id, ws, hydrateImageRefs);
         }
+        var swPresKey = ws._clayUser ? ws._clayUser.id : "_default";
+        userPresence.setPresence(slug, swPresKey, msg.id, null);
       }
       return;
     }
 
+    if (msg.type === "set_mate_dm") {
+      var dmPresKey = ws._clayUser ? ws._clayUser.id : "_default";
+      userPresence.setMateDm(slug, dmPresKey, msg.mateId || null);
+      return;
+    }
+
     if (msg.type === "delete_session") {
       if (ws._clayUser) {
         var sdPerms = usersModule.getEffectivePermissions(ws._clayUser, osUsers);
@@ -3320,6 +3380,7 @@ function createProjectContext(opts) {
         color: sData.color || null,
         recurrenceEnd: sData.recurrenceEnd || null,
         skipIfRunning: sData.skipIfRunning !== undefined ? sData.skipIfRunning : true,
+        intervalEnd: sData.intervalEnd || null,
       });
       return;
     }
@@ -3424,8 +3485,8 @@ function createProjectContext(opts) {
     var session = getSessionForWs(ws);
     if (!session) return;
 
-    // Backfill ownerId for legacy sessions restored without one
-    if (!session.ownerId && ws._clayUser) {
+    // Backfill ownerId for legacy sessions restored without one (multi-user only)
+    if (!session.ownerId && ws._clayUser && usersModule.isMultiUser()) {
       session.ownerId = ws._clayUser.id;
       sm.saveSessionFile(session);
     }
@@ -3499,7 +3560,7 @@ function createProjectContext(opts) {
   }
 
   // --- @Mention handler ---
-  var MENTION_WINDOW = 15; // turns to check for session continuity
+  var MENTION_WINDOW = 20; // turns to check for session continuity
 
   function getRecentTurns(session, n) {
     var turns = [];
@@ -3655,6 +3716,12 @@ function createProjectContext(opts) {
     var session = getSessionForWs(ws);
     if (!session) return;
 
+    // Block mentions during an active debate
+    if (session._debate && session._debate.phase === "live") {
+      sendTo(ws, { type: "mention_error", mateId: msg.mateId, error: "Cannot use @mentions during an active debate." });
+      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." });
@@ -3832,7 +3899,7 @@ function createProjectContext(opts) {
         onDone: mentionCallbacks.onDone,
         onError: mentionCallbacks.onError,
         canUseTool: function (toolName, input, toolOpts) {
-          var autoAllow = { Read: true, Glob: true, Grep: true };
+          var autoAllow = { Read: true, Glob: true, Grep: true, WebFetch: true, WebSearch: true };
           if (autoAllow[toolName]) {
             return Promise.resolve({ behavior: "allow", updatedInput: input });
           }
@@ -3846,6 +3913,7 @@ function createProjectContext(opts) {
               toolInput: input,
               toolUseId: toolOpts ? toolOpts.toolUseID : undefined,
               decisionReason: (toolOpts && toolOpts.decisionReason) || "",
+              mateId: msg.mateId,
             };
             sendToSession(session.localId, {
               type: "permission_request",
@@ -3854,6 +3922,7 @@ function createProjectContext(opts) {
               toolInput: input,
               toolUseId: toolOpts ? toolOpts.toolUseID : undefined,
               decisionReason: (toolOpts && toolOpts.decisionReason) || "",
+              mateId: msg.mateId,
             });
             onProcessingChanged();
             if (toolOpts && toolOpts.signal) {
@@ -3878,6 +3947,1313 @@ function createProjectContext(opts) {
     }
   }
 
+  // --- Debate engine ---
+
+  function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+
+  function buildDebateNameMap(panelists, mateCtx) {
+    var nameMap = {};
+    for (var i = 0; i < panelists.length; i++) {
+      var mate = matesModule.getMate(mateCtx, panelists[i].mateId);
+      if (!mate) continue;
+      var name = (mate.profile && mate.profile.displayName) || mate.name || "";
+      if (name) {
+        nameMap[name] = panelists[i].mateId;
+      }
+    }
+    return nameMap;
+  }
+
+  function detectMentions(text, nameMap) {
+    var names = Object.keys(nameMap);
+    // Sort by length descending to match longest name first
+    names.sort(function (a, b) { return b.length - a.length; });
+    var mentioned = [];
+    console.log("[debate-mention] nameMap keys:", JSON.stringify(names));
+    console.log("[debate-mention] text snippet:", text.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);
+      console.log("[debate-mention] testing @" + names[i] + " pattern=" + pattern.toString() + " matched=" + matched);
+      if (matched) {
+        var mateId = nameMap[names[i]];
+        if (mentioned.indexOf(mateId) === -1) {
+          mentioned.push(mateId);
+        }
+      }
+    }
+    return mentioned;
+  }
+
+  function getMateProfile(mateCtx, mateId) {
+    var mate = matesModule.getMate(mateCtx, mateId);
+    if (!mate) return { name: "Mate", avatarColor: "#6c5ce7", avatarStyle: "bottts", avatarSeed: mateId };
+    return {
+      name: (mate.profile && mate.profile.displayName) || mate.name || "Mate",
+      avatarColor: (mate.profile && mate.profile.avatarColor) || "#6c5ce7",
+      avatarStyle: (mate.profile && mate.profile.avatarStyle) || "bottts",
+      avatarSeed: (mate.profile && mate.profile.avatarSeed) || mateId,
+    };
+  }
+
+  function loadMateClaudeMd(mateCtx, mateId) {
+    var mateDir = matesModule.getMateDir(mateCtx, mateId);
+    try {
+      return fs.readFileSync(path.join(mateDir, "CLAUDE.md"), "utf8");
+    } catch (e) {
+      return "";
+    }
+  }
+
+  function loadMateDigests(mateCtx, mateId) {
+    var mateDir = matesModule.getMateDir(mateCtx, mateId);
+    try {
+      var digestFile = path.join(mateDir, "knowledge", "session-digests.jsonl");
+      if (!fs.existsSync(digestFile)) return "";
+      var allLines = fs.readFileSync(digestFile, "utf8").trim().split("\n");
+      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++) {
+        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) {}
+      }
+      return lines.join("\n");
+    } catch (e) {
+      return "";
+    }
+  }
+
+  function buildModeratorContext(debate) {
+    var lines = [
+      "You are moderating a structured debate among your AI teammates.",
+      "",
+      "Topic: " + debate.topic,
+      "Format: " + debate.format,
+      "Context: " + debate.context,
+    ];
+    if (debate.specialRequests) {
+      lines.push("Special requests: " + debate.specialRequests);
+    }
+    lines.push("");
+    lines.push("Panelists:");
+    for (var i = 0; i < debate.panelists.length; i++) {
+      var p = debate.panelists[i];
+      var profile = getMateProfile(debate.mateCtx, p.mateId);
+      lines.push("- @" + profile.name + " (" + p.role + "): " + p.brief);
+    }
+    lines.push("");
+    lines.push("RULES:");
+    lines.push("1. To call on a panelist, mention them with @TheirName in your response.");
+    lines.push("2. Only mention ONE panelist per response. Wait for their answer before calling the next.");
+    lines.push("3. When you mention a panelist, clearly state what you want them to address.");
+    lines.push("4. After hearing from all panelists, you may start additional rounds.");
+    lines.push("5. When you believe the debate has reached a natural conclusion, provide a summary WITHOUT mentioning any panelist. A response with no @mention signals the end of the debate.");
+    lines.push("6. If the user interjects with a comment, acknowledge it and weave it into the discussion.");
+    lines.push("");
+    lines.push("Begin by introducing the topic and calling on the first panelist.");
+    return lines.join("\n");
+  }
+
+  function buildPanelistContext(debate, panelistInfo) {
+    var moderatorProfile = getMateProfile(debate.mateCtx, debate.moderatorId);
+    var lines = [
+      "You are participating in a structured debate as a panelist.",
+      "",
+      "Topic: " + debate.topic,
+      "Your role: " + panelistInfo.role,
+      "Your brief: " + panelistInfo.brief,
+      "",
+      "Other panelists:",
+    ];
+    for (var i = 0; i < debate.panelists.length; i++) {
+      var p = debate.panelists[i];
+      if (p.mateId === panelistInfo.mateId) continue;
+      var profile = getMateProfile(debate.mateCtx, p.mateId);
+      lines.push("- @" + profile.name + " (" + p.role + "): " + p.brief);
+    }
+    lines.push("");
+    lines.push("The moderator is @" + moderatorProfile.name + ". They will call on you when it is your turn.");
+    lines.push("");
+    lines.push("RULES:");
+    lines.push("1. Stay in your assigned role and perspective.");
+    lines.push("2. Respond to the specific question or prompt from the moderator.");
+    lines.push("3. You may reference what other panelists have said.");
+    lines.push("4. Keep responses focused and substantive. Do not ramble.");
+    lines.push("5. You have read-only access to project files if needed to support your arguments.");
+    return lines.join("\n");
+  }
+
+  // --- Debate brief watcher (reusable for initial start and session restoration) ---
+  function startDebateBriefWatcher(session, debate, briefPath) {
+    if (!briefPath) {
+      console.error("[debate] No briefPath provided to watcher");
+      return;
+    }
+    // Persist briefPath on debate so restoration can reuse it
+    debate.briefPath = briefPath;
+    var watchDir = path.dirname(briefPath);
+    var briefFilename = path.basename(briefPath);
+
+    // Clean up any existing watcher
+    if (debate._briefWatcher) {
+      try { debate._briefWatcher.close(); } catch (e) {}
+      debate._briefWatcher = null;
+    }
+    if (debate._briefDebounce) {
+      clearTimeout(debate._briefDebounce);
+      debate._briefDebounce = null;
+    }
+
+    function checkDebateBrief() {
+      try {
+        var raw = fs.readFileSync(briefPath, "utf8");
+        var brief = JSON.parse(raw);
+
+        // Stop watching
+        if (debate._briefWatcher) { debate._briefWatcher.close(); debate._briefWatcher = null; }
+        if (debate._briefDebounce) { clearTimeout(debate._briefDebounce); debate._briefDebounce = null; }
+
+        // Clean up the brief file
+        try { fs.unlinkSync(briefPath); } catch (e) {}
+
+        // Apply brief to debate state
+        debate.topic = brief.topic || debate.topic;
+        debate.format = brief.format || debate.format;
+        debate.context = brief.context || "";
+        debate.specialRequests = brief.specialRequests || null;
+
+        // Update panelists with roles from the brief
+        if (brief.panelists && brief.panelists.length) {
+          for (var i = 0; i < brief.panelists.length; i++) {
+            var bp = brief.panelists[i];
+            for (var j = 0; j < debate.panelists.length; j++) {
+              if (debate.panelists[j].mateId === bp.mateId) {
+                debate.panelists[j].role = bp.role || "";
+                debate.panelists[j].brief = bp.brief || "";
+              }
+            }
+          }
+        }
+
+        // Rebuild name map with updated roles
+        var mateCtx = debate.mateCtx || matesModule.buildMateCtx(null);
+        debate.nameMap = buildDebateNameMap(debate.panelists, mateCtx);
+
+        console.log("[debate] Brief picked up, transitioning to live. Topic:", debate.topic);
+
+        // Transition to live
+        startDebateLive(session);
+      } catch (e) {
+        // File not ready yet or invalid JSON, keep watching
+      }
+    }
+
+    try {
+      try { fs.mkdirSync(watchDir, { recursive: true }); } catch (e) {}
+      debate._briefWatcher = fs.watch(watchDir, function (eventType, filename) {
+        if (filename === briefFilename) {
+          if (debate._briefDebounce) clearTimeout(debate._briefDebounce);
+          debate._briefDebounce = setTimeout(checkDebateBrief, 300);
+        }
+      });
+      debate._briefWatcher.on("error", function () {});
+      console.log("[debate] Watching for " + briefFilename + " at " + watchDir);
+    } catch (e) {
+      console.error("[debate] Failed to watch " + watchDir + ":", e.message);
+    }
+
+    // Check immediately in case the file already exists (server restart scenario)
+    checkDebateBrief();
+  }
+
+  // Restore debate state and brief watcher on WS reconnect (after server restart)
+  function restoreDebateState(ws) {
+    var userId = ws._clayUser ? ws._clayUser.id : null;
+    var mateCtx = matesModule.buildMateCtx(userId);
+
+    sm.sessions.forEach(function (session) {
+      // Already restored
+      if (session._debate) return;
+
+      // Has persisted debate state?
+      if (!session.debateState) return;
+
+      var phase = session.debateState.phase;
+      if (phase !== "preparing" && phase !== "live") return;
+
+      // Restore _debate from persisted state
+      var debate = restoreDebateFromState(session);
+      if (!debate) return;
+
+      // Update mateCtx with the connected user's context
+      debate.mateCtx = mateCtx;
+      debate.nameMap = buildDebateNameMap(debate.panelists, mateCtx);
+
+      var moderatorProfile = getMateProfile(mateCtx, debate.moderatorId);
+
+      if (phase === "preparing") {
+        var briefPath = debate.briefPath;
+        if (!briefPath && debate.debateId) {
+          briefPath = path.join(cwd, ".clay", "debates", debate.debateId, "brief.json");
+        }
+        if (!briefPath) return;
+
+        console.log("[debate] Restoring debate (preparing). topic:", debate.topic, "briefPath:", briefPath);
+        startDebateBriefWatcher(session, debate, briefPath);
+
+        // Send preparing sticky to the connected client
+        sendTo(ws, {
+          type: "debate_preparing",
+          topic: debate.topic,
+          moderatorId: debate.moderatorId,
+          moderatorName: moderatorProfile.name,
+          setupSessionId: debate.setupSessionId,
+          panelists: debate.panelists.map(function (p) {
+            var prof = getMateProfile(mateCtx, p.mateId);
+            return { mateId: p.mateId, name: prof.name };
+          }),
+        });
+      } else if (phase === "live") {
+        console.log("[debate] Restoring debate (live). topic:", debate.topic, "awaitingConclude:", debate.awaitingConcludeConfirm);
+        // Debate was live when server restarted. It can't resume AI turns,
+        // but we can show the sticky and let user see history.
+        sendTo(ws, {
+          type: "debate_started",
+          topic: debate.topic,
+          format: debate.format,
+          round: debate.round,
+          moderatorId: debate.moderatorId,
+          moderatorName: moderatorProfile.name,
+          panelists: debate.panelists.map(function (p) {
+            var prof = getMateProfile(mateCtx, p.mateId);
+            return { mateId: p.mateId, name: prof.name, role: p.role, avatarColor: prof.avatarColor, avatarStyle: prof.avatarStyle, avatarSeed: prof.avatarSeed };
+          }),
+        });
+        // If moderator had concluded, re-send conclude confirm so client shows End/Continue UI
+        if (debate.awaitingConcludeConfirm) {
+          sendTo(ws, { type: "debate_conclude_confirm", topic: debate.topic, round: debate.round });
+        }
+      }
+    });
+  }
+
+  // Persist debate state to session file (survives server restart)
+  function persistDebateState(session) {
+    if (!session._debate) return;
+    var d = session._debate;
+    session.debateState = {
+      phase: d.phase,
+      topic: d.topic,
+      format: d.format,
+      context: d.context || "",
+      specialRequests: d.specialRequests || null,
+      moderatorId: d.moderatorId,
+      panelists: d.panelists.map(function (p) {
+        return { mateId: p.mateId, role: p.role || "", brief: p.brief || "" };
+      }),
+      briefPath: d.briefPath || null,
+      debateId: d.debateId || null,
+      setupSessionId: d.setupSessionId || null,
+      setupStartedAt: d.setupStartedAt || null,
+      round: d.round || 1,
+      awaitingConcludeConfirm: !!d.awaitingConcludeConfirm,
+    };
+    sm.saveSessionFile(session);
+  }
+
+  // Restore _debate from persisted debateState
+  function restoreDebateFromState(session) {
+    var ds = session.debateState;
+    if (!ds) return null;
+    var userId = null; // Will be set when WS connects
+    var mateCtx = matesModule.buildMateCtx(userId);
+    var debate = {
+      phase: ds.phase,
+      topic: ds.topic,
+      format: ds.format,
+      context: ds.context || "",
+      specialRequests: ds.specialRequests || null,
+      moderatorId: ds.moderatorId,
+      panelists: ds.panelists || [],
+      mateCtx: mateCtx,
+      moderatorSession: null,
+      panelistSessions: {},
+      nameMap: buildDebateNameMap(ds.panelists || [], mateCtx),
+      turnInProgress: false,
+      pendingComment: null,
+      round: ds.round || 1,
+      history: [],
+      setupSessionId: ds.setupSessionId || null,
+      debateId: ds.debateId || null,
+      setupStartedAt: ds.setupStartedAt || null,
+      briefPath: ds.briefPath || null,
+      awaitingConcludeConfirm: !!ds.awaitingConcludeConfirm,
+    };
+
+    // Fallback: if awaitingConcludeConfirm was not persisted, detect from history
+    if (!debate.awaitingConcludeConfirm && ds.phase === "live") {
+      var hasEnded = false;
+      var hasConclude = false;
+      var lastModText = null;
+      for (var i = 0; i < session.history.length; i++) {
+        var h = session.history[i];
+        if (h.type === "debate_ended") hasEnded = true;
+        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) {
+        var mentions = detectMentions(lastModText, debate.nameMap);
+        if (mentions.length === 0) {
+          debate.awaitingConcludeConfirm = true;
+        }
+      }
+    }
+
+    session._debate = debate;
+    return debate;
+  }
+
+  function buildDebateToolHandler(session) {
+    return function (toolName, input, toolOpts) {
+      var autoAllow = { Read: true, Glob: true, Grep: true, WebFetch: true, WebSearch: true };
+      if (autoAllow[toolName]) {
+        return Promise.resolve({ behavior: "allow", updatedInput: input });
+      }
+      return Promise.resolve({
+        behavior: "deny",
+        message: "Read-only access during debate. You cannot make changes.",
+      });
+    };
+  }
+
+  function handleDebateStart(ws, msg) {
+    var session = getSessionForWs(ws);
+    if (!session) return;
+
+    if (!msg.moderatorId || !msg.topic || !msg.panelists || !msg.panelists.length) {
+      sendTo(ws, { type: "debate_error", error: "Missing required fields: moderatorId, topic, panelists." });
+      return;
+    }
+
+    if (session._debate && (session._debate.phase === "live" || session._debate.phase === "preparing")) {
+      sendTo(ws, { type: "debate_error", error: "A debate is already in progress." });
+      return;
+    }
+
+    // Block mentions during debate
+    if (session._mentionInProgress) {
+      sendTo(ws, { type: "debate_error", error: "A mention is in progress. Wait for it to finish." });
+      return;
+    }
+
+    var userId = ws._clayUser ? ws._clayUser.id : null;
+    var mateCtx = matesModule.buildMateCtx(userId);
+    var moderatorProfile = getMateProfile(mateCtx, msg.moderatorId);
+
+    // --- Phase 1: Preparing (clay-debate-setup skill) ---
+    var debate = {
+      phase: "preparing",
+      topic: msg.topic,
+      format: "free_discussion",
+      context: "",
+      specialRequests: null,
+      moderatorId: msg.moderatorId,
+      panelists: msg.panelists,
+      mateCtx: mateCtx,
+      moderatorSession: null,
+      panelistSessions: {},
+      nameMap: buildDebateNameMap(msg.panelists, mateCtx),
+      turnInProgress: false,
+      pendingComment: null,
+      round: 1,
+      history: [],
+      setupSessionId: null,
+    };
+    session._debate = debate;
+
+    // Create a new session for the setup skill (like Ralph crafting)
+    var debateId = "debate_" + Date.now();
+    var setupSession = sm.createSession();
+    setupSession.title = "Debate Setup: " + msg.topic.slice(0, 40);
+    setupSession.debateSetupMode = true;
+    setupSession.loop = { active: true, iteration: 0, role: "crafting", loopId: debateId, name: msg.topic.slice(0, 40), source: "debate", startedAt: Date.now() };
+    sm.saveSessionFile(setupSession);
+    sm.switchSession(setupSession.localId, null, hydrateImageRefs);
+    debate.setupSessionId = setupSession.localId;
+    debate.debateId = debateId;
+    debate.setupStartedAt = setupSession.loop.startedAt;
+
+    // Build panelist info for the skill prompt
+    var panelistNames = msg.panelists.map(function (p) {
+      var prof = getMateProfile(mateCtx, p.mateId);
+      return prof.name || p.mateId;
+    }).join(", ");
+
+    var debateDir = path.join(cwd, ".clay", "debates", debateId);
+    try { fs.mkdirSync(debateDir, { recursive: true }); } catch (e) {}
+    var briefPath = path.join(debateDir, "brief.json");
+    console.log("[debate] cwd=" + cwd + " debateDir=" + debateDir + " briefPath=" + briefPath);
+
+    var craftingPrompt = "Use the /clay-debate-setup skill to prepare a structured debate. " +
+      "You MUST invoke the clay-debate-setup skill. Do NOT start the debate yourself.\n\n" +
+      "## Initial Topic\n" + msg.topic + "\n\n" +
+      "## Moderator\n" + (moderatorProfile.name || msg.moderatorId) + "\n\n" +
+      "## Selected Panelists\n" + msg.panelists.map(function (p) {
+        var prof = getMateProfile(mateCtx, p.mateId);
+        return "- " + (prof.name || p.mateId) + " (ID: " + p.mateId + ")";
+      }).join("\n") + "\n\n" +
+      "## Debate Brief Output Path\n" +
+      "When the setup is complete, write the debate brief JSON to this EXACT absolute path:\n" +
+      "`" + briefPath + "`\n" +
+      "This is where the debate engine watches for the file. Do NOT write it anywhere else.\n\n" +
+      "## Spoken Language\nKorean (unless user switches)";
+
+    // Persist debate state before starting watcher
+    debate.briefPath = briefPath;
+    persistDebateState(session);
+
+    // Watch for brief.json in the debate-specific directory
+    startDebateBriefWatcher(session, debate, briefPath);
+
+    // Notify clients that we are in preparing phase (send to both original and setup session)
+    var preparingMsg = {
+      type: "debate_preparing",
+      topic: debate.topic,
+      moderatorId: debate.moderatorId,
+      moderatorName: moderatorProfile.name,
+      setupSessionId: setupSession.localId,
+      panelists: debate.panelists.map(function (p) {
+        var prof = getMateProfile(mateCtx, p.mateId);
+        return { mateId: p.mateId, name: prof.name };
+      }),
+    };
+    // Send directly to the requesting ws (session switch may not have propagated yet)
+    sendTo(ws, preparingMsg);
+    // Also broadcast to any other clients on either session
+    sendToSession(session.localId, preparingMsg);
+    sendToSession(setupSession.localId, preparingMsg);
+
+    // Start the setup skill session
+    setupSession.history.push({ type: "user_message", text: craftingPrompt });
+    sm.appendToSessionFile(setupSession, { type: "user_message", text: craftingPrompt });
+    sendToSession(setupSession.localId, { type: "user_message", text: craftingPrompt });
+    setupSession.isProcessing = true;
+    onProcessingChanged();
+    setupSession.sentToolResults = {};
+    sendToSession(setupSession.localId, { type: "status", status: "processing" });
+    sdk.startQuery(setupSession, craftingPrompt, undefined, getLinuxUserForSession(setupSession));
+  }
+
+  function startDebateLive(session) {
+    var debate = session._debate;
+    if (!debate || debate.phase === "live") return;
+
+    debate.phase = "live";
+    debate.turnInProgress = true;
+    debate.round = 1;
+
+    var mateCtx = debate.mateCtx;
+    var moderatorProfile = getMateProfile(mateCtx, debate.moderatorId);
+
+    // Create a dedicated debate session, grouped with the setup session
+    var debateSession = sm.createSession();
+    debateSession.title = debate.topic.slice(0, 50);
+    debateSession.loop = { active: true, iteration: 1, role: "debate", loopId: debate.debateId, name: debate.topic.slice(0, 40), source: "debate", startedAt: debate.setupStartedAt || Date.now() };
+    // Assign cliSessionId manually so saveSessionFile works (no SDK query for debate sessions)
+    if (!debateSession.cliSessionId) {
+      debateSession.cliSessionId = require("crypto").randomUUID();
+    }
+    sm.saveSessionFile(debateSession);
+    sm.switchSession(debateSession.localId, null, hydrateImageRefs);
+    debate.liveSessionId = debateSession.localId;
+
+    // Move _debate to the new session so all debate logic uses it
+    debateSession._debate = debate;
+    delete session._debate;
+    // Clear persisted state from setup session, persist on live session
+    session.debateState = null;
+    sm.saveSessionFile(session);
+    persistDebateState(debateSession);
+
+    // Save to session history
+    var debateStartEntry = {
+      type: "debate_started",
+      topic: debate.topic,
+      format: debate.format,
+      moderatorId: debate.moderatorId,
+      moderatorName: moderatorProfile.name,
+      panelists: debate.panelists.map(function (p) {
+        var prof = getMateProfile(mateCtx, p.mateId);
+        return { mateId: p.mateId, name: prof.name, role: p.role, avatarColor: prof.avatarColor, avatarStyle: prof.avatarStyle, avatarSeed: prof.avatarSeed };
+      }),
+    };
+    debateSession.history.push(debateStartEntry);
+    sm.appendToSessionFile(debateSession, debateStartEntry);
+
+    // Notify clients (same data as history entry)
+    sendToSession(debateSession.localId, debateStartEntry);
+
+    // Signal moderator's first turn
+    sendToSession(debateSession.localId, {
+      type: "debate_turn",
+      mateId: debate.moderatorId,
+      mateName: moderatorProfile.name,
+      role: "moderator",
+      round: debate.round,
+      avatarColor: moderatorProfile.avatarColor,
+      avatarStyle: moderatorProfile.avatarStyle,
+      avatarSeed: moderatorProfile.avatarSeed,
+    });
+
+    // Create moderator mention session
+    var claudeMd = loadMateClaudeMd(mateCtx, debate.moderatorId);
+    var digests = loadMateDigests(mateCtx, debate.moderatorId);
+    var moderatorContext = buildModeratorContext(debate) + digests;
+
+    sdk.createMentionSession({
+      claudeMd: claudeMd,
+      initialContext: moderatorContext,
+      initialMessage: "Begin the debate on: " + debate.topic,
+      onActivity: function (activity) {
+        if (debateSession._debate && debateSession._debate.phase !== "ended") {
+          sendToSession(debateSession.localId, { type: "debate_activity", mateId: debate.moderatorId, activity: activity });
+        }
+      },
+      onDelta: function (delta) {
+        if (debateSession._debate && debateSession._debate.phase !== "ended") {
+          sendToSession(debateSession.localId, { type: "debate_stream", mateId: debate.moderatorId, mateName: moderatorProfile.name, delta: delta });
+        }
+      },
+      onDone: function (fullText) {
+        handleModeratorTurnDone(debateSession, fullText);
+      },
+      onError: function (errMsg) {
+        console.error("[debate] Moderator error:", errMsg);
+        endDebate(debateSession, "error");
+      },
+      canUseTool: buildDebateToolHandler(debateSession),
+    }).then(function (mentionSession) {
+      if (mentionSession) {
+        debate.moderatorSession = mentionSession;
+      }
+    }).catch(function (err) {
+      console.error("[debate] Failed to create moderator session:", err.message || err);
+      endDebate(debateSession, "error");
+    });
+  }
+
+  function handleModeratorTurnDone(session, fullText) {
+    var debate = session._debate;
+    if (!debate || debate.phase === "ended") return;
+
+    debate.turnInProgress = false;
+
+    // Record in debate history
+    var moderatorProfile = getMateProfile(debate.mateCtx, debate.moderatorId);
+    debate.history.push({ speaker: "moderator", mateId: debate.moderatorId, mateName: moderatorProfile.name, text: fullText });
+
+    // Save to session history
+    var turnEntry = { type: "debate_turn_done", mateId: debate.moderatorId, mateName: moderatorProfile.name, role: "moderator", round: debate.round, text: fullText, avatarStyle: moderatorProfile.avatarStyle, avatarSeed: moderatorProfile.avatarSeed, avatarColor: moderatorProfile.avatarColor };
+    session.history.push(turnEntry);
+    sm.appendToSessionFile(session, turnEntry);
+    sendToSession(session.localId, turnEntry);
+
+    // Check if user stopped the debate during this turn
+    if (debate.phase === "ending") {
+      endDebate(session, "user_stopped");
+      return;
+    }
+
+    // Detect @mentions
+    console.log("[debate] nameMap keys:", JSON.stringify(Object.keys(debate.nameMap)));
+    console.log("[debate] moderator text (last 200):", fullText.slice(-200));
+    var mentionedIds = detectMentions(fullText, debate.nameMap);
+    console.log("[debate] detected mentions:", JSON.stringify(mentionedIds));
+
+    if (mentionedIds.length === 0) {
+      // No mentions = moderator wants to conclude. Ask user to confirm.
+      console.log("[debate] No mentions detected, requesting user confirmation to end.");
+      debate.turnInProgress = false;
+      debate.awaitingConcludeConfirm = true;
+      var concludeEntry = { type: "debate_conclude_confirm", topic: debate.topic, round: debate.round };
+      session.history.push(concludeEntry);
+      sm.appendToSessionFile(session, concludeEntry);
+      sendToSession(session.localId, concludeEntry);
+      return;
+    }
+
+    // Check for pending user comment before triggering panelist
+    if (debate.pendingComment) {
+      injectUserComment(session);
+      return;
+    }
+
+    // Trigger the first mentioned panelist
+    triggerPanelist(session, mentionedIds[0], fullText);
+  }
+
+  function triggerPanelist(session, mateId, moderatorText) {
+    var debate = session._debate;
+    if (!debate || debate.phase === "ended") return;
+
+    debate.turnInProgress = true;
+    debate._currentTurnMateId = mateId;
+    debate._currentTurnText = "";
+
+    var profile = getMateProfile(debate.mateCtx, mateId);
+    var panelistInfo = null;
+    for (var i = 0; i < debate.panelists.length; i++) {
+      if (debate.panelists[i].mateId === mateId) {
+        panelistInfo = debate.panelists[i];
+        break;
+      }
+    }
+    if (!panelistInfo) {
+      console.error("[debate] Panelist not found:", mateId);
+      debate._currentTurnMateId = null;
+      // Feed error back to moderator
+      feedBackToModerator(session, mateId, "[This panelist is not part of the debate panel.]");
+      return;
+    }
+
+    // Notify clients of new turn
+    sendToSession(session.localId, {
+      type: "debate_turn",
+      mateId: mateId,
+      mateName: profile.name,
+      role: panelistInfo.role,
+      round: debate.round,
+      avatarColor: profile.avatarColor,
+      avatarStyle: profile.avatarStyle,
+      avatarSeed: profile.avatarSeed,
+    });
+
+    var panelistCallbacks = {
+      onActivity: function (activity) {
+        if (session._debate && session._debate.phase !== "ended") {
+          sendToSession(session.localId, { type: "debate_activity", mateId: mateId, activity: activity });
+        }
+      },
+      onDelta: function (delta) {
+        if (session._debate && session._debate.phase !== "ended") {
+          debate._currentTurnText += delta;
+          sendToSession(session.localId, { type: "debate_stream", mateId: mateId, mateName: profile.name, delta: delta });
+        }
+      },
+      onDone: function (fullText) {
+        handlePanelistTurnDone(session, mateId, fullText);
+      },
+      onError: function (errMsg) {
+        console.error("[debate] Panelist error for " + mateId + ":", errMsg);
+        debate.turnInProgress = false;
+        // Feed error back to moderator so the debate can continue
+        feedBackToModerator(session, mateId, "[" + profile.name + " encountered an error and could not respond. Please continue with other panelists or wrap up.]");
+      },
+    };
+
+    // Check for existing session
+    var existing = debate.panelistSessions[mateId];
+    if (existing && existing.isAlive()) {
+      // Build recent debate context for continuation
+      var recentHistory = "";
+      var lastPanelistIdx = -1;
+      for (var hi = debate.history.length - 1; hi >= 0; hi--) {
+        if (debate.history[hi].mateId === mateId) {
+          lastPanelistIdx = hi;
+          break;
+        }
+      }
+      if (lastPanelistIdx >= 0 && lastPanelistIdx < debate.history.length - 1) {
+        recentHistory = "\n\n[Debate turns since your last response:]\n---\n";
+        for (var hj = lastPanelistIdx + 1; hj < debate.history.length; hj++) {
+          var h = debate.history[hj];
+          recentHistory += h.mateName + " (" + (h.speaker === "moderator" ? "moderator" : h.role || h.speaker) + "): " + h.text.substring(0, 500) + "\n\n";
+        }
+        recentHistory += "---";
+      }
+      var continuationMsg = recentHistory + "\n\n[The moderator is now addressing you. Please respond.]\n\nModerator said:\n" + moderatorText;
+      existing.pushMessage(continuationMsg, panelistCallbacks);
+    } else {
+      // Create new panelist session
+      var claudeMd = loadMateClaudeMd(debate.mateCtx, mateId);
+      var digests = loadMateDigests(debate.mateCtx, mateId);
+      var panelistContext = buildPanelistContext(debate, panelistInfo) + digests;
+
+      // Include debate history so far for context
+      var historyContext = "";
+      if (debate.history.length > 0) {
+        historyContext = "\n\n[Debate so far:]\n---\n";
+        for (var hk = 0; hk < debate.history.length; hk++) {
+          var he = debate.history[hk];
+          historyContext += he.mateName + " (" + (he.speaker === "moderator" ? "moderator" : he.role || he.speaker) + "): " + he.text.substring(0, 500) + "\n\n";
+        }
+        historyContext += "---";
+      }
+
+      sdk.createMentionSession({
+        claudeMd: claudeMd,
+        initialContext: panelistContext + historyContext,
+        initialMessage: "The moderator addresses you:\n\n" + moderatorText,
+        onActivity: panelistCallbacks.onActivity,
+        onDelta: panelistCallbacks.onDelta,
+        onDone: panelistCallbacks.onDone,
+        onError: panelistCallbacks.onError,
+        canUseTool: buildDebateToolHandler(session),
+      }).then(function (mentionSession) {
+        if (mentionSession) {
+          debate.panelistSessions[mateId] = mentionSession;
+        }
+      }).catch(function (err) {
+        console.error("[debate] Failed to create panelist session for " + mateId + ":", err.message || err);
+        debate.turnInProgress = false;
+        feedBackToModerator(session, mateId, "[" + profile.name + " is unavailable. Please continue with other panelists or wrap up.]");
+      });
+    }
+  }
+
+  function handlePanelistTurnDone(session, mateId, fullText) {
+    var debate = session._debate;
+    if (!debate || debate.phase === "ended") return;
+
+    debate.turnInProgress = false;
+    debate._currentTurnMateId = null;
+    debate._currentTurnText = "";
+
+    var profile = getMateProfile(debate.mateCtx, mateId);
+    var panelistInfo = null;
+    for (var i = 0; i < debate.panelists.length; i++) {
+      if (debate.panelists[i].mateId === mateId) {
+        panelistInfo = debate.panelists[i];
+        break;
+      }
+    }
+
+    // Record in debate history
+    debate.history.push({ speaker: "panelist", mateId: mateId, mateName: profile.name, role: panelistInfo ? panelistInfo.role : "", text: fullText });
+
+    // Save to session history
+    var turnEntry = { type: "debate_turn_done", mateId: mateId, mateName: profile.name, role: panelistInfo ? panelistInfo.role : "", round: debate.round, text: fullText, avatarStyle: profile.avatarStyle, avatarSeed: profile.avatarSeed, avatarColor: profile.avatarColor };
+    session.history.push(turnEntry);
+    sm.appendToSessionFile(session, turnEntry);
+    sendToSession(session.localId, turnEntry);
+
+    // Check if user stopped the debate
+    if (debate.phase === "ending") {
+      endDebate(session, "user_stopped");
+      return;
+    }
+
+    // Check for pending user comment
+    if (debate.pendingComment) {
+      injectUserComment(session);
+      return;
+    }
+
+    // Feed panelist response back to moderator
+    feedBackToModerator(session, mateId, fullText);
+  }
+
+  function feedBackToModerator(session, panelistMateId, panelistText) {
+    var debate = session._debate;
+    if (!debate || !debate.moderatorSession || debate.phase === "ended") return;
+
+    debate.round++;
+    debate.turnInProgress = true;
+
+    var panelistProfile = getMateProfile(debate.mateCtx, panelistMateId);
+    var panelistInfo = null;
+    for (var i = 0; i < debate.panelists.length; i++) {
+      if (debate.panelists[i].mateId === panelistMateId) {
+        panelistInfo = debate.panelists[i];
+        break;
+      }
+    }
+
+    var moderatorProfile = getMateProfile(debate.mateCtx, debate.moderatorId);
+
+    // Notify clients of moderator turn
+    sendToSession(session.localId, {
+      type: "debate_turn",
+      mateId: debate.moderatorId,
+      mateName: moderatorProfile.name,
+      role: "moderator",
+      round: debate.round,
+      avatarColor: moderatorProfile.avatarColor,
+      avatarStyle: moderatorProfile.avatarStyle,
+      avatarSeed: moderatorProfile.avatarSeed,
+    });
+
+    var feedText = "[Panelist Response]\n\n" +
+      "@" + panelistProfile.name + " (" + (panelistInfo ? panelistInfo.role : "panelist") + ") responded:\n" +
+      panelistText + "\n\n" +
+      "Continue the debate. Call on the next panelist with @TheirName, or provide a closing summary (without any @mentions) to end the debate.";
+
+    debate.moderatorSession.pushMessage(feedText, buildModeratorCallbacks(session));
+  }
+
+  function buildModeratorCallbacks(session) {
+    var debate = session._debate;
+    var moderatorProfile = getMateProfile(debate.mateCtx, debate.moderatorId);
+    return {
+      onActivity: function (activity) {
+        if (session._debate && session._debate.phase !== "ended") {
+          sendToSession(session.localId, { type: "debate_activity", mateId: debate.moderatorId, activity: activity });
+        }
+      },
+      onDelta: function (delta) {
+        if (session._debate && session._debate.phase !== "ended") {
+          sendToSession(session.localId, { type: "debate_stream", mateId: debate.moderatorId, mateName: moderatorProfile.name, delta: delta });
+        }
+      },
+      onDone: function (fullText) {
+        handleModeratorTurnDone(session, fullText);
+      },
+      onError: function (errMsg) {
+        console.error("[debate] Moderator error:", errMsg);
+        endDebate(session, "error");
+      },
+    };
+  }
+
+  function handleDebateComment(ws, msg) {
+    var session = getSessionForWs(ws);
+    if (!session) return;
+
+    var debate = session._debate;
+    if (!debate || debate.phase !== "live") {
+      sendTo(ws, { type: "debate_error", error: "No active debate." });
+      return;
+    }
+
+    // If awaiting conclude confirmation, re-send the confirm prompt instead
+    if (debate.awaitingConcludeConfirm) {
+      sendTo(ws, { type: "debate_conclude_confirm", topic: debate.topic, round: debate.round });
+      return;
+    }
+
+    if (!msg.text) return;
+
+    debate.pendingComment = { text: msg.text };
+    sendToSession(session.localId, { type: "debate_comment_queued", text: msg.text });
+
+    // If a panelist turn is in progress, abort it and go straight to moderator
+    if (debate.turnInProgress && debate._currentTurnMateId && debate._currentTurnMateId !== debate.moderatorId) {
+      var abortMateId = debate._currentTurnMateId;
+      console.log("[debate] User raised hand during panelist turn, aborting " + abortMateId);
+
+      // Close the panelist's mention session to stop generation
+      if (debate.panelistSessions[abortMateId]) {
+        try { debate.panelistSessions[abortMateId].close(); } catch (e) {}
+        delete debate.panelistSessions[abortMateId];
+      }
+
+      // Save partial text as interrupted turn
+      var partialText = debate._currentTurnText || "(interrupted by audience)";
+      var profile = getMateProfile(debate.mateCtx, abortMateId);
+      var panelistInfo = null;
+      for (var pi = 0; pi < debate.panelists.length; pi++) {
+        if (debate.panelists[pi].mateId === abortMateId) { panelistInfo = debate.panelists[pi]; break; }
+      }
+
+      sendToSession(session.localId, {
+        type: "debate_turn_done",
+        mateId: abortMateId,
+        mateName: profile.name,
+        role: panelistInfo ? panelistInfo.role : "",
+        text: partialText,
+        interrupted: true,
+        avatarStyle: profile.avatarStyle,
+        avatarSeed: profile.avatarSeed,
+        avatarColor: profile.avatarColor,
+      });
+
+      var turnEntry = { type: "debate_turn_done", mateId: abortMateId, mateName: profile.name, role: panelistInfo ? panelistInfo.role : "", round: debate.round, text: partialText, avatarStyle: profile.avatarStyle, avatarSeed: profile.avatarSeed, avatarColor: profile.avatarColor, interrupted: true };
+      session.history.push(turnEntry);
+      sm.appendToSessionFile(session, turnEntry);
+      debate.history.push({ speaker: "panelist", mateId: abortMateId, mateName: profile.name, role: panelistInfo ? panelistInfo.role : "", text: partialText });
+
+      debate.turnInProgress = false;
+      debate._currentTurnMateId = null;
+      debate._currentTurnText = "";
+    }
+
+    // Inject to moderator immediately if no turn in progress (or just aborted)
+    if (!debate.turnInProgress) {
+      injectUserComment(session);
+    }
+    // If moderator is currently speaking, pendingComment will be picked up after moderator's onDone
+  }
+
+  function injectUserComment(session) {
+    var debate = session._debate;
+    if (!debate || !debate.pendingComment || !debate.moderatorSession || debate.phase === "ended") return;
+
+    var comment = debate.pendingComment;
+    debate.pendingComment = null;
+
+    // Record in debate history
+    debate.history.push({ speaker: "user", mateId: null, mateName: "User", text: comment.text });
+
+    var commentEntry = { type: "debate_comment_injected", text: comment.text };
+    session.history.push(commentEntry);
+    sm.appendToSessionFile(session, commentEntry);
+    sendToSession(session.localId, commentEntry);
+
+    // Feed to moderator
+    debate.turnInProgress = true;
+    var moderatorProfile = getMateProfile(debate.mateCtx, debate.moderatorId);
+
+    sendToSession(session.localId, {
+      type: "debate_turn",
+      mateId: debate.moderatorId,
+      mateName: moderatorProfile.name,
+      role: "moderator",
+      round: debate.round,
+      avatarColor: moderatorProfile.avatarColor,
+      avatarStyle: moderatorProfile.avatarStyle,
+      avatarSeed: moderatorProfile.avatarSeed,
+    });
+
+    var feedText = "[The user raised their hand and said:]\n" +
+      comment.text + "\n" +
+      "[Please acknowledge this and weave it into the discussion. Then continue the debate.]";
+
+    debate.moderatorSession.pushMessage(feedText, buildModeratorCallbacks(session));
+  }
+
+  function handleDebateStop(ws) {
+    var session = getSessionForWs(ws);
+    if (!session) return;
+
+    var debate = session._debate;
+    if (!debate || debate.phase !== "live") return;
+
+    if (debate.turnInProgress) {
+      // Let current turn finish, then end
+      debate.phase = "ending";
+    } else {
+      endDebate(session, "user_stopped");
+    }
+  }
+
+  // Rebuild _debate from session history (for resume after server restart)
+  function rebuildDebateState(session, ws) {
+    // Find debate_started entry in history
+    var startEntry = null;
+    var endEntry = null;
+    var concludeEntry = null;
+    var lastRound = 1;
+    for (var i = 0; i < session.history.length; i++) {
+      var h = session.history[i];
+      if (h.type === "debate_started") startEntry = h;
+      if (h.type === "debate_ended") endEntry = h;
+      if (h.type === "debate_conclude_confirm") concludeEntry = h;
+      if (h.type === "debate_turn_done" && h.round) lastRound = h.round;
+    }
+    if (!startEntry) return null;
+
+    var userId = ws._clayUser ? ws._clayUser.id : null;
+    var mateCtx = matesModule.buildMateCtx(userId);
+
+    var debate = {
+      phase: endEntry ? "ended" : "live",
+      topic: startEntry.topic || "",
+      format: startEntry.format || "free_discussion",
+      context: "",
+      specialRequests: null,
+      moderatorId: startEntry.moderatorId,
+      panelists: (startEntry.panelists || []).map(function (p) {
+        return { mateId: p.mateId, role: p.role || "", brief: p.brief || "" };
+      }),
+      mateCtx: mateCtx,
+      moderatorSession: null,
+      panelistSessions: {},
+      nameMap: buildDebateNameMap(
+        (startEntry.panelists || []).map(function (p) { return { mateId: p.mateId, role: p.role || "" }; }),
+        mateCtx
+      ),
+      turnInProgress: false,
+      pendingComment: null,
+      round: lastRound,
+      history: [],
+      awaitingConcludeConfirm: !endEntry && !!concludeEntry,
+      debateId: (session.loop && session.loop.loopId) || "debate_rebuilt",
+    };
+
+    // Rebuild debate.history from session history turn entries
+    for (var j = 0; j < session.history.length; j++) {
+      var entry = session.history[j];
+      if (entry.type === "debate_turn_done") {
+        debate.history.push({
+          speaker: entry.role === "moderator" ? "moderator" : "panelist",
+          mateId: entry.mateId,
+          mateName: entry.mateName,
+          role: entry.role || "",
+          text: entry.text || "",
+        });
+      }
+    }
+
+    // If no endEntry and no concludeEntry, check if last moderator turn had no mentions (implicit conclude)
+    if (!endEntry && !concludeEntry && debate.history.length > 0) {
+      var lastTurn = debate.history[debate.history.length - 1];
+      if (lastTurn.speaker === "moderator" && lastTurn.text) {
+        var rebuildMentions = detectMentions(lastTurn.text, debate.nameMap);
+        if (rebuildMentions.length === 0) {
+          debate.awaitingConcludeConfirm = true;
+          console.log("[debate] Last moderator turn had no mentions, setting awaitingConcludeConfirm.");
+        }
+      }
+    }
+
+    session._debate = debate;
+    console.log("[debate] Rebuilt debate state from history. Topic:", debate.topic, "Phase:", debate.phase, "Turns:", debate.history.length);
+    return debate;
+  }
+
+  function handleDebateConcludeResponse(ws, msg) {
+    var session = getSessionForWs(ws);
+    if (!session) return;
+    var debate = session._debate;
+
+    // If _debate is gone (server restart), try to rebuild from history
+    if (!debate) {
+      debate = rebuildDebateState(session, ws);
+      if (!debate) {
+        console.log("[debate] Cannot rebuild debate state for resume.");
+        return;
+      }
+    }
+
+    // Allow resume from both "live + awaiting confirm" and "ended" states
+    var isLiveConfirm = debate.phase === "live" && debate.awaitingConcludeConfirm;
+    var isResume = debate.phase === "ended" && msg.action === "continue";
+    if (!isLiveConfirm && !isResume) return;
+
+    debate.awaitingConcludeConfirm = false;
+
+    if (msg.action === "end") {
+      endDebate(session, "natural");
+      return;
+    }
+
+    if (msg.action === "continue") {
+      var wasEnded = debate.phase === "ended";
+      debate.phase = "live";
+      var instruction = (msg.text || "").trim();
+      var mateCtx = debate.mateCtx || matesModule.buildMateCtx(ws._clayUser ? ws._clayUser.id : null);
+      debate.mateCtx = mateCtx;
+      var moderatorProfile = getMateProfile(mateCtx, debate.moderatorId);
+
+      // Record user's resume message if provided
+      if (instruction) {
+        var resumeEntry = { type: "debate_user_resume", text: instruction };
+        session.history.push(resumeEntry);
+        sm.appendToSessionFile(session, resumeEntry);
+        sendToSession(session.localId, resumeEntry);
+      }
+
+      // Notify clients debate is back live and persist to history
+      var resumedMsg = {
+        type: "debate_resumed",
+        topic: debate.topic,
+        round: debate.round,
+        moderatorId: debate.moderatorId,
+        moderatorName: moderatorProfile.name,
+        panelists: debate.panelists.map(function (p) {
+          var prof = getMateProfile(mateCtx, p.mateId);
+          return { mateId: p.mateId, name: prof.name, role: p.role, avatarColor: prof.avatarColor, avatarStyle: prof.avatarStyle, avatarSeed: prof.avatarSeed };
+        }),
+      };
+      session.history.push(resumedMsg);
+      sm.appendToSessionFile(session, resumedMsg);
+      sendToSession(session.localId, resumedMsg);
+
+      debate.turnInProgress = true;
+      sendToSession(session.localId, {
+        type: "debate_turn",
+        mateId: debate.moderatorId,
+        mateName: moderatorProfile.name,
+        role: "moderator",
+        round: debate.round,
+        avatarColor: moderatorProfile.avatarColor,
+        avatarStyle: moderatorProfile.avatarStyle,
+        avatarSeed: moderatorProfile.avatarSeed,
+      });
+
+      var resumePrompt = instruction
+        ? "[The audience has requested the debate continue with the following direction]\nUser: " + instruction + "\n\n[As moderator, acknowledge this input and call on a panelist with @TheirName to continue the discussion.]"
+        : "[The audience has requested the debate continue. Call on the next panelist with @TheirName to explore additional perspectives.]";
+
+      // If resuming from ended state, moderator session may be dead. Create a new one.
+      if (wasEnded || !debate.moderatorSession || !debate.moderatorSession.isAlive()) {
+        console.log("[debate] Creating new moderator session for resume");
+        var claudeMd = loadMateClaudeMd(mateCtx, debate.moderatorId);
+        var digests = loadMateDigests(mateCtx, debate.moderatorId);
+        var moderatorContext = buildModeratorContext(debate) + digests;
+
+        // Include debate history so moderator has context
+        moderatorContext += "\n\nDebate history so far:\n---\n";
+        for (var hi = 0; hi < debate.history.length; hi++) {
+          var h = debate.history[hi];
+          moderatorContext += (h.mateName || h.speaker || "Unknown") + " (" + (h.role || "") + "): " + (h.text || "").slice(0, 500) + "\n\n";
+        }
+        moderatorContext += "---\n";
+
+        sdk.createMentionSession({
+          claudeMd: claudeMd,
+          initialContext: moderatorContext,
+          initialMessage: resumePrompt,
+          onActivity: function (activity) {
+            if (session._debate && session._debate.phase !== "ended") {
+              sendToSession(session.localId, { type: "debate_activity", mateId: debate.moderatorId, activity: activity });
+            }
+          },
+          onDelta: function (delta) {
+            if (session._debate && session._debate.phase !== "ended") {
+              sendToSession(session.localId, { type: "debate_stream", mateId: debate.moderatorId, mateName: moderatorProfile.name, delta: delta });
+            }
+          },
+          onDone: function (fullText) {
+            handleModeratorTurnDone(session, fullText);
+          },
+          onError: function (errMsg) {
+            console.error("[debate] Moderator resume error:", errMsg);
+            endDebate(session, "error");
+          },
+          canUseTool: buildDebateToolHandler(session),
+        }).then(function (mentionSession) {
+          if (mentionSession) {
+            debate.moderatorSession = mentionSession;
+          }
+        }).catch(function (err) {
+          console.error("[debate] Failed to create resume moderator session:", err.message || err);
+          endDebate(session, "error");
+        });
+      } else {
+        debate.moderatorSession.pushMessage(resumePrompt, buildModeratorCallbacks(session));
+      }
+      return;
+    }
+  }
+
+  function endDebate(session, reason) {
+    var debate = session._debate;
+    if (!debate || debate.phase === "ended") return;
+
+    debate.phase = "ended";
+    debate.turnInProgress = false;
+    persistDebateState(session);
+
+    // Clean up brief watcher if still active
+    if (debate._briefWatcher) {
+      try { debate._briefWatcher.close(); } catch (e) {}
+      debate._briefWatcher = null;
+    }
+
+    // Notify clients
+    sendToSession(session.localId, {
+      type: "debate_ended",
+      reason: reason,
+      rounds: debate.round,
+      topic: debate.topic,
+    });
+
+    // Save to session history
+    var endEntry = { type: "debate_ended", topic: debate.topic, rounds: debate.round, reason: reason };
+    session.history.push(endEntry);
+    sm.appendToSessionFile(session, endEntry);
+
+    // Generate digests for all participants
+    digestDebateParticipant(session, debate.moderatorId, debate, "moderator");
+    for (var i = 0; i < debate.panelists.length; i++) {
+      digestDebateParticipant(session, debate.panelists[i].mateId, debate, debate.panelists[i].role);
+    }
+  }
+
+  function digestDebateParticipant(session, mateId, debate, role) {
+    var mentionSession = null;
+    if (mateId === debate.moderatorId) {
+      mentionSession = debate.moderatorSession;
+    } else {
+      mentionSession = debate.panelistSessions[mateId];
+    }
+    if (!mentionSession || !mentionSession.isAlive()) return;
+
+    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");
+
+    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),
+          };
+        }
+
+        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);
+        }
+
+        // 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) ---
   function broadcastPresence() {
     if (!usersModule.isMultiUser()) return;
@@ -3908,6 +5284,12 @@ function createProjectContext(opts) {
 
   // --- WS disconnection handler ---
   function handleDisconnection(ws) {
+    // Persist last active session for this user before cleanup
+    if (ws._clayActiveSession) {
+      var dcPresKey = ws._clayUser ? ws._clayUser.id : "_default";
+      var dcExisting = userPresence.getPresence(slug, dcPresKey);
+      userPresence.setPresence(slug, dcPresKey, ws._clayActiveSession, dcExisting ? dcExisting.mateDm : null);
+    }
     tm.detachAll(ws);
     clients.delete(ws);
     if (clients.size === 0) {
@@ -4126,15 +5508,38 @@ function createProjectContext(opts) {
         var scopeFlag = scope === "global" ? "--global" : "--project";
         var skillSpawnOpts = {
           cwd: spawnCwd,
-          stdio: "ignore",
+          stdio: ["ignore", "pipe", "pipe"],
           detached: false,
         };
         if (skillUserInfo) {
           skillSpawnOpts.uid = skillUserInfo.uid;
           skillSpawnOpts.gid = skillUserInfo.gid;
         }
+        console.log("[skill-install] spawning: npx skills add " + url + " --skill " + skill + " --yes " + scopeFlag + " (cwd: " + spawnCwd + ")");
         var child = spawn("npx", ["skills", "add", url, "--skill", skill, "--yes", scopeFlag], skillSpawnOpts);
+        var stdoutBuf = "";
+        var stderrBuf = "";
+        child.stdout.on("data", function (chunk) {
+          stdoutBuf += chunk.toString();
+          console.log("[skill-install] " + skill + " stdout chunk: " + chunk.toString().trim().slice(0, 500));
+        });
+        child.stderr.on("data", function (chunk) {
+          stderrBuf += chunk.toString();
+          console.log("[skill-install] " + skill + " stderr chunk: " + chunk.toString().trim().slice(0, 500));
+        });
+        // Timeout after 60 seconds
+        var installTimeout = setTimeout(function () {
+          console.error("[skill-install] " + skill + " timed out after 60s, killing process");
+          try { child.kill("SIGTERM"); } catch (e) {}
+          try {
+            send({ type: "skill_installed", skill: skill, scope: scope, success: false, error: "Installation timed out after 60 seconds" });
+          } catch (e) {}
+        }, 60000);
         child.on("close", function (code) {
+          clearTimeout(installTimeout);
+          console.log("[skill-install] " + skill + " exited with code " + code + " (stdout=" + stdoutBuf.length + "b, stderr=" + stderrBuf.length + "b)");
+          if (stdoutBuf) console.log("[skill-install] stdout: " + stdoutBuf.slice(0, 2000));
+          if (stderrBuf) console.log("[skill-install] stderr: " + stderrBuf.slice(0, 2000));
           try {
             var success = code === 0;
             send({
@@ -4149,6 +5554,8 @@ function createProjectContext(opts) {
           }
         });
         child.on("error", function (err) {
+          clearTimeout(installTimeout);
+          console.error("[skill-install] " + skill + " spawn error:", err.message || err);
           try {
             send({
               type: "skill_installed",
@@ -4158,7 +5565,7 @@ function createProjectContext(opts) {
               error: err.message,
             });
           } catch (e) {
-            console.error("[project] skill_installed error send failed:", e.message || e);
+            console.error("[skill-install] " + skill + " send failed:", e.message || e);
           }
         });
         res.writeHead(200, { "Content-Type": "application/json" });
@@ -4346,6 +5753,7 @@ function createProjectContext(opts) {
           (function (skill) {
             var installedVer = getInstalledVersion(skill.name);
             var installed = !!installedVer;
+            console.log("[skill-check] " + skill.name + " installed=" + installed + " localVersion=" + (installedVer || "none"));
             // Convert GitHub repo URL to raw SKILL.md URL
             var rawUrl = "";
             var ghMatch = skill.url.match(/github\.com\/([^/]+)\/([^/]+)/);
@@ -4353,13 +5761,16 @@ function createProjectContext(opts) {
               rawUrl = "https://raw.githubusercontent.com/" + ghMatch[1] + "/" + ghMatch[2] + "/main/SKILL.md";
             }
             if (!rawUrl) {
+              console.log("[skill-check] " + skill.name + " no valid GitHub URL, skipping remote check");
               results.push({ name: skill.name, installed: installed, installedVersion: installedVer, remoteVersion: "", status: installed ? "ok" : "missing" });
               finishOne();
               return;
             }
+            console.log("[skill-check] " + skill.name + " fetching remote: " + rawUrl);
             // Fetch remote SKILL.md
             var https = require("https");
             https.get(rawUrl, function (resp) {
+              console.log("[skill-check] " + skill.name + " remote response status=" + resp.statusCode);
               var data = "";
               resp.on("data", function (chunk) { data += chunk; });
               resp.on("end", function () {
@@ -4371,15 +5782,17 @@ function createProjectContext(opts) {
                   } else if (remoteVer && compareVersions(installedVer, remoteVer) < 0) {
                     status = "outdated";
                   }
+                  console.log("[skill-check] " + skill.name + " remoteVersion=" + remoteVer + " status=" + status);
                   results.push({ name: skill.name, installed: installed, installedVersion: installedVer, remoteVersion: remoteVer, status: status });
                   finishOne();
                 } catch (e) {
-                  console.error("[project] Skill version check failed for " + skill.name + ":", e.message || e);
+                  console.error("[skill-check] " + skill.name + " version parse failed:", e.message || e);
                   results.push({ name: skill.name, installed: installed, installedVersion: installedVer, remoteVersion: "", status: installed ? "ok" : "error" });
                   finishOne();
                 }
               });
-            }).on("error", function () {
+            }).on("error", function (err) {
+              console.error("[skill-check] " + skill.name + " fetch error:", err.message || err);
               results.push({ name: skill.name, installed: installed, installedVersion: installedVer, remoteVersion: "", status: installed ? "ok" : "missing" });
               finishOne();
             });