clay-server 2.6.0 → 2.7.1

package/lib/project.js

@@ -8,6 +8,7 @@ var { createTerminalManager } = require("./terminal-manager");
 var { createNotesManager } = require("./notes");
 var { fetchLatestVersion, isNewer } = require("./updater");
 var { execFileSync, spawn } = require("child_process");
+var { createLoopRegistry } = require("./scheduler");
 
 var MAX_UPLOAD_BYTES = 50 * 1024 * 1024; // 50 MB
 
@@ -222,6 +223,587 @@ function createProjectContext(opts) {
     onProcessingChanged: onProcessingChanged,
   });
 
+  // --- Ralph Loop state ---
+  var loopState = {
+    active: false,
+    phase: "idle", // idle | crafting | approval | executing | done
+    promptText: "",
+    judgeText: "",
+    iteration: 0,
+    maxIterations: 20,
+    baseCommit: null,
+    currentSessionId: null,
+    judgeSessionId: null,
+    results: [],
+    stopping: false,
+    wizardData: null,
+    craftingSessionId: null,
+    startedAt: null,
+    loopId: null,
+  };
+
+  function loopDir() {
+    if (!loopState.loopId) return null;
+    return path.join(cwd, ".claude", "loops", loopState.loopId);
+  }
+
+  function generateLoopId() {
+    return "loop_" + Date.now() + "_" + crypto.randomBytes(3).toString("hex");
+  }
+
+  // Loop state persistence
+  var _loopConfig = require("./config");
+  var _loopUtils = require("./utils");
+  var _loopDir = path.join(_loopConfig.CONFIG_DIR, "loops");
+  var _loopEncodedCwd = _loopUtils.resolveEncodedFile(_loopDir, cwd, ".json");
+  var _loopStatePath = path.join(_loopDir, _loopEncodedCwd + ".json");
+
+  function saveLoopState() {
+    try {
+      fs.mkdirSync(_loopDir, { recursive: true });
+      var data = {
+        phase: loopState.phase,
+        active: loopState.active,
+        iteration: loopState.iteration,
+        maxIterations: loopState.maxIterations,
+        baseCommit: loopState.baseCommit,
+        results: loopState.results,
+        wizardData: loopState.wizardData,
+        startedAt: loopState.startedAt,
+        loopId: loopState.loopId,
+      };
+      var tmpPath = _loopStatePath + ".tmp";
+      fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+      fs.renameSync(tmpPath, _loopStatePath);
+    } catch (e) {
+      console.error("[ralph-loop] Failed to save state:", e.message);
+    }
+  }
+
+  function loadLoopState() {
+    try {
+      var raw = fs.readFileSync(_loopStatePath, "utf8");
+      var data = JSON.parse(raw);
+      loopState.phase = data.phase || "idle";
+      loopState.active = data.active || false;
+      loopState.iteration = data.iteration || 0;
+      loopState.maxIterations = data.maxIterations || 20;
+      loopState.baseCommit = data.baseCommit || null;
+      loopState.results = data.results || [];
+      loopState.wizardData = data.wizardData || null;
+      loopState.startedAt = data.startedAt || null;
+      loopState.loopId = data.loopId || null;
+      // SDK sessions cannot survive daemon restart
+      loopState.currentSessionId = null;
+      loopState.judgeSessionId = null;
+      loopState.craftingSessionId = null;
+      loopState.stopping = false;
+      // If was executing, schedule resume after SDK is ready
+      if (loopState.phase === "executing" && loopState.active) {
+        loopState._needsResume = true;
+      }
+      // If was crafting, check if files exist and move to approval
+      if (loopState.phase === "crafting") {
+        var hasFiles = checkLoopFilesExist();
+        if (hasFiles) {
+          loopState.phase = "approval";
+          saveLoopState();
+        } else {
+          loopState.phase = "idle";
+          saveLoopState();
+        }
+      }
+    } catch (e) {
+      // No saved state, use defaults
+    }
+  }
+
+  function clearLoopState() {
+    loopState.active = false;
+    loopState.phase = "idle";
+    loopState.promptText = "";
+    loopState.judgeText = "";
+    loopState.iteration = 0;
+    loopState.maxIterations = 20;
+    loopState.baseCommit = null;
+    loopState.currentSessionId = null;
+    loopState.judgeSessionId = null;
+    loopState.results = [];
+    loopState.stopping = false;
+    loopState.wizardData = null;
+    loopState.craftingSessionId = null;
+    loopState.startedAt = null;
+    loopState.loopId = null;
+    saveLoopState();
+  }
+
+  function checkLoopFilesExist() {
+    var dir = loopDir();
+    if (!dir) return false;
+    var hasPrompt = false;
+    var hasJudge = false;
+    try { fs.accessSync(path.join(dir, "PROMPT.md")); hasPrompt = true; } catch (e) {}
+    try { fs.accessSync(path.join(dir, "JUDGE.md")); hasJudge = true; } catch (e) {}
+    return hasPrompt && hasJudge;
+  }
+
+  // .claude/ directory watcher for PROMPT.md / JUDGE.md
+  var claudeDirWatcher = null;
+  var claudeDirDebounce = null;
+
+  function startClaudeDirWatch() {
+    if (claudeDirWatcher) return;
+    var watchDir = loopDir();
+    if (!watchDir) return;
+    try { fs.mkdirSync(watchDir, { recursive: true }); } catch (e) {}
+    try {
+      claudeDirWatcher = fs.watch(watchDir, function () {
+        if (claudeDirDebounce) clearTimeout(claudeDirDebounce);
+        claudeDirDebounce = setTimeout(function () {
+          broadcastLoopFilesStatus();
+        }, 300);
+      });
+      claudeDirWatcher.on("error", function () {});
+    } catch (e) {
+      console.error("[ralph-loop] Failed to watch .claude/:", e.message);
+    }
+  }
+
+  function stopClaudeDirWatch() {
+    if (claudeDirWatcher) {
+      claudeDirWatcher.close();
+      claudeDirWatcher = null;
+    }
+    if (claudeDirDebounce) {
+      clearTimeout(claudeDirDebounce);
+      claudeDirDebounce = null;
+    }
+  }
+
+  function broadcastLoopFilesStatus() {
+    var dir = loopDir();
+    var hasPrompt = false;
+    var hasJudge = false;
+    var hasLoopJson = false;
+    if (dir) {
+      try { fs.accessSync(path.join(dir, "PROMPT.md")); hasPrompt = true; } catch (e) {}
+      try { fs.accessSync(path.join(dir, "JUDGE.md")); hasJudge = true; } catch (e) {}
+      try { fs.accessSync(path.join(dir, "LOOP.json")); hasLoopJson = true; } catch (e) {}
+    }
+    send({
+      type: "ralph_files_status",
+      promptReady: hasPrompt,
+      judgeReady: hasJudge,
+      loopJsonReady: hasLoopJson,
+      bothReady: hasPrompt && hasJudge,
+      taskId: loopState.loopId,
+    });
+    // Auto-transition to approval phase when both files appear
+    if (hasPrompt && hasJudge && loopState.phase === "crafting") {
+      loopState.phase = "approval";
+      saveLoopState();
+
+      // Parse recommended title from crafting session conversation
+      if (loopState.craftingSessionId && loopState.loopId) {
+        var craftSess = sm.sessions.get(loopState.craftingSessionId);
+        if (craftSess && craftSess.history) {
+          for (var hi = craftSess.history.length - 1; hi >= 0; hi--) {
+            var entry = craftSess.history[hi];
+            var entryText = entry.text || "";
+            var titleMatch = entryText.match(/\[\[LOOP_TITLE:\s*(.+?)\]\]/);
+            if (titleMatch) {
+              var suggestedTitle = titleMatch[1].trim();
+              if (suggestedTitle) {
+                loopRegistry.updateRecord(loopState.loopId, { name: suggestedTitle });
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Load persisted state on startup
+  loadLoopState();
+
+  // --- Loop Registry (unified one-off + scheduled) ---
+  var activeRegistryId = null; // track which registry record triggered current loop
+
+  var loopRegistry = createLoopRegistry({
+    cwd: cwd,
+    onTrigger: function (record) {
+      // Only trigger if no loop is currently active
+      if (loopState.active || loopState.phase === "executing") {
+        console.log("[loop-registry] Skipping trigger — loop already active");
+        return;
+      }
+      // Verify the loop directory and files exist
+      var recDir = path.join(cwd, ".claude", "loops", record.id);
+      try {
+        fs.accessSync(path.join(recDir, "PROMPT.md"));
+        fs.accessSync(path.join(recDir, "JUDGE.md"));
+      } catch (e) {
+        console.error("[loop-registry] Loop files missing for " + record.id);
+        return;
+      }
+      // Set the loopId and start
+      loopState.loopId = record.id;
+      activeRegistryId = record.id;
+      console.log("[loop-registry] Auto-starting loop: " + record.name);
+      send({ type: "schedule_run_started", recordId: record.id });
+      startLoop();
+    },
+    onChange: function (records) {
+      send({ type: "loop_registry_updated", records: records });
+    },
+  });
+  loopRegistry.load();
+  loopRegistry.startTimer();
+
+  function startLoop(opts) {
+    var loopOpts = opts || {};
+    var dir = loopDir();
+    if (!dir) {
+      send({ type: "loop_error", text: "No loop directory. Run the wizard first." });
+      return;
+    }
+    var promptPath = path.join(dir, "PROMPT.md");
+    var judgePath = path.join(dir, "JUDGE.md");
+    var promptText, judgeText;
+    try {
+      promptText = fs.readFileSync(promptPath, "utf8");
+    } catch (e) {
+      send({ type: "loop_error", text: "Missing PROMPT.md in " + dir });
+      return;
+    }
+    try {
+      judgeText = fs.readFileSync(judgePath, "utf8");
+    } catch (e) {
+      send({ type: "loop_error", text: "Missing JUDGE.md in " + dir });
+      return;
+    }
+
+    var baseCommit;
+    try {
+      baseCommit = execFileSync("git", ["rev-parse", "HEAD"], {
+        cwd: cwd, encoding: "utf8", timeout: 5000,
+      }).trim();
+    } catch (e) {
+      send({ type: "loop_error", text: "Failed to get git HEAD: " + e.message });
+      return;
+    }
+
+    // Read loop config from LOOP.json in loop directory
+    var loopConfig = {};
+    try {
+      loopConfig = JSON.parse(fs.readFileSync(path.join(dir, "LOOP.json"), "utf8"));
+    } catch (e) {}
+
+    loopState.active = true;
+    loopState.phase = "executing";
+    loopState.promptText = promptText;
+    loopState.judgeText = judgeText;
+    loopState.iteration = 0;
+    loopState.maxIterations = loopConfig.maxIterations || loopOpts.maxIterations || 20;
+    loopState.baseCommit = baseCommit;
+    loopState.currentSessionId = null;
+    loopState.judgeSessionId = null;
+    loopState.results = [];
+    loopState.stopping = false;
+    loopState.startedAt = Date.now();
+    saveLoopState();
+
+    stopClaudeDirWatch();
+
+    send({ type: "loop_started", maxIterations: loopState.maxIterations });
+    runNextIteration();
+  }
+
+  function runNextIteration() {
+    console.log("[ralph-loop] runNextIteration called, iteration: " + loopState.iteration + ", active: " + loopState.active + ", stopping: " + loopState.stopping);
+    if (!loopState.active || loopState.stopping) {
+      finishLoop("stopped");
+      return;
+    }
+
+    loopState.iteration++;
+    if (loopState.iteration > loopState.maxIterations) {
+      finishLoop("max_iterations");
+      return;
+    }
+
+    var session = sm.createSession();
+    session.loop = { active: true, iteration: loopState.iteration, role: "coder" };
+    var loopName = (loopState.wizardData && loopState.wizardData.name) || "";
+    session.title = "Ralph" + (loopName ? " " + loopName : "") + " #" + loopState.iteration;
+    sm.saveSessionFile(session);
+    sm.broadcastSessionList();
+
+    loopState.currentSessionId = session.localId;
+
+    send({
+      type: "loop_iteration",
+      iteration: loopState.iteration,
+      maxIterations: loopState.maxIterations,
+      sessionId: session.localId,
+    });
+
+    session.onQueryComplete = function(completedSession) {
+      console.log("[ralph-loop] Coder #" + loopState.iteration + " onQueryComplete fired, history length: " + completedSession.history.length);
+      if (!loopState.active) { console.log("[ralph-loop] Coder: loopState.active is false, skipping"); return; }
+      // Check if session ended with error
+      var lastItems = completedSession.history.slice(-3);
+      var hadError = false;
+      for (var i = 0; i < lastItems.length; i++) {
+        if (lastItems[i].type === "error" || (lastItems[i].type === "done" && lastItems[i].code === 1)) {
+          hadError = true;
+          break;
+        }
+      }
+      if (hadError) {
+        loopState.results.push({
+          iteration: loopState.iteration,
+          verdict: "error",
+          summary: "Iteration ended with error",
+        });
+        send({
+          type: "loop_verdict",
+          iteration: loopState.iteration,
+          verdict: "error",
+          summary: "Iteration ended with error, retrying...",
+        });
+        setTimeout(function() { runNextIteration(); }, 2000);
+        return;
+      }
+      runJudge();
+    };
+
+    var userMsg = { type: "user_message", text: loopState.promptText };
+    session.history.push(userMsg);
+    sm.appendToSessionFile(session, userMsg);
+
+    session.isProcessing = true;
+    onProcessingChanged();
+    session.sentToolResults = {};
+    send({ type: "status", status: "processing" });
+    session.acceptEditsAfterStart = true;
+    session.singleTurn = true;
+    sdk.startQuery(session, loopState.promptText);
+  }
+
+  function runJudge() {
+    if (!loopState.active || loopState.stopping) {
+      finishLoop("stopped");
+      return;
+    }
+
+    var diff;
+    try {
+      diff = execFileSync("git", ["diff", loopState.baseCommit], {
+        cwd: cwd, encoding: "utf8", timeout: 30000,
+        maxBuffer: 10 * 1024 * 1024,
+      });
+    } catch (e) {
+      send({ type: "loop_error", text: "Failed to generate git diff: " + e.message });
+      finishLoop("error");
+      return;
+    }
+
+    var judgePrompt = "You are a judge evaluating whether a coding task has been completed.\n\n" +
+      "## Original Task (PROMPT.md)\n\n" + loopState.promptText + "\n\n" +
+      "## Evaluation Criteria (JUDGE.md)\n\n" + loopState.judgeText + "\n\n" +
+      "## Changes Made (git diff)\n\n```diff\n" + diff + "\n```\n\n" +
+      "Based on the evaluation criteria, has the task been completed successfully?\n\n" +
+      "Respond with exactly one of:\n" +
+      "- PASS: [brief explanation]\n" +
+      "- FAIL: [brief explanation of what is still missing]\n\n" +
+      "Do NOT use any tools. Just analyze and respond.";
+
+    var judgeSession = sm.createSession();
+    judgeSession.loop = { active: true, iteration: loopState.iteration, role: "judge" };
+    var judgeName = (loopState.wizardData && loopState.wizardData.name) || "";
+    judgeSession.title = "Ralph" + (judgeName ? " " + judgeName : "") + " Judge #" + loopState.iteration;
+    sm.saveSessionFile(judgeSession);
+    sm.broadcastSessionList();
+    loopState.judgeSessionId = judgeSession.localId;
+
+    send({
+      type: "loop_judging",
+      iteration: loopState.iteration,
+      sessionId: judgeSession.localId,
+    });
+
+    judgeSession.onQueryComplete = function(completedSession) {
+      console.log("[ralph-loop] Judge #" + loopState.iteration + " onQueryComplete fired, history length: " + completedSession.history.length);
+      var verdict = parseJudgeVerdict(completedSession);
+      console.log("[ralph-loop] Judge verdict: " + (verdict.pass ? "PASS" : "FAIL") + " - " + verdict.explanation);
+
+      loopState.results.push({
+        iteration: loopState.iteration,
+        verdict: verdict.pass ? "pass" : "fail",
+        summary: verdict.explanation,
+      });
+
+      send({
+        type: "loop_verdict",
+        iteration: loopState.iteration,
+        verdict: verdict.pass ? "pass" : "fail",
+        summary: verdict.explanation,
+      });
+
+      if (verdict.pass) {
+        finishLoop("pass");
+      } else {
+        setTimeout(function() { runNextIteration(); }, 1000);
+      }
+    };
+
+    var userMsg = { type: "user_message", text: judgePrompt };
+    judgeSession.history.push(userMsg);
+    sm.appendToSessionFile(judgeSession, userMsg);
+
+    judgeSession.isProcessing = true;
+    onProcessingChanged();
+    judgeSession.sentToolResults = {};
+    judgeSession.acceptEditsAfterStart = true;
+    judgeSession.singleTurn = true;
+    sdk.startQuery(judgeSession, judgePrompt);
+  }
+
+  function parseJudgeVerdict(session) {
+    var text = "";
+    for (var i = 0; i < session.history.length; i++) {
+      var h = session.history[i];
+      if (h.type === "delta" && h.text) text += h.text;
+      if (h.type === "text" && h.text) text += h.text;
+    }
+    console.log("[ralph-loop] Judge raw text (last 500 chars): " + text.slice(-500));
+    var upper = text.toUpperCase();
+    var passIdx = upper.indexOf("PASS");
+    var failIdx = upper.indexOf("FAIL");
+    if (passIdx !== -1 && (failIdx === -1 || passIdx < failIdx)) {
+      var explanation = text.substring(passIdx + 4).replace(/^[\s:]+/, "").split("\n")[0].trim();
+      return { pass: true, explanation: explanation || "Task completed" };
+    }
+    if (failIdx !== -1) {
+      var explanation = text.substring(failIdx + 4).replace(/^[\s:]+/, "").split("\n")[0].trim();
+      return { pass: false, explanation: explanation || "Task not yet complete" };
+    }
+    return { pass: false, explanation: "Could not parse judge verdict" };
+  }
+
+  function finishLoop(reason) {
+    console.log("[ralph-loop] finishLoop called, reason: " + reason + ", iteration: " + loopState.iteration);
+    loopState.active = false;
+    loopState.phase = "done";
+    loopState.stopping = false;
+    loopState.currentSessionId = null;
+    loopState.judgeSessionId = null;
+    saveLoopState();
+
+    send({
+      type: "loop_finished",
+      reason: reason,
+      iterations: loopState.iteration,
+      results: loopState.results,
+    });
+
+    // Record result in loop registry
+    if (loopState.loopId) {
+      loopRegistry.recordRun(loopState.loopId, {
+        reason: reason,
+        startedAt: loopState.startedAt,
+        iterations: loopState.iteration,
+      });
+    }
+    if (activeRegistryId) {
+      send({ type: "schedule_run_finished", recordId: activeRegistryId, reason: reason, iterations: loopState.iteration });
+      activeRegistryId = null;
+    }
+
+    if (pushModule) {
+      var body = reason === "pass"
+        ? "Task completed after " + loopState.iteration + " iteration(s)"
+        : reason === "max_iterations"
+          ? "Reached max iterations (" + loopState.maxIterations + ")"
+          : reason === "stopped"
+            ? "Loop stopped by user"
+            : "Loop ended due to error";
+      pushModule.sendPush({
+        type: "done",
+        slug: slug,
+        title: "Ralph Loop Complete",
+        body: body,
+        tag: "ralph-loop-done",
+      });
+    }
+  }
+
+  function resumeLoop() {
+    var dir = loopDir();
+    if (!dir) {
+      console.error("[ralph-loop] Cannot resume: no loop directory");
+      loopState.active = false;
+      loopState.phase = "idle";
+      saveLoopState();
+      return;
+    }
+    try {
+      loopState.promptText = fs.readFileSync(path.join(dir, "PROMPT.md"), "utf8");
+    } catch (e) {
+      console.error("[ralph-loop] Cannot resume: missing PROMPT.md");
+      loopState.active = false;
+      loopState.phase = "idle";
+      saveLoopState();
+      return;
+    }
+    try {
+      loopState.judgeText = fs.readFileSync(path.join(dir, "JUDGE.md"), "utf8");
+    } catch (e) {
+      console.error("[ralph-loop] Cannot resume: missing JUDGE.md");
+      loopState.active = false;
+      loopState.phase = "idle";
+      saveLoopState();
+      return;
+    }
+    // Retry the interrupted iteration (runNextIteration will increment)
+    if (loopState.iteration > 0) {
+      loopState.iteration--;
+    }
+    console.log("[ralph-loop] Resuming loop, next iteration will be " + (loopState.iteration + 1) + "/" + loopState.maxIterations);
+    send({ type: "loop_started", maxIterations: loopState.maxIterations });
+    runNextIteration();
+  }
+
+  function stopLoop() {
+    if (!loopState.active) return;
+    console.log("[ralph-loop] stopLoop called");
+    loopState.stopping = true;
+
+    // Abort all loop-related sessions (coder + judge)
+    var sessionIds = [loopState.currentSessionId, loopState.judgeSessionId];
+    for (var i = 0; i < sessionIds.length; i++) {
+      if (sessionIds[i] == null) continue;
+      var s = sm.sessions.get(sessionIds[i]);
+      if (!s) continue;
+      // End message queue so SDK exits prompt wait
+      if (s.messageQueue) { try { s.messageQueue.end(); } catch (e) {} }
+      // Abort active API call
+      if (s.abortController) { try { s.abortController.abort(); } catch (e) {} }
+    }
+
+    send({ type: "loop_stopping" });
+
+    // Fallback: force finish if onQueryComplete hasn't fired after 5s
+    setTimeout(function() {
+      if (loopState.active && loopState.stopping) {
+        console.log("[ralph-loop] Stop fallback triggered — forcing finishLoop");
+        finishLoop("stopped");
+      }
+    }, 5000);
+  }
+
   // --- Terminal manager ---
   var tm = createTerminalManager({ cwd: cwd, send: send, sendTo: sendTo });
   var nm = createNotesManager({ cwd: cwd, send: send, sendTo: sendTo });
@@ -239,6 +821,12 @@ function createProjectContext(opts) {
     clients.add(ws);
     broadcastClientCount();
 
+    // Resume loop if server restarted mid-execution (deferred so client gets initial state first)
+    if (loopState._needsResume) {
+      delete loopState._needsResume;
+      setTimeout(function() { resumeLoop(); }, 500);
+    }
+
     // Send cached state
     sendTo(ws, { type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, dangerouslySkipPermissions: dangerouslySkipPermissions, lanHost: lanHost, projectCount: getProjectCount(), projects: getProjectList() });
     if (latestVersion) {
@@ -253,6 +841,46 @@ function createProjectContext(opts) {
     sendTo(ws, { type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
     sendTo(ws, { type: "term_list", terminals: tm.list() });
     sendTo(ws, { type: "notes_list", notes: nm.list() });
+    sendTo(ws, { type: "loop_registry_updated", records: loopRegistry.getAll() });
+
+    // Ralph Loop availability
+    var hasLoopFiles = false;
+    try {
+      fs.accessSync(path.join(cwd, ".claude", "PROMPT.md"));
+      fs.accessSync(path.join(cwd, ".claude", "JUDGE.md"));
+      hasLoopFiles = true;
+    } catch (e) {}
+    sendTo(ws, {
+      type: "loop_available",
+      available: hasLoopFiles,
+      active: loopState.active,
+      iteration: loopState.iteration,
+      maxIterations: loopState.maxIterations,
+    });
+
+    // Ralph phase state
+    sendTo(ws, {
+      type: "ralph_phase",
+      phase: loopState.phase,
+      wizardData: loopState.wizardData,
+      craftingSessionId: loopState.craftingSessionId || null,
+    });
+    if (loopState.phase === "crafting" || loopState.phase === "approval") {
+      var _hasPrompt = false;
+      var _hasJudge = false;
+      var _lDir = loopDir();
+      if (_lDir) {
+        try { fs.accessSync(path.join(_lDir, "PROMPT.md")); _hasPrompt = true; } catch (e) {}
+        try { fs.accessSync(path.join(_lDir, "JUDGE.md")); _hasJudge = true; } catch (e) {}
+      }
+      sendTo(ws, {
+        type: "ralph_files_status",
+        promptReady: _hasPrompt,
+        judgeReady: _hasJudge,
+        bothReady: _hasPrompt && _hasJudge,
+        taskId: loopState.loopId,
+      });
+    }
 
     // Session list
     sendTo(ws, {
@@ -1019,6 +1647,20 @@ function createProjectContext(opts) {
       return;
     }
 
+    if (msg.type === "restart_server") {
+      if (typeof opts.onRestart === "function") {
+        sendTo(ws, { type: "restart_server_result", ok: true });
+        send({ type: "toast", level: "info", message: "Server is restarting..." });
+        // Small delay so the response has time to reach clients
+        setTimeout(function () {
+          opts.onRestart();
+        }, 500);
+      } else {
+        sendTo(ws, { type: "restart_server_result", ok: false, error: "Restart not supported" });
+      }
+      return;
+    }
+
     // --- File browser ---
     if (msg.type === "fs_list") {
       var fsDir = safePath(cwd, msg.path || ".");
@@ -1446,6 +2088,218 @@ function createProjectContext(opts) {
       return;
     }
 
+    if (msg.type === "loop_start") {
+      // If this loop has a cron schedule, don't run immediately — just confirm registration
+      if (loopState.wizardData && loopState.wizardData.cron) {
+        loopState.active = false;
+        loopState.phase = "done";
+        saveLoopState();
+        send({ type: "loop_finished", reason: "scheduled", iterations: 0, results: [] });
+        send({ type: "ralph_phase", phase: "idle", wizardData: null });
+        send({ type: "loop_scheduled", recordId: loopState.loopId, cron: loopState.wizardData.cron });
+        return;
+      }
+      startLoop();
+      return;
+    }
+
+    if (msg.type === "loop_stop") {
+      stopLoop();
+      return;
+    }
+
+    if (msg.type === "ralph_wizard_complete") {
+      var wData = msg.data || {};
+      var maxIter = wData.maxIterations || 25;
+      var wizardCron = wData.cron || null;
+      var newLoopId = generateLoopId();
+      loopState.loopId = newLoopId;
+      loopState.wizardData = {
+        name: wData.name || wData.task || "Untitled",
+        task: wData.task || "",
+        maxIterations: maxIter,
+        cron: wizardCron,
+      };
+      loopState.phase = "crafting";
+      loopState.startedAt = Date.now();
+      saveLoopState();
+
+      // Register in loop registry
+      loopRegistry.register({
+        id: newLoopId,
+        name: loopState.wizardData.name,
+        task: wData.task || "",
+        cron: wizardCron,
+        enabled: wizardCron ? true : false,
+        maxIterations: maxIter,
+      });
+
+      // Create loop directory and write LOOP.json
+      var lDir = loopDir();
+      try { fs.mkdirSync(lDir, { recursive: true }); } catch (e) {}
+      var loopJsonPath = path.join(lDir, "LOOP.json");
+      var tmpLoopJson = loopJsonPath + ".tmp";
+      fs.writeFileSync(tmpLoopJson, JSON.stringify({ maxIterations: maxIter }, null, 2));
+      fs.renameSync(tmpLoopJson, loopJsonPath);
+
+      // Assemble prompt for clay-ralph skill (include loop dir path so skill knows where to write)
+      var craftingPrompt = "Use the /clay-ralph skill to design a Ralph Loop for the following task. " +
+        "You MUST invoke the clay-ralph skill — do NOT execute the task yourself. " +
+        "Your job is to interview me, then create PROMPT.md and JUDGE.md files " +
+        "that a future autonomous session will execute.\n\n" +
+        "## Task\n" + (wData.task || "") +
+        "\n\n## Loop Directory\n" + lDir;
+
+      // Create a new session for crafting
+      var craftingSession = sm.createSession();
+      var craftName = (loopState.wizardData && loopState.wizardData.name) || "";
+      craftingSession.title = "Ralph" + (craftName ? " " + craftName : "") + " Crafting";
+      craftingSession.ralphCraftingMode = true;
+      craftingSession.hidden = true;
+      sm.saveSessionFile(craftingSession);
+      sm.switchSession(craftingSession.localId);
+      loopState.craftingSessionId = craftingSession.localId;
+
+      // Store crafting session ID in the registry record
+      loopRegistry.updateRecord(newLoopId, { craftingSessionId: craftingSession.localId });
+
+      // Start .claude/ directory watcher
+      startClaudeDirWatch();
+
+      // Start query
+      craftingSession.history.push({ type: "user_message", text: craftingPrompt });
+      sm.appendToSessionFile(craftingSession, { type: "user_message", text: craftingPrompt });
+      send({ type: "user_message", text: craftingPrompt });
+      craftingSession.isProcessing = true;
+      onProcessingChanged();
+      craftingSession.sentToolResults = {};
+      send({ type: "status", status: "processing" });
+      sdk.startQuery(craftingSession, craftingPrompt);
+
+      send({ type: "ralph_crafting_started", sessionId: craftingSession.localId, taskId: newLoopId });
+      send({ type: "ralph_phase", phase: "crafting", wizardData: loopState.wizardData, craftingSessionId: craftingSession.localId });
+      return;
+    }
+
+    if (msg.type === "loop_registry_files") {
+      var recId = msg.id;
+      var lDir = path.join(cwd, ".claude", "loops", recId);
+      var promptContent = "";
+      var judgeContent = "";
+      try { promptContent = fs.readFileSync(path.join(lDir, "PROMPT.md"), "utf8"); } catch (e) {}
+      try { judgeContent = fs.readFileSync(path.join(lDir, "JUDGE.md"), "utf8"); } catch (e) {}
+      send({
+        type: "loop_registry_files_content",
+        id: recId,
+        prompt: promptContent,
+        judge: judgeContent,
+      });
+      return;
+    }
+
+    if (msg.type === "ralph_preview_files") {
+      var promptContent = "";
+      var judgeContent = "";
+      var previewDir = loopDir();
+      if (previewDir) {
+        try { promptContent = fs.readFileSync(path.join(previewDir, "PROMPT.md"), "utf8"); } catch (e) {}
+        try { judgeContent = fs.readFileSync(path.join(previewDir, "JUDGE.md"), "utf8"); } catch (e) {}
+      }
+      sendTo(ws, {
+        type: "ralph_files_content",
+        prompt: promptContent,
+        judge: judgeContent,
+      });
+      return;
+    }
+
+    if (msg.type === "ralph_wizard_cancel") {
+      stopClaudeDirWatch();
+      // Clean up loop directory
+      var cancelDir = loopDir();
+      if (cancelDir) {
+        try { fs.rmSync(cancelDir, { recursive: true, force: true }); } catch (e) {}
+      }
+      clearLoopState();
+      send({ type: "ralph_phase", phase: "idle", wizardData: null });
+      return;
+    }
+
+    if (msg.type === "ralph_cancel_crafting") {
+      // Abort the crafting session if running
+      if (loopState.craftingSessionId != null) {
+        var craftSession = sm.sessions.get(loopState.craftingSessionId) || null;
+        if (craftSession && craftSession.abortController) {
+          craftSession.abortController.abort();
+        }
+      }
+      stopClaudeDirWatch();
+      // Clean up loop directory
+      var craftCancelDir = loopDir();
+      if (craftCancelDir) {
+        try { fs.rmSync(craftCancelDir, { recursive: true, force: true }); } catch (e) {}
+      }
+      clearLoopState();
+      send({ type: "ralph_phase", phase: "idle", wizardData: null });
+      return;
+    }
+
+    // --- Loop Registry messages ---
+    if (msg.type === "loop_registry_list") {
+      sendTo(ws, { type: "loop_registry_updated", records: loopRegistry.getAll() });
+      return;
+    }
+
+    if (msg.type === "loop_registry_update") {
+      var updatedRec = loopRegistry.update(msg.id, msg.data || {});
+      if (!updatedRec) {
+        sendTo(ws, { type: "loop_registry_error", text: "Record not found" });
+      }
+      return;
+    }
+
+    if (msg.type === "loop_registry_remove") {
+      var removedRec = loopRegistry.remove(msg.id);
+      if (!removedRec) {
+        sendTo(ws, { type: "loop_registry_error", text: "Record not found" });
+      }
+      return;
+    }
+
+    if (msg.type === "loop_registry_toggle") {
+      var toggledRec = loopRegistry.toggleEnabled(msg.id);
+      if (!toggledRec) {
+        sendTo(ws, { type: "loop_registry_error", text: "Record not found or not scheduled" });
+      }
+      return;
+    }
+
+    if (msg.type === "loop_registry_rerun") {
+      // Re-run an existing job (one-off from library)
+      if (loopState.active || loopState.phase === "executing") {
+        sendTo(ws, { type: "loop_registry_error", text: "A loop is already running" });
+        return;
+      }
+      var rerunRec = loopRegistry.getById(msg.id);
+      if (!rerunRec) {
+        sendTo(ws, { type: "loop_registry_error", text: "Record not found" });
+        return;
+      }
+      var rerunDir = path.join(cwd, ".claude", "loops", rerunRec.id);
+      try {
+        fs.accessSync(path.join(rerunDir, "PROMPT.md"));
+        fs.accessSync(path.join(rerunDir, "JUDGE.md"));
+      } catch (e) {
+        sendTo(ws, { type: "loop_registry_error", text: "Loop files missing for " + rerunRec.id });
+        return;
+      }
+      loopState.loopId = rerunRec.id;
+      activeRegistryId = null; // not a scheduled trigger
+      send({ type: "loop_rerun_started", recordId: rerunRec.id });
+      startLoop();
+      return;
+    }
+
     if (msg.type !== "message") return;
     if (!msg.text && (!msg.images || msg.images.length === 0) && (!msg.pastes || msg.pastes.length === 0)) return;
 
@@ -1752,12 +2606,23 @@ function createProjectContext(opts) {
           if (!ent.isDirectory() && !ent.isSymbolicLink()) continue;
           var mdPath = path.join(scanDirs[sd].dir, ent.name, "SKILL.md");
           try {
-            fs.accessSync(mdPath, fs.constants.R_OK);
+            var mdContent = fs.readFileSync(mdPath, "utf8");
+            var desc = "";
+            // Parse YAML frontmatter for description
+            if (mdContent.startsWith("---")) {
+              var endIdx = mdContent.indexOf("---", 3);
+              if (endIdx !== -1) {
+                var frontmatter = mdContent.substring(3, endIdx);
+                var descMatch = frontmatter.match(/^description:\s*(.+)/m);
+                if (descMatch) desc = descMatch[1].trim();
+              }
+            }
             if (!installed[ent.name]) {
-              installed[ent.name] = { scope: scanDirs[sd].scope };
+              installed[ent.name] = { scope: scanDirs[sd].scope, description: desc, path: path.join(scanDirs[sd].dir, ent.name) };
             } else {
               // project-level adds to existing global entry
               installed[ent.name].scope = "both";
+              if (desc && !installed[ent.name].description) installed[ent.name].description = desc;
             }
           } catch (e) {}
         }
@@ -1767,6 +2632,21 @@ function createProjectContext(opts) {
       return true;
     }
 
+    // Git dirty check
+    if (req.method === "GET" && urlPath === "/api/git-dirty") {
+      var execSync = require("child_process").execSync;
+      try {
+        var out = execSync("git status --porcelain", { cwd: cwd, encoding: "utf8", timeout: 5000 });
+        var dirty = out.trim().length > 0;
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ dirty: dirty }));
+      } catch (e) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ dirty: false }));
+      }
+      return true;
+    }
+
     // Info endpoint
     if (req.method === "GET" && urlPath === "/info") {
       res.writeHead(200, {
@@ -1782,6 +2662,7 @@ function createProjectContext(opts) {
 
   // --- Destroy ---
   function destroy() {
+    loopRegistry.stopTimer();
     stopFileWatch();
     stopAllDirWatches();
     // Abort all active sessions