clay-server 2.22.3-beta.1 → 2.23.0-beta.2

package/lib/project.js

@@ -1486,6 +1486,10 @@ function createProjectContext(opts) {
       handleDebateConcludeResponse(ws, msg);
       return;
     }
+    if (msg.type === "debate_confirm_brief") {
+      handleDebateConfirmBrief(ws);
+      return;
+    }
 
     // --- Knowledge file management ---
     if (msg.type === "knowledge_list") {
@@ -4234,6 +4238,9 @@ function createProjectContext(opts) {
 
         sendToSession(session.localId, { type: "mention_done", mateId: msg.mateId });
 
+        // Check if the mate wrote a debate brief during this turn
+        checkForDmDebateBrief(session, msg.mateId, mateCtx);
+
         // Generate session digest for mate's long-term memory
         digestMentionSession(session, msg.mateId, mateCtx, fullText, msg.text);
       },
@@ -4906,10 +4913,33 @@ function createProjectContext(opts) {
         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);
+        // If debate was started from DM (no setupSessionId), go to reviewing phase
+        if (!debate.setupSessionId) {
+          console.log("[debate] Brief picked up from DM, entering review phase. Topic:", debate.topic);
+          debate.phase = "reviewing";
+          persistDebateState(session);
+
+          var moderatorProfile = getMateProfile(mateCtx, debate.moderatorId);
+          var briefReadyMsg = {
+            type: "debate_brief_ready",
+            debateId: debate.debateId,
+            topic: debate.topic,
+            format: debate.format || "free_discussion",
+            context: debate.context || "",
+            specialRequests: debate.specialRequests || null,
+            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 || "", brief: p.brief || "" };
+            }),
+          };
+          sendToSession(session.localId, briefReadyMsg);
+        } else {
+          console.log("[debate] Brief picked up, transitioning to live. Topic:", debate.topic);
+          // Transition to live (standard flow via modal/skill)
+          startDebateLive(session);
+        }
       } catch (e) {
         // File not ready yet or invalid JSON, keep watching
       }
@@ -4946,7 +4976,7 @@ function createProjectContext(opts) {
       if (!session.debateState) return;
 
       var phase = session.debateState.phase;
-      if (phase !== "preparing" && phase !== "live") return;
+      if (phase !== "preparing" && phase !== "reviewing" && phase !== "live") return;
 
       // Restore _debate from persisted state
       var debate = restoreDebateFromState(session);
@@ -4980,6 +5010,22 @@ function createProjectContext(opts) {
             return { mateId: p.mateId, name: prof.name };
           }),
         });
+      } else if (phase === "reviewing") {
+        console.log("[debate] Restoring debate (reviewing). topic:", debate.topic);
+        sendTo(ws, {
+          type: "debate_brief_ready",
+          debateId: debate.debateId,
+          topic: debate.topic,
+          format: debate.format || "free_discussion",
+          context: debate.context || "",
+          specialRequests: debate.specialRequests || null,
+          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 || "", brief: p.brief || "" };
+          }),
+        });
       } 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,
@@ -5097,6 +5143,87 @@ function createProjectContext(opts) {
     };
   }
 
