clay-server 2.5.1 → 2.7.0

package/lib/project.js

@@ -1,11 +1,15 @@
 var fs = require("fs");
 var path = require("path");
+var os = require("os");
+var crypto = require("crypto");
 var { createSessionManager } = require("./sessions");
 var { createSDKBridge } = require("./sdk-bridge");
 var { createTerminalManager } = require("./terminal-manager");
 var { createNotesManager } = require("./notes");
 var { fetchLatestVersion, isNewer } = require("./updater");
-var { execFileSync } = require("child_process");
+var { execFileSync, spawn } = require("child_process");
+
+var MAX_UPLOAD_BYTES = 50 * 1024 * 1024; // 50 MB
 
 // SDK loaded dynamically (ESM module)
 var sdkModule = null;
@@ -63,6 +67,7 @@ function createProjectContext(opts) {
   var slug = opts.slug;
   var project = path.basename(cwd);
   var title = opts.title || null;
+  var icon = opts.icon || null;
   var pushModule = opts.pushModule || null;
   var debug = opts.debug || false;
   var dangerouslySkipPermissions = opts.dangerouslySkipPermissions || false;
@@ -70,6 +75,7 @@ function createProjectContext(opts) {
   var lanHost = opts.lanHost || null;
   var getProjectCount = opts.getProjectCount || function () { return 1; };
   var getProjectList = opts.getProjectList || function () { return []; };
+  var onProcessingChanged = opts.onProcessingChanged || function () {};
   var latestVersion = null;
 
   // --- Per-project clients ---
@@ -192,8 +198,17 @@ function createProjectContext(opts) {
 
   // --- Session manager ---
   var sm = createSessionManager({ cwd: cwd, send: send });
-  sm.currentPermissionMode = "default";
-  sm.currentEffort = "high";
+  var _projMode = typeof opts.onGetProjectDefaultMode === "function" ? opts.onGetProjectDefaultMode(slug) : null;
+  var _srvMode = typeof opts.onGetServerDefaultMode === "function" ? opts.onGetServerDefaultMode() : null;
+  sm.currentPermissionMode = (_projMode && _projMode.mode) || (_srvMode && _srvMode.mode) || "default";
+
+  var _projEffort = typeof opts.onGetProjectDefaultEffort === "function" ? opts.onGetProjectDefaultEffort(slug) : null;
+  var _srvEffort = typeof opts.onGetServerDefaultEffort === "function" ? opts.onGetServerDefaultEffort() : null;
+  sm.currentEffort = (_projEffort && _projEffort.effort) || (_srvEffort && _srvEffort.effort) || "medium";
+
+  var _projModel = typeof opts.onGetProjectDefaultModel === "function" ? opts.onGetProjectDefaultModel(slug) : null;
+  var _srvModel = typeof opts.onGetServerDefaultModel === "function" ? opts.onGetServerDefaultModel() : null;
+  sm._savedDefaultModel = (_projModel && _projModel.model) || (_srvModel && _srvModel.model) || null;
 
   // --- SDK bridge ---
   var sdk = createSDKBridge({
@@ -204,8 +219,523 @@ function createProjectContext(opts) {
     pushModule: pushModule,
     getSDK: getSDK,
     dangerouslySkipPermissions: dangerouslySkipPermissions,
+    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 _loopEncodedCwd = _loopUtils.encodeCwd(cwd);
+  var _loopDir = path.join(_loopConfig.CONFIG_DIR, "loops");
+  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,
+    });
+    // Auto-transition to approval phase when both files appear
+    if (hasPrompt && hasJudge && loopState.phase === "crafting") {
+      loopState.phase = "approval";
+      saveLoopState();
+    }
+  }
+
+  // Load persisted state on startup
+  loadLoopState();
+
+  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,
+    });
+
+    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 });
@@ -223,6 +753,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) {
@@ -234,10 +770,48 @@ function createProjectContext(opts) {
     if (sm.currentModel) {
       sendTo(ws, { type: "model_info", model: sm.currentModel, models: sm.availableModels || [] });
     }
-    sendTo(ws, { type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+    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() });
 
+    // 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,
+      });
+    }
+
     // Session list
     sendTo(ws, {
       type: "session_list",
@@ -489,13 +1063,70 @@ function createProjectContext(opts) {
       return;
     }
 
+    if (msg.type === "set_server_default_model" && msg.model) {
+      if (typeof opts.onSetServerDefaultModel === "function") {
+        opts.onSetServerDefaultModel(msg.model);
+      }
+      var session = sm.getActiveSession();
+      if (session) {
+        sdk.setModel(session, msg.model);
+      }
+      return;
+    }
+
+    if (msg.type === "set_project_default_model" && msg.model) {
+      if (typeof opts.onSetProjectDefaultModel === "function") {
+        opts.onSetProjectDefaultModel(slug, msg.model);
+      }
+      var session = sm.getActiveSession();
+      if (session) {
+        sdk.setModel(session, msg.model);
+      }
+      return;
+    }
+
     if (msg.type === "set_permission_mode" && msg.mode) {
+      // When dangerouslySkipPermissions is active, don't allow UI to change mode
+      if (dangerouslySkipPermissions) {
+        send({ type: "config_state", model: sm.currentModel || "", mode: "bypassPermissions", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+        return;
+      }
       sm.currentPermissionMode = msg.mode;
       var session = sm.getActiveSession();
       if (session) {
         sdk.setPermissionMode(session, msg.mode);
       }
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+      return;
+    }
+
+    if (msg.type === "set_server_default_mode" && msg.mode) {
+      if (typeof opts.onSetServerDefaultMode === "function") {
+        opts.onSetServerDefaultMode(msg.mode);
+      }
+      if (!dangerouslySkipPermissions) {
+        sm.currentPermissionMode = msg.mode;
+        var session = sm.getActiveSession();
+        if (session) {
+          sdk.setPermissionMode(session, msg.mode);
+        }
+        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+      }
+      return;
+    }
+
+    if (msg.type === "set_project_default_mode" && msg.mode) {
+      if (typeof opts.onSetProjectDefaultMode === "function") {
+        opts.onSetProjectDefaultMode(slug, msg.mode);
+      }
+      if (!dangerouslySkipPermissions) {
+        sm.currentPermissionMode = msg.mode;
+        var session = sm.getActiveSession();
+        if (session) {
+          sdk.setPermissionMode(session, msg.mode);
+        }
+        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+      }
       return;
     }
 
@@ -505,9 +1136,27 @@ function createProjectContext(opts) {
       return;
     }
 
+    if (msg.type === "set_server_default_effort" && msg.effort) {
+      if (typeof opts.onSetServerDefaultEffort === "function") {
+        opts.onSetServerDefaultEffort(msg.effort);
+      }
+      sm.currentEffort = msg.effort;
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [] });
+      return;
+    }
+
+    if (msg.type === "set_project_default_effort" && msg.effort) {
+      if (typeof opts.onSetProjectDefaultEffort === "function") {
+        opts.onSetProjectDefaultEffort(slug, msg.effort);
+      }
+      sm.currentEffort = msg.effort;
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [] });
+      return;
+    }
+
     if (msg.type === "set_betas") {
       sm.currentBetas = msg.betas || [];
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "high", betas: sm.currentBetas });
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas });
       return;
     }
 