+  // Check if a mate wrote a debate brief during a DM mention turn
+  function checkForDmDebateBrief(session, mateId, mateCtx) {
+    // Skip if there's already an active debate on this session
+    if (session._debate && (session._debate.phase === "preparing" || session._debate.phase === "reviewing" || session._debate.phase === "live")) return;
+
+    var debatesDir = path.join(cwd, ".clay", "debates");
+    var dirs;
+    try {
+      dirs = fs.readdirSync(debatesDir);
+    } catch (e) {
+      return; // No debates directory
+    }
+
+    for (var i = 0; i < dirs.length; i++) {
+      var briefPath = path.join(debatesDir, dirs[i], "brief.json");
+      var raw;
+      try {
+        raw = fs.readFileSync(briefPath, "utf8");
+      } catch (e) {
+        continue; // No brief.json in this dir
+      }
+
+      var brief;
+      try {
+        brief = JSON.parse(raw);
+      } catch (e) {
+        continue; // Invalid JSON
+      }
+
+      // Found a valid brief - create debate state
+      var debateId = dirs[i];
+      console.log("[debate] Found DM debate brief from mate " + mateId + ", debateId:", debateId);
+
+      // Clean up the brief file
+      try { fs.unlinkSync(briefPath); } catch (e) {}
+
+      var debate = {
+        phase: "reviewing",
+        topic: brief.topic || "Untitled debate",
+        format: brief.format || "free_discussion",
+        context: brief.context || "",
+        specialRequests: brief.specialRequests || null,
+        moderatorId: mateId,
+        panelists: (brief.panelists || []).map(function (p) {
+          return { mateId: p.mateId, role: p.role || "", brief: p.brief || "" };
+        }),
+        mateCtx: mateCtx,
+        moderatorSession: null,
+        panelistSessions: {},
+        nameMap: null,
+        turnInProgress: false,
+        pendingComment: null,
+        round: 1,
+        history: [],
+        setupSessionId: null,
+        debateId: debateId,
+        briefPath: briefPath,
+      };
+      debate.nameMap = buildDebateNameMap(debate.panelists, mateCtx);
+      session._debate = debate;
+      persistDebateState(session);
+
+      var moderatorProfile = getMateProfile(mateCtx, mateId);
+      sendToSession(session.localId, {
+        type: "debate_brief_ready",
+        debateId: debateId,
+        topic: debate.topic,
+        format: debate.format,
+        context: debate.context,
+        specialRequests: debate.specialRequests,
+        moderatorId: mateId,
+        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 || "", brief: p.brief || "" };
+        }),
+      });
+      return; // Only process first brief found
+    }
+  }
+
   function handleDebateStart(ws, msg) {
     var session = getSessionForWs(ws);
     if (!session) return;
@@ -5142,8 +5269,152 @@ function createProjectContext(opts) {
     };
     session._debate = debate;
 
-    // Create a new session for the setup skill (like Ralph crafting)
     var debateId = "debate_" + Date.now();
+    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);
+
+    debate.debateId = debateId;
+    debate.briefPath = briefPath;
+
+    if (msg.quickStart) {
+      // --- Quick Start: moderator mate generates brief from DM context ---
+      handleDebateQuickStart(ws, session, debate, msg, mateCtx, moderatorProfile, briefPath);
+    } else {
+      // --- Standard: clay-debate-setup skill ---
+      handleDebateSkillSetup(ws, session, debate, msg, mateCtx, moderatorProfile, briefPath);
+    }
+  }
+
+  // Quick start: moderator mate uses DM conversation context to generate the debate brief directly
+  function handleDebateQuickStart(ws, session, debate, msg, mateCtx, moderatorProfile, briefPath) {
+    var debateId = debate.debateId;
+
+    // Create setup session (still needed for session grouping)
+    var setupSession = sm.createSession();
+    setupSession.title = "Debate Setup: " + (msg.topic || "Quick").slice(0, 40);
+    setupSession.debateSetupMode = true;
+    setupSession.loop = { active: true, iteration: 0, role: "crafting", loopId: debateId, name: (msg.topic || "Quick").slice(0, 40), source: "debate", startedAt: Date.now() };
+    sm.saveSessionFile(setupSession);
+    sm.switchSession(setupSession.localId, null, hydrateImageRefs);
+    debate.setupSessionId = setupSession.localId;
+    debate.setupStartedAt = setupSession.loop.startedAt;
+
+    // Build DM conversation context for the moderator
+    var dmContext = msg.dmContext || "";
+
+    // Build panelist info
+    var panelistInfo = msg.panelists.map(function (p) {
+      var prof = getMateProfile(mateCtx, p.mateId);
+      return "- " + (prof.name || p.mateId) + " (ID: " + p.mateId + ", bio: " + (prof.bio || "none") + ")";
+    }).join("\n");
+
+    var quickBriefPrompt = [
+      "You are " + (moderatorProfile.name || "the moderator") + ". You were just having a DM conversation with the user, and they want to turn this into a structured debate.",
+      "",
+      "## Recent DM Conversation",
+      dmContext,
+      "",
+      "## Topic Suggestion",
+      msg.topic || "(Derive from conversation above)",
+      "",
+      "## Available Panelists",
+      panelistInfo,
+      "",
+      "## Your Task",
+      "Based on the conversation context, create a debate brief. You know the topic well because you were just discussing it.",
+      "Assign each panelist a role and perspective that will create the most productive debate.",
+      "",
+      "Output ONLY a valid JSON object (no markdown fences, no extra text):",
+      "{",
+      '  "topic": "refined debate topic",',
+      '  "format": "free_discussion",',
+      '  "context": "key context from DM conversation that panelists should know",',
+      '  "specialRequests": "any special instructions (null if none)",',
+      '  "panelists": [',
+      '    { "mateId": "...", "role": "perspective/stance", "brief": "what this panelist should argue for" }',
+      "  ]",
+      "}",
+    ].join("\n");
+
+    // Persist and start watcher
+    persistDebateState(session);
+    startDebateBriefWatcher(session, debate, briefPath);
+
+    // Notify clients
+    var preparingMsg = {
+      type: "debate_preparing",
+      topic: debate.topic || "(Setting up...)",
+      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 };
+      }),
+    };
+    sendTo(ws, preparingMsg);
+    sendToSession(session.localId, preparingMsg);
+    sendToSession(setupSession.localId, preparingMsg);
+
+    // Use moderator's own Claude identity to generate the brief via mention session
+    var claudeMd = loadMateClaudeMd(mateCtx, debate.moderatorId);
+    var digests = loadMateDigests(mateCtx, debate.moderatorId);
+
+    var briefText = "";
+    sdk.createMentionSession({
+      claudeMd: claudeMd,
+      initialContext: digests,
+      initialMessage: quickBriefPrompt,
+      onActivity: function () {},
+      onDelta: function (delta) { briefText += delta; },
+      onDone: function () {
+        try {
+          var cleaned = briefText.trim();
+          if (cleaned.indexOf("```") === 0) {
+            cleaned = cleaned.replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "").trim();
+          }
+          // Validate it is parseable JSON
+          JSON.parse(cleaned);
+          // Write brief.json for the watcher to pick up
+          fs.writeFileSync(briefPath, cleaned, "utf8");
+          console.log("[debate-quick] Moderator generated brief, wrote to " + briefPath);
+        } catch (e) {
+          console.error("[debate-quick] Failed to generate brief:", e.message);
+          console.error("[debate-quick] Raw output:", briefText.substring(0, 500));
+          // Fall back: write a minimal brief
+          var fallbackBrief = {
+            topic: debate.topic || "Discussion",
+            format: "free_discussion",
+            context: "",
+            specialRequests: null,
+            panelists: debate.panelists.map(function (p) {
+              var prof = getMateProfile(mateCtx, p.mateId);
+              return { mateId: p.mateId, role: "participant", brief: "Share your perspective on the topic." };
+            }),
+          };
+          try {
+            fs.writeFileSync(briefPath, JSON.stringify(fallbackBrief), "utf8");
+            console.log("[debate-quick] Wrote fallback brief");
+          } catch (fe) {
+            console.error("[debate-quick] Failed to write fallback brief:", fe.message);
+            endDebate(session, "error");
+          }
+        }
+      },
+      onError: function (err) {
+        console.error("[debate-quick] Moderator brief generation failed:", err);
+        endDebate(session, "error");
+      },
+    });
+  }
+
+  // Standard debate setup via clay-debate-setup skill
+  function handleDebateSkillSetup(ws, session, debate, msg, mateCtx, moderatorProfile, briefPath) {
+    var debateId = debate.debateId;
+
+    // Create a new session for the setup skill (like Ralph crafting)
     var setupSession = sm.createSession();
     setupSession.title = "Debate Setup: " + msg.topic.slice(0, 40);
     setupSession.debateSetupMode = true;
@@ -5151,7 +5422,6 @@ function createProjectContext(opts) {
     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
@@ -5160,11 +5430,6 @@ function createProjectContext(opts) {
       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" +
@@ -5180,7 +5445,6 @@ function createProjectContext(opts) {
       "## 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
@@ -5693,12 +5957,33 @@ function createProjectContext(opts) {
     debate.moderatorSession.pushMessage(feedText, buildModeratorCallbacks(session));
   }
 
+  function handleDebateConfirmBrief(ws) {
+    var session = getSessionForWs(ws);
+    if (!session) return;
+
+    var debate = session._debate;
+    if (!debate || debate.phase !== "reviewing") {
+      sendTo(ws, { type: "debate_error", error: "No debate brief to confirm." });
+      return;
+    }
+
+    console.log("[debate] User confirmed brief, transitioning to live. Topic:", debate.topic);
+    startDebateLive(session);
+  }
+
   function handleDebateStop(ws) {
     var session = getSessionForWs(ws);
     if (!session) return;
 
     var debate = session._debate;
-    if (!debate || debate.phase !== "live") return;
+    if (!debate) return;
+
+    if (debate.phase === "reviewing") {
+      endDebate(session, "user_stopped");
+      return;
+    }
+
+    if (debate.phase !== "live") return;
 
     if (debate.turnInProgress) {
       // Let current turn finish, then end
@@ -6756,8 +7041,14 @@ function createProjectContext(opts) {
     var claudeMdPath = path.join(cwd, "CLAUDE.md");
     // Enforce immediately on startup
     try { matesModule.enforceTeamAwareness(claudeMdPath); } catch (e) {}
+    try {
+      var _projList = getProjectList();
+      var _projData = _projList.filter(function (p) { return !p.isMate && !p.isWorktree; }).map(function (p) { return { slug: p.slug, path: p.path, title: p.title || p.project, icon: p.icon }; });
+      matesModule.enforceProjectRegistry(claudeMdPath, _projData);
+    } catch (e) {}
     try { matesModule.enforceSessionMemory(claudeMdPath); } catch (e) {}
     try { matesModule.enforceStickyNotes(claudeMdPath); } catch (e) {}
+    try { matesModule.enforceDebateAwareness(claudeMdPath); } catch (e) {}
     try { crisisSafety.enforce(claudeMdPath); } catch (e) {}
     // Sync sticky notes knowledge file on startup
     try {
@@ -6778,8 +7069,14 @@ function createProjectContext(opts) {
         crisisDebounce = setTimeout(function () {
           crisisDebounce = null;
           try { matesModule.enforceTeamAwareness(claudeMdPath); } catch (e) {}
+          try {
+            var _projList2 = getProjectList();
+            var _projData2 = _projList2.filter(function (p) { return !p.isMate && !p.isWorktree; }).map(function (p) { return { slug: p.slug, path: p.path, title: p.title || p.project, icon: p.icon }; });
+            matesModule.enforceProjectRegistry(claudeMdPath, _projData2);
+          } catch (e) {}
           try { matesModule.enforceSessionMemory(claudeMdPath); } catch (e) {}
           try { matesModule.enforceStickyNotes(claudeMdPath); } catch (e) {}
+          try { matesModule.enforceDebateAwareness(claudeMdPath); } catch (e) {}
           try { crisisSafety.enforce(claudeMdPath); } catch (e) {}
         }, 500);
       });