@@ -593,6 +1242,7 @@ function createProjectContext(opts) {
           session.pendingPermissions = {};
           session.pendingAskUser = {};
           session.isProcessing = false;
+          onProcessingChanged();
 
           sm.saveSessionFile(session);
           sm.switchSession(session.localId);
@@ -641,7 +1291,7 @@ function createProjectContext(opts) {
       if (decision === "allow_accept_edits") {
         sdk.setPermissionMode(session, "acceptEdits");
         sm.currentPermissionMode = "acceptEdits";
-        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
         pending.resolve({ behavior: "allow", updatedInput: pending.toolInput });
         sm.sendAndRecord(session, { type: "permission_resolved", requestId: requestId, decision: decision });
         return;
@@ -653,14 +1303,24 @@ function createProjectContext(opts) {
         pending.resolve({ behavior: "deny", message: "User chose to clear context and restart" });
         sm.sendAndRecord(session, { type: "permission_resolved", requestId: requestId, decision: decision });
 
-        // Abort the old session's query so it stops processing immediately
-        if (session.abortController) {
-          session.abortController.abort();
-        }
+        // Abort the old session's query — but defer to next tick so the SDK's
+        // deny write (scheduled as microtask by pending.resolve) completes first.
+        // Aborting synchronously would kill the subprocess before the write,
+        // causing an "Operation aborted" crash in the SDK.
         session.isProcessing = false;
+        onProcessingChanged();
         session.pendingPermissions = {};
         session.pendingAskUser = {};
         sm.broadcastSessionList();
+        setImmediate(function () {
+          if (session.abortController) {
+            session.abortController.abort();
+          }
+        });
+
+        // Update permission mode for the new session
+        sm.currentPermissionMode = "acceptEdits";
+        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
 
         // Build prompt from plan content (sent from client) or plan file path
         var clientPlanContent = msg.planContent || "";
@@ -672,24 +1332,34 @@ function createProjectContext(opts) {
           planPrompt = "Execute the plan in " + planFilePath + ". Do NOT re-enter plan mode — read the plan file and implement it step by step.";
         }
 
-        // Wait a tick for the deny to propagate, then create new session + send plan
-        setTimeout(function () {
-          var newSession = sm.createSession();
-          // Send the plan as the first user message (with planContent for UI rendering)
-          var userMsg = { type: "user_message", text: planPrompt, planContent: clientPlanContent || null };
-          newSession.history.push(userMsg);
-          sm.appendToSessionFile(newSession, userMsg);
-          newSession.title = "Plan execution (cleared context)";
-          sm.saveSessionFile(newSession);
-          sm.broadcastSessionList();
-          send(userMsg);
+        // Wait for old query stream to fully terminate, then create new session + send plan
+        var oldStreamPromise = session.streamPromise || Promise.resolve();
+        Promise.race([
+          oldStreamPromise,
+          new Promise(function (resolve) { setTimeout(resolve, 3000); }),
+        ]).then(function () {
+          try {
+            var newSession = sm.createSession();
+            // Send the plan as the first user message (with planContent for UI rendering)
+            var userMsg = { type: "user_message", text: planPrompt, planContent: clientPlanContent || null };
+            newSession.history.push(userMsg);
+            sm.appendToSessionFile(newSession, userMsg);
+            newSession.title = "Plan execution (cleared context)";
+            sm.saveSessionFile(newSession);
+            sm.broadcastSessionList();
+            send(userMsg);
 
-          newSession.isProcessing = true;
-          newSession.sentToolResults = {};
-          send({ type: "status", status: "processing" });
-          newSession.acceptEditsAfterStart = true;
-          sdk.startQuery(newSession, planPrompt);
-        }, 200);
+            newSession.isProcessing = true;
+            onProcessingChanged();
+            newSession.sentToolResults = {};
+            send({ type: "status", status: "processing" });
+            newSession.acceptEditsAfterStart = true;
+            sdk.startQuery(newSession, planPrompt);
+          } catch (e) {
+            console.error("[project] Error starting plan execution:", e);
+            send({ type: "error", text: "Failed to start plan execution: " + (e.message || e) });
+          }
+        });
         return;
       }
 
@@ -709,6 +1379,7 @@ function createProjectContext(opts) {
 
             if (!session.isProcessing) {
               session.isProcessing = true;
+              onProcessingChanged();
               session.sentToolResults = {};
               send({ type: "status", status: "processing" });
               if (!session.queryInstance) {
@@ -820,6 +1491,52 @@ function createProjectContext(opts) {
       return;
     }
 
+    // --- Reorder projects ---
+    if (msg.type === "reorder_projects") {
+      var slugs = msg.slugs;
+      if (!Array.isArray(slugs) || slugs.length === 0) {
+        sendTo(ws, { type: "reorder_projects_result", ok: false, error: "Missing slugs" });
+        return;
+      }
+      if (typeof opts.onReorderProjects === "function") {
+        var reorderResult = opts.onReorderProjects(slugs);
+        sendTo(ws, { type: "reorder_projects_result", ok: reorderResult.ok, error: reorderResult.error });
+      } else {
+        sendTo(ws, { type: "reorder_projects_result", ok: false, error: "Not supported" });
+      }
+      return;
+    }
+
+    // --- Set project title (rename) ---
+    if (msg.type === "set_project_title") {
+      if (!msg.slug) {
+        sendTo(ws, { type: "set_project_title_result", ok: false, error: "Missing slug" });
+        return;
+      }
+      if (typeof opts.onSetProjectTitle === "function") {
+        var titleResult = opts.onSetProjectTitle(msg.slug, msg.title || null);
+        sendTo(ws, { type: "set_project_title_result", ok: titleResult.ok, slug: msg.slug, error: titleResult.error });
+      } else {
+        sendTo(ws, { type: "set_project_title_result", ok: false, error: "Not supported" });
+      }
+      return;
+    }
+
+    // --- Set project icon (emoji) ---
+    if (msg.type === "set_project_icon") {
+      if (!msg.slug) {
+        sendTo(ws, { type: "set_project_icon_result", ok: false, error: "Missing slug" });
+        return;
+      }
+      if (typeof opts.onSetProjectIcon === "function") {
+        var iconResult = opts.onSetProjectIcon(msg.slug, msg.icon || null);
+        sendTo(ws, { type: "set_project_icon_result", ok: iconResult.ok, slug: msg.slug, error: iconResult.error });
+      } else {
+        sendTo(ws, { type: "set_project_icon_result", ok: false, error: "Not supported" });
+      }
+      return;
+    }
+
     // --- Daemon config (server settings) ---
     if (msg.type === "get_daemon_config") {
       if (typeof opts.onGetDaemonConfig === "function") {
@@ -860,6 +1577,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 || ".");
@@ -915,6 +1646,98 @@ function createProjectContext(opts) {
       return;
     }
 
+    // --- File write ---
+    if (msg.type === "fs_write") {
+      var fsWriteFile = safePath(cwd, msg.path);
+      if (!fsWriteFile) {
+        sendTo(ws, { type: "fs_write_result", path: msg.path, ok: false, error: "Access denied" });
+        return;
+      }
+      try {
+        fs.writeFileSync(fsWriteFile, msg.content || "", "utf8");
+        sendTo(ws, { type: "fs_write_result", path: msg.path, ok: true });
+      } catch (e) {
+        sendTo(ws, { type: "fs_write_result", path: msg.path, ok: false, error: e.message });
+      }
+      return;
+    }
+
+    // --- Project environment variables ---
+    if (msg.type === "get_project_env") {
+      var envrc = "";
+      var hasEnvrc = false;
+      if (typeof opts.onGetProjectEnv === "function") {
+        var envResult = opts.onGetProjectEnv(msg.slug);
+        envrc = envResult.envrc || "";
+      }
+      try {
+        var envrcPath = path.join(cwd, ".envrc");
+        hasEnvrc = fs.existsSync(envrcPath);
+      } catch (e) {}
+      sendTo(ws, { type: "project_env_result", slug: msg.slug, envrc: envrc, hasEnvrc: hasEnvrc });
+      return;
+    }
+
+    if (msg.type === "set_project_env") {
+      if (typeof opts.onSetProjectEnv === "function") {
+        var setResult = opts.onSetProjectEnv(msg.slug, msg.envrc || "");
+        sendTo(ws, { type: "set_project_env_result", ok: setResult.ok, slug: msg.slug, error: setResult.error });
+      } else {
+        sendTo(ws, { type: "set_project_env_result", ok: false, error: "Not supported" });
+      }
+      return;
+    }
+
+    // --- Global CLAUDE.md ---
+    if (msg.type === "read_global_claude_md") {
+      var os = require("os");
+      var globalMdPath = path.join(os.homedir(), ".claude", "CLAUDE.md");
+      try {
+        var globalMdContent = fs.readFileSync(globalMdPath, "utf8");
+        sendTo(ws, { type: "global_claude_md_result", content: globalMdContent });
+      } catch (e) {
+        sendTo(ws, { type: "global_claude_md_result", error: e.message });
+      }
+      return;
+    }
+
+    if (msg.type === "write_global_claude_md") {
+      var os2 = require("os");
+      var globalMdDir = path.join(os2.homedir(), ".claude");
+      var globalMdWritePath = path.join(globalMdDir, "CLAUDE.md");
+      try {
+        if (!fs.existsSync(globalMdDir)) {
+          fs.mkdirSync(globalMdDir, { recursive: true });
+        }
+        fs.writeFileSync(globalMdWritePath, msg.content || "", "utf8");
+        sendTo(ws, { type: "write_global_claude_md_result", ok: true });
+      } catch (e) {
+        sendTo(ws, { type: "write_global_claude_md_result", ok: false, error: e.message });
+      }
+      return;
+    }
+
+    // --- Shared environment variables ---
+    if (msg.type === "get_shared_env") {
+      var sharedEnvrc = "";
+      if (typeof opts.onGetSharedEnv === "function") {
+        var sharedResult = opts.onGetSharedEnv();
+        sharedEnvrc = sharedResult.envrc || "";
+      }
+      sendTo(ws, { type: "shared_env_result", envrc: sharedEnvrc });
+      return;
+    }
+
+    if (msg.type === "set_shared_env") {
+      if (typeof opts.onSetSharedEnv === "function") {
+        var sharedSetResult = opts.onSetSharedEnv(msg.envrc || "");
+        sendTo(ws, { type: "set_shared_env_result", ok: sharedSetResult.ok, error: sharedSetResult.error });
+      } else {
+        sendTo(ws, { type: "set_shared_env_result", ok: false, error: "Not supported" });
+      }
+      return;
+    }
+
     // --- File watcher ---
     if (msg.type === "fs_watch") {
       if (msg.path) startFileWatch(msg.path);
@@ -1195,6 +2018,117 @@ function createProjectContext(opts) {
       return;
     }
 
+    if (msg.type === "loop_start") {
+      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 newLoopId = generateLoopId();
+      loopState.loopId = newLoopId;
+      loopState.wizardData = {
+        name: (wData.name || "").replace(/[^a-zA-Z0-9_-]/g, "") || "ralph",
+        task: wData.task || "",
+        maxIterations: maxIter,
+      };
+      loopState.phase = "crafting";
+      loopState.startedAt = Date.now();
+      saveLoopState();
+
+      // 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 = "/clay-ralph\n## Task\n" + (wData.task || "") +
+        "\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;
+      sm.saveSessionFile(craftingSession);
+      sm.switchSession(craftingSession.localId);
+      sm.broadcastSessionList();
+      loopState.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 });
+      send({ type: "ralph_phase", phase: "crafting", wizardData: loopState.wizardData, craftingSessionId: craftingSession.localId });
+      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;
+    }
+
     if (msg.type !== "message") return;
     if (!msg.text && (!msg.images || msg.images.length === 0) && (!msg.pastes || msg.pastes.length === 0)) return;
 
@@ -1228,6 +2162,7 @@ function createProjectContext(opts) {
 
     if (!session.isProcessing) {
       session.isProcessing = true;
+      onProcessingChanged();
       session.sentToolResults = {};
       send({ type: "status", status: "processing" });
       if (!session.queryInstance) {
@@ -1254,6 +2189,54 @@ function createProjectContext(opts) {
 
   // --- Handle project-scoped HTTP requests ---
   function handleHTTP(req, res, urlPath) {
+    // File upload
+    if (req.method === "POST" && urlPath === "/api/upload") {
+      parseJsonBody(req).then(function (body) {
+        var fileName = body.name;
+        var fileData = body.data; // base64
+        if (!fileName || !fileData) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end('{"error":"missing name or data"}');
+          return;
+        }
+        // Sanitize filename — strip path separators
+        var safeName = path.basename(fileName).replace(/[^a-zA-Z0-9._\-\(\)\[\] ]/g, "_");
+        if (!safeName) safeName = "upload";
+
+        // Check size
+        var estimatedBytes = fileData.length * 0.75;
+        if (estimatedBytes > MAX_UPLOAD_BYTES) {
+          res.writeHead(413, { "Content-Type": "application/json" });
+          res.end('{"error":"file too large (max 50MB)"}');
+          return;
+        }
+
+        // Create tmp dir: os.tmpdir()/clay-{hash}/
+        var cwdHash = crypto.createHash("sha256").update(cwd).digest("hex").substring(0, 12);
+        var tmpDir = path.join(os.tmpdir(), "clay-" + cwdHash);
+        try { fs.mkdirSync(tmpDir, { recursive: true }); } catch (e) {}
+
+        // Add timestamp prefix to avoid collisions
+        var ts = Date.now();
+        var destName = ts + "-" + safeName;
+        var destPath = path.join(tmpDir, destName);
+
+        try {
+          var buf = Buffer.from(fileData, "base64");
+          fs.writeFileSync(destPath, buf);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ path: destPath, name: safeName }));
+        } catch (e) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "failed to save: " + (e.message || e) }));
+        }
+      }).catch(function () {
+        res.writeHead(400);
+        res.end("Bad request");
+      });
+      return true;
+    }
+
     // Push subscribe
     if (req.method === "POST" && urlPath === "/api/push-subscribe") {
       parseJsonBody(req).then(function (body) {
@@ -1342,6 +2325,157 @@ function createProjectContext(opts) {
       return true;
     }
 
+    // Install a skill (background spawn)
+    if (req.method === "POST" && urlPath === "/api/install-skill") {
+      parseJsonBody(req).then(function (body) {
+        var url = body.url;
+        var skill = body.skill;
+        var scope = body.scope; // "global" or "project"
+        if (!url || !skill || !scope) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end('{"error":"missing url, skill, or scope"}');
+          return;
+        }
+        var spawnCwd = scope === "global" ? os.homedir() : cwd;
+        var child = spawn("npx", ["skills", "add", url, "--skill", skill], {
+          cwd: spawnCwd,
+          stdio: "ignore",
+          detached: false,
+        });
+        child.on("close", function (code) {
+          var success = code === 0;
+          send({
+            type: "skill_installed",
+            skill: skill,
+            scope: scope,
+            success: success,
+            error: success ? null : "Process exited with code " + code,
+          });
+        });
+        child.on("error", function (err) {
+          send({
+            type: "skill_installed",
+            skill: skill,
+            scope: scope,
+            success: false,
+            error: err.message,
+          });
+        });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end('{"ok":true}');
+      }).catch(function () {
+        res.writeHead(400);
+        res.end("Bad request");
+      });
+      return true;
+    }
+
+    // Uninstall a skill (remove directory)
+    if (req.method === "POST" && urlPath === "/api/uninstall-skill") {
+      parseJsonBody(req).then(function (body) {
+        var skill = body.skill;
+        var scope = body.scope; // "global" or "project"
+        if (!skill || !scope) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end('{"error":"missing skill or scope"}');
+          return;
+        }
+        var baseDir = scope === "global" ? os.homedir() : cwd;
+        var skillDir = path.join(baseDir, ".claude", "skills", skill);
+        // Safety: ensure skillDir is inside the expected .claude/skills directory
+        var expectedParent = path.join(baseDir, ".claude", "skills");
+        var resolved = path.resolve(skillDir);
+        if (!resolved.startsWith(expectedParent + path.sep)) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end('{"error":"invalid skill path"}');
+          return;
+        }
+        try {
+          fs.rmSync(resolved, { recursive: true, force: true });
+          send({
+            type: "skill_uninstalled",
+            skill: skill,
+            scope: scope,
+            success: true,
+          });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end('{"ok":true}');
+        } catch (err) {
+          send({
+            type: "skill_uninstalled",
+            skill: skill,
+            scope: scope,
+            success: false,
+            error: err.message,
+          });
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      }).catch(function () {
+        res.writeHead(400);
+        res.end("Bad request");
+      });
+      return true;
+    }
+
+    // Installed skills (global + project)
+    if (req.method === "GET" && urlPath === "/api/installed-skills") {
+      var installed = {};
+      var globalDir = path.join(os.homedir(), ".claude", "skills");
+      var projectDir = path.join(cwd, ".claude", "skills");
+      var scanDirs = [
+        { dir: globalDir, scope: "global" },
+        { dir: projectDir, scope: "project" },
+      ];
+      for (var sd = 0; sd < scanDirs.length; sd++) {
+        var entries;
+        try { entries = fs.readdirSync(scanDirs[sd].dir, { withFileTypes: true }); } catch (e) { continue; }
+        for (var si = 0; si < entries.length; si++) {
+          var ent = entries[si];
+          if (!ent.isDirectory() && !ent.isSymbolicLink()) continue;
+          var mdPath = path.join(scanDirs[sd].dir, ent.name, "SKILL.md");
+          try {
+            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, 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) {}
+        }
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ installed: installed }));
+      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, {
@@ -1374,6 +2508,12 @@ function createProjectContext(opts) {
       try { ws.close(); } catch (e) {}
     }
     clients.clear();
+    // Cleanup tmp upload directory
+    try {
+      var cwdHash = crypto.createHash("sha256").update(cwd).digest("hex").substring(0, 12);
+      var tmpDir = path.join(os.tmpdir(), "clay-" + cwdHash);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch (e) {}
   }
 
   // --- Status info ---
@@ -1388,6 +2528,7 @@ function createProjectContext(opts) {
       path: cwd,
       project: project,
       title: title,
+      icon: icon,
       clients: clients.size,
       sessions: sessionCount,
       isProcessing: hasProcessing,
@@ -1399,6 +2540,10 @@ function createProjectContext(opts) {
     send({ type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, lanHost: lanHost, projectCount: getProjectCount(), projects: getProjectList() });
   }
 
+  function setIcon(newIcon) {
+    icon = newIcon || null;
+  }
+
   return {
     cwd: cwd,
     slug: slug,
@@ -1414,6 +2559,7 @@ function createProjectContext(opts) {
     handleHTTP: handleHTTP,
     getStatus: getStatus,
     setTitle: setTitle,
+    setIcon: setIcon,
     warmup: function () { sdk.warmup(); },
     destroy: destroy,
   };