clay-server 2.44.1-beta.2 → 2.45.0-beta.1

package/lib/daemon.js

@@ -703,7 +703,7 @@ var relay = createServer({
       osUsers: !!config.osUsers,
       inheritGroups: config.inheritGroups !== false,
       chatLayout: config.chatLayout || "channel",
-      matesEnabled: config.matesEnabled !== false,
+      matesEnabled: config.matesEnabled === true,
       pinEnabled: !!config.pinHash,
       platform: process.platform,
       hostname: os2.hostname(),

package/lib/project-sessions.js

@@ -169,19 +169,32 @@ function attachSessions(ctx) {
         var termId = (typeof s.runtimeTerminalId === "number")
           ? s.runtimeTerminalId
           : (typeof s.terminalId === "number" ? s.terminalId : null);
-        try {
-          ctx._notifications && ctx._notifications.notify("tui_attention", {
-            slug: slug,
-            sessionId: s.localId,
-            ownerId: s.ownerId || null,
-            targetUserId: s.ownerId || null,
-            title: "Claude responded",
-            body: firstLine,
-            terminalId: termId,
-            sessionTitle: s.title || "",
-            cliSessionId: s.cliSessionId || null,
-          });
-        } catch (e) {}
+        // Don't banner a session someone is already watching — they can see
+        // the reply in the TUI. Gate at the source (server) rather than relying
+        // on the client's activeSessionId suppression, which isn't reliable for
+        // TUI sessions and lets banners pile up for the session in view.
+        var beingViewed = false;
+        for (var vws of clients) {
+          if (vws.readyState === 1 && vws._clayActiveSession === s.localId) {
+            beingViewed = true;
+            break;
+          }
+        }
+        if (!beingViewed) {
+          try {
+            ctx._notifications && ctx._notifications.notify("tui_attention", {
+              slug: slug,
+              sessionId: s.localId,
+              ownerId: s.ownerId || null,
+              targetUserId: s.ownerId || null,
+              title: "Claude responded",
+              body: firstLine,
+              terminalId: termId,
+              sessionTitle: s.title || "",
+              cliSessionId: s.cliSessionId || null,
+            });
+          } catch (e) {}
+        }
         // Re-read the assistant text index and broadcast it so any client
         // with this session in view can wire hover-to-grab onto the new
         // message right away. The transcript is small enough that a full
@@ -904,6 +917,24 @@ function attachSessions(ctx) {
       return true;
     }
 
+    if (msg.type === "reload_skills") {
+      var session = getSessionForWs(ws);
+      if (session && sdk.reloadSkills) {
+        sdk.reloadSkills(session);
+      }
+      return true;
+    }
+
+    if (msg.type === "set_mcp_permission_mode_override" && msg.serverName) {
+      var session = getSessionForWs(ws);
+      if (session && sdk.setMcpPermissionModeOverride) {
+        // mode: "default" | "auto" | null (null clears the override)
+        var mcpMode = (msg.mode === "auto" || msg.mode === "default") ? msg.mode : null;
+        sdk.setMcpPermissionModeOverride(session, msg.serverName, mcpMode);
+      }
+      return true;
+    }
+
     if (msg.type === "set_vendor" && msg.vendor) {
       var vendorSession = getSessionForWs(ws);
       if (vendorSession) {
@@ -1256,13 +1287,18 @@ function attachSessions(ctx) {
           sdk.pushMessage(session, answerText);
         }
       } else {
-        // Claude native AskUserQuestion path (canUseTool). The SDK is
-        // synchronously blocked on the permission callback, so we must
-        // resolve it with the standard permission shape.
-        pending.resolve({
-          behavior: "allow",
-          updatedInput: Object.assign({}, pending.input, { answers: answers }),
-        });
+        // Claude native AskUserQuestion path (built-in tool, intercepted via
+        // canUseTool). In headless SDK mode the built-in can't render its own
+        // answer UI: resolving "allow" lets it return an EMPTY result, so the
+        // model continues the same turn with no answer ("I don't see an
+        // answer"). Injected user messages also lose the race against that
+        // empty result. Instead, deliver the answer as the tool_result by
+        // denying with the formatted answer text — the SDK surfaces a deny
+        // `message` to the model as the tool result, so the model receives the
+        // user's choice in the same turn. (updatedInput.answers is not read by
+        // the 0.3.x built-in, which is what caused answers to be dropped.)
+        var nativeAnswerText = formatAskUserAnswerAsMessage(pending.input, answers);
+        pending.resolve({ behavior: "deny", message: nativeAnswerText });
       }
       return true;
     }
@@ -1457,6 +1493,26 @@ function attachSessions(ctx) {
       return true;
     }
 
+    // --- Host user dialog response (SDK request_user_dialog) ---
+    if (msg.type === "user_dialog_response") {
+      var session = getSessionForWs(ws);
+      if (!session) return true;
+      var pending = session.pendingUserDialogs && session.pendingUserDialogs[msg.requestId];
+      if (!pending) return true;
+      delete session.pendingUserDialogs[msg.requestId];
+      if (msg.behavior === "completed") {
+        pending.resolve({ behavior: "completed", result: msg.result });
+      } else {
+        pending.resolve({ behavior: "cancelled" });
+      }
+      sm.sendAndRecord(session, {
+        type: "user_dialog_resolved",
+        requestId: msg.requestId,
+        behavior: msg.behavior === "completed" ? "completed" : "cancelled",
+      });
+      return true;
+    }
+
     // --- Browse directories (for add-project autocomplete) ---
     if (msg.type === "browse_dir") {
       var rawPath = (msg.path || "").replace(/^~/, require("./config").REAL_HOME);

package/lib/public/app.js

@@ -287,7 +287,7 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     cachedMatesList: [],
     cachedDmFavorites: [],
     cachedAvailableBuiltins: [],
-    matesEnabled: true,
+    matesEnabled: false,
     returningFromMateDm: false,
     pendingMateInterview: null,
     pendingTermCommand: null,

package/lib/public/modules/app-messages.js

@@ -21,7 +21,7 @@ import { renderMemoryList } from './mate-memory.js';
 import { handlePaletteSessionSwitch, setPaletteVersion } from './command-palette.js';
 import { handleFindInSessionResults } from './session-search.js';
 import { handleInputSync, autoResize, builtinCommands, setScheduleBtnDisabled } from './input.js';
-import { startThinking, appendThinking, stopThinking, resetThinkingGroup, createToolItem, updateToolExecuting, updateToolResult, markAllToolsDone, closeToolGroup, removeToolFromGroup, resetToolState, getTools, getPlanContent, setPlanContent, renderPlanBanner, renderPlanCard, getTodoTools, handleTodoWrite, handleTaskCreate, handleTaskUpdate, applyDeadSessionTodoCompaction, isPlanFilePath, enableMainInput, addTurnMeta, updateSubagentActivity, addSubagentToolEntry, markSubagentDone, initSubagentStop, updateSubagentProgress, updateSubagentTaskStatus, renderAskUserQuestion, markAskUserAnswered, renderPermissionRequest, markPermissionCancelled, markPermissionResolved, renderElicitationRequest, markElicitationResolved } from './tools.js';
+import { startThinking, appendThinking, stopThinking, resetThinkingGroup, createToolItem, updateToolExecuting, updateToolResult, markAllToolsDone, closeToolGroup, removeToolFromGroup, resetToolState, getTools, getPlanContent, setPlanContent, renderPlanBanner, renderPlanCard, getTodoTools, handleTodoWrite, handleTaskCreate, handleTaskUpdate, applyDeadSessionTodoCompaction, isPlanFilePath, enableMainInput, addTurnMeta, updateSubagentActivity, addSubagentToolEntry, markSubagentDone, initSubagentStop, updateSubagentProgress, updateSubagentTaskStatus, renderAskUserQuestion, markAskUserAnswered, renderPermissionRequest, markPermissionCancelled, markPermissionResolved, renderElicitationRequest, markElicitationResolved, renderUserDialogRequest, markUserDialogResolved, updateThinkingTokens } from './tools.js';
 import { showDoneNotification, playDoneSound, isNotifAlertEnabled, isNotifSoundEnabled } from './notifications.js';
 import { handleFsList, handleFsRead, handleFileChanged, handleDirChanged, handleFileHistory, handleGitDiff, handleFileAt, refreshIfOpen, getPendingNavigate, handleFsSearch } from './filebrowser.js';
 import { isProjectSettingsOpen, handleInstructionsRead, handleInstructionsWrite, handleProjectEnv, handleProjectEnvSaved, handleProjectSharedEnv, handleProjectSharedEnvSaved, handleProjectOwnerChanged } from './project-settings.js';
@@ -992,6 +992,16 @@ export function processMessage(msg) {
         stopUrgentBlink();
         break;
 
+      case "user_dialog_request":
+        renderUserDialogRequest(msg);
+        startUrgentBlink();
+        break;
+
+      case "user_dialog_resolved":
+        markUserDialogResolved(msg.requestId, msg.behavior);
+        stopUrgentBlink();
+        break;
+
       case "slash_command_result":
         finalizeAssistantBlock();
         var cmdBlock = document.createElement("div");
@@ -1088,6 +1098,43 @@ export function processMessage(msg) {
         addSystemMessage(msg.text, false);
         break;
 
+      case "thinking_tokens":
+        updateThinkingTokens(msg.estimatedTokens);
+        break;
+
+      case "informational":
+        // level: info | notice | suggestion | warning
+        if (msg.content) addSystemMessage(msg.content, msg.level === "warning");
+        break;
+
+      case "permission_denied": {
+        var deniedText = (msg.toolName ? msg.toolName + ": " : "")
+          + "tool call denied"
+          + (msg.reason ? " — " + msg.reason : (msg.message ? " — " + msg.message : ""))
+          + ".";
+        addSystemMessage(deniedText, false);
+        break;
+      }
+
+      case "model_refusal": {
+        var refusalText;
+        if (msg.refusalKind === "fallback") {
+          refusalText = "The model declined this request and automatically retried"
+            + (msg.fallbackModel ? " with " + msg.fallbackModel : " with a fallback model")
+            + (msg.originalModel ? " (originally " + msg.originalModel + ")" : "")
+            + ".";
+          if (msg.category) refusalText += " Category: " + msg.category + ".";
+          addSystemMessage(refusalText, false);
+        } else {
+          refusalText = "The model declined to respond to this request.";
+          if (msg.explanation) refusalText += " " + msg.explanation;
+          else if (msg.content) refusalText += " " + msg.content;
+          if (msg.category) refusalText += " (Category: " + msg.category + ")";
+          addSystemMessage(refusalText, true);
+        }
+        break;
+      }
+
       case "process_conflict":
         removeMatePreThinking();
         setActivity(null);

package/lib/public/modules/mcp-ui.js

@@ -137,6 +137,28 @@ function renderMcpServerList() {
 
       row.appendChild(cb);
       row.appendChild(info);
+
+      // Per-server permission mode override (applies to the active session only).
+      if (server.projectEnabled) {
+        var modeSel = document.createElement("select");
+        modeSel.className = "mcp-server-perm-mode";
+        modeSel.dataset.serverName = server.name;
+        modeSel.title = "Permission mode for this server (this session only)";
+        var optAsk = document.createElement("option");
+        optAsk.value = "default";
+        optAsk.textContent = "Ask";
+        var optAuto = document.createElement("option");
+        optAuto.value = "auto";
+        optAuto.textContent = "Auto-approve";
+        modeSel.appendChild(optAsk);
+        modeSel.appendChild(optAuto);
+        modeSel.value = server.permissionModeOverride === "auto" ? "auto" : "default";
+        // The row is a <label>; keep select interactions from toggling the checkbox.
+        modeSel.addEventListener("click", function (e) { e.stopPropagation(); e.preventDefault(); });
+        modeSel.addEventListener("change", onPermissionModeChange);
+        row.appendChild(modeSel);
+      }
+
       contentEl.appendChild(row);
     }
     refreshIcons(contentEl);
@@ -293,3 +315,25 @@ function onToggle(e) {
     }));
   }
 }
+
+function onPermissionModeChange(e) {
+  var name = e.target.dataset.serverName;
+  var mode = e.target.value; // "default" | "auto"
+
+  // Remember locally so a re-render keeps the selection.
+  for (var i = 0; i < _mcpServers.length; i++) {
+    if (_mcpServers[i].name === name) {
+      _mcpServers[i].permissionModeOverride = mode;
+      break;
+    }
+  }
+
+  var ws = getWs();
+  if (ws && ws.readyState === 1) {
+    ws.send(JSON.stringify({
+      type: "set_mcp_permission_mode_override",
+      serverName: name,
+      mode: mode,
+    }));
+  }
+}

package/lib/public/modules/profile.js

@@ -590,8 +590,8 @@ export function initProfile(_ctx) {
 
     // Apply Mates UI gate at boot so the sidebar avatars / DM picker
     // entry / home-hub strip are hidden before the user opens settings.
-    // Default true: only flip the body class off when explicitly false.
-    var matesOn = data.matesEnabled !== false;
+    // Default OFF: Mates is opt-in, so only enable when explicitly true.
+    var matesOn = data.matesEnabled === true;
     store.set({ matesEnabled: matesOn });
     if (document.body) document.body.classList.toggle('mates-disabled', !matesOn);
   }).catch(function(err) {

package/lib/public/modules/skills.js

@@ -1,6 +1,16 @@
 import { iconHtml, refreshIcons } from './icons.js';
 import { escapeHtml, copyToClipboard, showToast } from './utils.js';
 import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+
+// Ask the active session to hot-reload skills so a just-installed/uninstalled
+// skill takes effect without restarting the session. No-op if no live session.
+function reloadActiveSessionSkills() {
+  var ws = getWs();
+  if (ws && ws.readyState === 1) {
+    ws.send(JSON.stringify({ type: "reload_skills" }));
+  }
+}
 
 var modal;
 var contentEl;
@@ -607,6 +617,9 @@ export function handleSkillInstalled(msg) {
     if (activeTab === "installed" && currentView === "list") {
       loadInstalledSkills();
     }
+
+    // Hot-reload skills in the active session so it's usable immediately
+    reloadActiveSessionSkills();
   } else {
     // Show error toast
     showToast("Failed to install " + skill + (msg.error ? ": " + msg.error : ""), "error");
@@ -676,6 +689,9 @@ export function handleSkillUninstalled(msg) {
     if (activeTab === "installed" && currentView === "list") {
       loadInstalledSkills();
     }
+
+    // Hot-reload skills in the active session so the change applies immediately
+    reloadActiveSessionSkills();
   } else {
     showToast("Failed to uninstall " + skill + (msg.error ? ": " + msg.error : ""), "error");
     // Re-enable the uninstall button

package/lib/public/modules/tools.js

@@ -1181,6 +1181,159 @@ export function markElicitationResolved(requestId, action) {
   delete pendingElicitations[requestId];
 }
 
+// --- Host user dialog (SDK request_user_dialog) ---
+// Generic, defensive renderer. We declare only kinds we handle in
+// supportedDialogKinds (server side), but treat the payload as opaque: render
+// a human message + any provided choices, fall back to Proceed/Cancel, and
+// log the raw payload so unseen shapes can be refined. Cancel is always safe.
+
+var pendingUserDialogs = {};
+
+function sendUserDialogResponse(container, requestId, behavior, result) {
+  if (container.classList.contains("resolved")) return;
+  container.classList.add("resolved");
+  if (ctx.stopUrgentBlink) ctx.stopUrgentBlink();
+
+  var isCancel = behavior !== "completed";
+  container.classList.add(isCancel ? "resolved-denied" : "resolved-allowed");
+
+  var actions = container.querySelector(".permission-actions");
+  if (actions) {
+    actions.innerHTML = '<span class="permission-decision-label">' + (isCancel ? "Cancelled" : "Submitted") + '</span>';
+  }
+
+  if (ctx.ws && ctx.connected) {
+    var msg = {
+      type: "user_dialog_response",
+      requestId: requestId,
+      behavior: isCancel ? "cancelled" : "completed",
+    };
+    if (!isCancel) msg.result = result;
+    ctx.ws.send(JSON.stringify(msg));
+  }
+
+  delete pendingUserDialogs[requestId];
+}
+
+export function renderUserDialogRequest(msg) {
+  if (pendingUserDialogs[msg.requestId]) return;
+  ctx.finalizeAssistantBlock();
+  stopThinking();
+  closeToolGroup();
+
+  var payload = msg.payload || {};
+  try { console.log("[user_dialog] kind=" + msg.dialogKind + " payload=", payload); } catch (e) {}
+
+  var container = document.createElement("div");
+  container.className = "permission-container user-dialog-container";
+  container.dataset.requestId = msg.requestId;
+
+  // Header
+  var titleText = payload.title || "Claude needs a decision";
+  var header = document.createElement("div");
+  header.className = "permission-header";
+  header.innerHTML =
+    '<span class="permission-icon">' + iconHtml("key") + '</span>' +
+    '<span class="permission-title">' + escapeHtml(titleText) + '</span>';
+
+  // Body: best-effort human message from common payload fields
+  var body = document.createElement("div");
+  body.className = "permission-body";
+  var messageText = payload.message || payload.prompt || payload.question || payload.text || "";
+  if (messageText) {
+    var messageEl = document.createElement("div");
+    messageEl.className = "permission-reason";
+    messageEl.textContent = String(messageText);
+    body.appendChild(messageEl);
+  }
+  var kindEl = document.createElement("div");
+  kindEl.className = "user-dialog-kind";
+  kindEl.style.cssText = "margin-top: 6px; font-size: 11px; color: var(--text-muted);";
+  kindEl.textContent = msg.dialogKind || "dialog";
+  body.appendChild(kindEl);
+
+  // Actions
+  var actions = document.createElement("div");
+  actions.className = "permission-actions";
+
+  // If the payload carries explicit choices, render one button per choice.
+  var choices = Array.isArray(payload.options) ? payload.options
+    : Array.isArray(payload.choices) ? payload.choices
+    : null;
+
+  if (choices && choices.length) {
+    for (var i = 0; i < choices.length; i++) {
+      (function (choice) {
+        var label = (choice && (choice.label || choice.title || choice.name)) || String(choice);
+        var value = (choice && ("value" in choice)) ? choice.value : choice;
+        var btn = document.createElement("button");
+        btn.className = "permission-btn permission-allow";
+        btn.textContent = label;
+        btn.addEventListener("click", function () {
+          sendUserDialogResponse(container, msg.requestId, "completed", value);
+        });
+        actions.appendChild(btn);
+      })(choices[i]);
+    }
+  } else {
+    var proceedBtn = document.createElement("button");
+    proceedBtn.className = "permission-btn permission-allow";
+    proceedBtn.textContent = "Proceed";
+    proceedBtn.addEventListener("click", function () {
+      sendUserDialogResponse(container, msg.requestId, "completed", {});
+    });
+    actions.appendChild(proceedBtn);
+  }
+
+  var cancelBtn = document.createElement("button");
+  cancelBtn.className = "permission-btn permission-deny";
+  cancelBtn.textContent = "Cancel";
+  cancelBtn.addEventListener("click", function () {
+    sendUserDialogResponse(container, msg.requestId, "cancelled", null);
+  });
+  actions.appendChild(cancelBtn);
+
+  container.appendChild(header);
+  container.appendChild(body);
+  container.appendChild(actions);
+  ctx.addToMessages(container);
+
+  pendingUserDialogs[msg.requestId] = container;
+  refreshIcons();
+  ctx.setActivity(null);
+  maybeScrollToBottom();
+}
+
+export function markUserDialogResolved(requestId, behavior) {
+  var container = pendingUserDialogs[requestId];
+  if (!container) {
+    container = ctx.messagesEl.querySelector('.user-dialog-container[data-request-id="' + requestId + '"]');
+  }
+  if (!container || container.classList.contains("resolved")) return;
+
+  container.classList.add("resolved");
+  var isCancel = behavior !== "completed";
+  container.classList.add(isCancel ? "resolved-denied" : "resolved-allowed");
+
+  var actionsEl = container.querySelector(".permission-actions");
+  if (actionsEl) {
+    actionsEl.innerHTML = '<span class="permission-decision-label">' + (isCancel ? "Cancelled" : "Submitted") + '</span>';
+  }
+  delete pendingUserDialogs[requestId];
+}
+
+// --- Live thinking-token estimate ---
+// Annotates the active thinking block's label with a running token estimate.
+// No-op when no thinking block is active.
+export function updateThinkingTokens(estimatedTokens) {
+  if (!currentThinking || !currentThinking.el) return;
+  var label = currentThinking.el.querySelector(".thinking-label");
+  if (!label) return;
+  var n = estimatedTokens || 0;
+  var disp = n >= 1000 ? ("~" + (Math.round(n / 100) / 10) + "k") : ("~" + n);
+  label.textContent = "Thinking " + disp + " tokens";
+}
+
 // --- Plan mode rendering ---
 export function renderPlanBanner(type) {
   ctx.finalizeAssistantBlock();
@@ -1554,6 +1707,8 @@ export function startThinking() {
     var el = thinkingGroup.el;
     el.classList.remove("done");
     el.querySelector(".thinking-content").textContent = "";
+    var reuseLabel = el.querySelector(".thinking-label");
+    if (reuseLabel) reuseLabel.textContent = "Thinking";
     // Mate mode: restore dots activity row, hide thinking header
     if (el.classList.contains("mate-thinking")) {
       var actRow = el.querySelector(".mate-thinking-activity");
@@ -2379,6 +2534,7 @@ export function resetToolState() {
   if (todoObserver) { todoObserver.disconnect(); todoObserver = null; }
   pendingPermissions = {};
   pendingElicitations = {};
+  pendingUserDialogs = {};
   currentToolGroup = null;
   toolGroupCounter = 0;
   toolGroups = {};

package/lib/public/modules/user-settings.js

@@ -468,8 +468,8 @@ function populateAccount() {
     if (data.mateOnboardingShown) {
       try { localStorage.setItem("clay-mate-onboarding-shown", "1"); } catch (e) {}
     }
-    // Mates UI toggle: default true; treat any missing/non-false value as on
-    var matesOn = data.matesEnabled !== false;
+    // Mates UI toggle: default OFF (opt-in); enable only when explicitly true
+    var matesOn = data.matesEnabled === true;
     var matesToggle = document.getElementById('us-mates-enabled');
     if (matesToggle) matesToggle.checked = matesOn;
     store.set({ matesEnabled: matesOn });

package/lib/sdk-bridge.js

@@ -392,6 +392,54 @@ function createSDKBridge(opts) {
     });
   }
 
+  // --- Host user dialog ---
+  // Mirrors handleElicitation: the adapter invokes onUserDialog with an opaque
+  // { dialogKind, payload }, we forward a user_dialog_request to the client, and
+  // resolve once the client answers. Which dialog kinds exist is the adapter's
+  // concern; the relay just transports them. Unknown kinds / autonomous mode
+  // resolve to { behavior: "cancelled" } (the no-dialog default).
+
+  function handleUserDialog(session, request, opts) {
+    // Ralph Loop: auto-cancel host dialogs in autonomous mode (CLI falls back
+    // to the no-dialog default, e.g. the classic refusal error).
+    if (session.loop && session.loop.active && session.loop.role !== "crafting") {
+      return Promise.resolve({ behavior: "cancelled" });
+    }
+
+    return new Promise(function(resolve) {
+      var requestId = crypto.randomUUID();
+      if (!session.pendingUserDialogs) session.pendingUserDialogs = {};
+      session.pendingUserDialogs[requestId] = {
+        resolve: resolve,
+        request: request,
+      };
+      sendAndRecord(session, {
+        type: "user_dialog_request",
+        requestId: requestId,
+        dialogKind: request.dialogKind,
+        payload: request.payload || {},
+        toolUseId: request.toolUseID || null,
+      });
+
+      if (pushModule) {
+        pushModule.sendPush({
+          type: "user_dialog",
+          slug: slug,
+          title: "Claude needs a decision",
+          body: "Waiting for your response",
+          tag: "claude-user-dialog",
+        });
+      }
+
+      if (opts.signal) {
+        opts.signal.addEventListener("abort", function() {
+          delete session.pendingUserDialogs[requestId];
+          resolve({ behavior: "cancelled" });
+        });
+      }
+    });
+  }
+
 
   // --- Linux user project directory setup ---
   // Ensures the linux user's .claude project directory exists and is writable,
@@ -1281,6 +1329,9 @@ function createSDKBridge(opts) {
       onElicitation: function(request, elicitOpts) {
         return handleElicitation(session, request, elicitOpts);
       },
+      onUserDialog: function(dialogRequest, dialogOpts) {
+        return handleUserDialog(session, dialogRequest, dialogOpts);
+      },
       callMcpTool: function(serverName, toolName, args) {
         return callMcpToolHandler(mergedMcpServers, serverName, toolName, args);
       },
@@ -1603,6 +1654,29 @@ function createSDKBridge(opts) {
     }
   }
 
+  // Hot-reload skills/MCP/agents on the active query without a restart.
+  async function reloadSkills(session) {
+    if (!session || !session.queryInstance) return;
+    try {
+      // Route through QueryHandle (works for both in-process and worker paths)
+      await session.queryInstance.reloadSkills();
+      send({ type: "system_info", text: "Skills reloaded." });
+    } catch (e) {
+      send({ type: "error", text: "Failed to reload skills: " + (e.message || e) });
+    }
+  }
+
+  // Override the permission mode for one MCP server on the active query.
+  async function setMcpPermissionModeOverride(session, serverName, mode) {
+    if (!session || !session.queryInstance) return;
+    try {
+      // Route through QueryHandle (works for both in-process and worker paths)
+      await session.queryInstance.setMcpPermissionModeOverride(serverName, mode);
+    } catch (e) {
+      send({ type: "error", text: "Failed to set MCP permission mode: " + (e.message || e) });
+    }
+  }
+
   // --- @Mention: persistent read-only session for a mentioned Mate ---
   // Creates a mention session that can be reused across multiple mentions
   // within a conversation flow (session continuity).
@@ -1789,6 +1863,8 @@ function createSDKBridge(opts) {
     permissionPushBody: permissionPushBody,
     warmup: warmup,
     stopTask: stopTask,
+    reloadSkills: reloadSkills,
+    setMcpPermissionModeOverride: setMcpPermissionModeOverride,
     createMentionSession: createMentionSession,
     startIdleReaper: startIdleReaper,
     stopIdleReaper: stopIdleReaper,

package/lib/sdk-message-processor.js

@@ -698,6 +698,73 @@ function attachMessageProcessor(ctx) {
       var retryText = parsed.message || parsed.error || "Retrying API request...";
       sendToSession(session, { type: "system_info", text: retryText });
 
+    } else if (parsed.yokeType === "commands_changed") {
+      // Mid-session command list change: rebuild the union with skills (same as
+      // init) and push a full replacement to the client.
+      var cmdSeen = new Set();
+      var cmdCombined = [];
+      var cmdAll = (parsed.commandNames || []).concat(Array.from(sm.skillNames || []));
+      for (var ci = 0; ci < cmdAll.length; ci++) {
+        if (!cmdSeen.has(cmdAll[ci])) {
+          cmdSeen.add(cmdAll[ci]);
+          cmdCombined.push(cmdAll[ci]);
+        }
+      }
+      sm.slashCommands = cmdCombined;
+      send({ type: "slash_commands", commands: sm.slashCommands });
+
+    } else if (parsed.yokeType === "worker_shutting_down") {
+      // Surface non-routine teardown reasons; "host_exit" is the normal close.
+      if (parsed.reason && parsed.reason !== "host_exit") {
+        sendToSession(session, { type: "system_info", text: "Session worker shutting down: " + parsed.reason });
+      }
+
+    } else if (parsed.yokeType === "thinking_tokens") {
+      // Live thinking-token estimate; ephemeral, do not persist in history.
+      sendToSession(session, {
+        type: "thinking_tokens",
+        estimatedTokens: parsed.estimatedTokens || 0,
+        estimatedTokensDelta: parsed.estimatedTokensDelta || 0,
+      });
+
+    } else if (parsed.yokeType === "informational") {
+      // Leveled informational message from the agent (info/notice/suggestion/warning).
+      if (parsed.content) {
+        sendAndRecord(session, {
+          type: "informational",
+          level: parsed.level || "info",
+          content: parsed.content,
+          toolUseId: parsed.toolUseId || null,
+          preventContinuation: !!parsed.preventContinuation,
+        });
+      }
+
+    } else if (parsed.yokeType === "permission_denied") {
+      // A tool call was blocked; surface why.
+      sendAndRecord(session, {
+        type: "permission_denied",
+        toolName: parsed.toolName || "",
+        toolUseId: parsed.toolUseId || null,
+        agentId: parsed.agentId || null,
+        reasonType: parsed.reasonType || null,
+        reason: parsed.reason || null,
+        message: parsed.message || "",
+      });
+
+    } else if (parsed.yokeType === "model_refusal") {
+      // Model declined the request. "fallback" => the CLI retried on another
+      // model; "no_fallback" => the turn ended with a refusal.
+      sendAndRecord(session, {
+        type: "model_refusal",
+        refusalKind: parsed.refusalKind || "no_fallback",
+        originalModel: parsed.originalModel || null,
+        fallbackModel: parsed.fallbackModel || null,
+        direction: parsed.direction || null,
+        category: parsed.category || null,
+        explanation: parsed.explanation || null,
+        content: parsed.content || null,
+      });
+
     } else if (parsed.yokeType === "system") {
       // Catch-all for unhandled system subtypes (e.g. hook-block errors).
       // Extract any error text and surface it in the UI.

package/lib/server-settings.js

@@ -29,7 +29,7 @@ function attachSettings(ctx) {
         profile.autoContinueOnRateLimit = !!mu.autoContinueOnRateLimit;
         profile.chatLayout = mu.chatLayout || "channel";
         profile.mateOnboardingShown = !!mu.mateOnboardingShown;
-        profile.matesEnabled = mu.matesEnabled !== false;
+        profile.matesEnabled = mu.matesEnabled === true;
         try { profile.terminalFont = users.getTerminalFont(mu.id); } catch (e) {}
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify(profile));
@@ -52,7 +52,7 @@ function attachSettings(ctx) {
         profile.autoContinueOnRateLimit = !!dc.autoContinueOnRateLimit;
         profile.chatLayout = dc.chatLayout || "channel";
         profile.mateOnboardingShown = !!dc.mateOnboardingShown;
-        profile.matesEnabled = dc.matesEnabled !== false;
+        profile.matesEnabled = dc.matesEnabled === true;
         if (dc.terminalFont && typeof dc.terminalFont === "object") {
           profile.terminalFont = {
             family: dc.terminalFont.family || "'SF Mono', Menlo, Monaco, 'Courier New', monospace",

package/lib/users-preferences.js

@@ -334,20 +334,21 @@ function attachPreferences(deps) {
 
   // --- Per-user Mates UI toggle ---
   //
-  // When false, the entire Mates surface (sidebar avatars, DM "Create a
-  // Mate" entry, home-hub mates strip) is hidden for this user. Default
-  // is ON: Mates is opt-out, not opt-in. Stored as `matesEnabled`; we
-  // treat any value other than the literal `false` as enabled so brand-
-  // new users (no field set) get the default-on experience.
+  // When disabled, the entire Mates surface (sidebar avatars, DM "Create a
+  // Mate" entry, home-hub mates strip) is hidden for this user; multi-user
+  // and the rest of the sidebar are unaffected. Default is OFF: Mates is
+  // opt-in, not opt-out. Stored as `matesEnabled`; only the literal `true`
+  // enables it, so brand-new users (no field set) get the default-off
+  // experience and must turn Mates on explicitly in settings.
 
   function getMatesEnabled(userId) {
     var data = loadUsers();
     for (var i = 0; i < data.users.length; i++) {
       if (data.users[i].id === userId) {
-        return data.users[i].matesEnabled !== false;
+        return data.users[i].matesEnabled === true;
       }
     }
-    return true;
+    return false;
   }
 
   function setMatesEnabled(userId, enabled) {

package/lib/ws-schema.js

@@ -67,6 +67,10 @@ var schema = {
   "compacting":               { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Conversation compaction in progress (active: true/false)" },
   "message_uuid":             { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "UUID assigned to a user or assistant message" },
   "prompt_suggestion":        { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Suggested follow-up prompt from the assistant" },
+  "model_refusal":            { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Model declined the request (fallback to another model, or no fallback)" },
+  "informational":            { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Leveled informational message from the agent (info/notice/suggestion/warning)" },
+  "permission_denied":        { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "A tool call was denied; explains why" },
+  "thinking_tokens":          { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Live thinking-token estimate (ephemeral)" },
   "context_preview":          { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Preview of context sources included in a query" },
 
   // -----------------------------------------------------------------------
@@ -115,6 +119,9 @@ var schema = {
   "elicitation_request":      { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Structured form elicitation request from assistant" },
   "elicitation_response":     { direction: "c2s", handler: "lib/project-sessions.js", description: "User response to an elicitation form" },
   "elicitation_resolved":     { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Elicitation request resolved" },
+  "user_dialog_request":      { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Host dialog request from assistant (SDK request_user_dialog)" },
+  "user_dialog_response":     { direction: "c2s", handler: "lib/project-sessions.js", description: "User response to a host dialog request" },
+  "user_dialog_resolved":     { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Host dialog request resolved" },
 
   // -----------------------------------------------------------------------
   // Stop / control
@@ -157,6 +164,8 @@ var schema = {
   "set_server_default_model": { direction: "c2s", handler: "lib/project-sessions.js", description: "Set the server-wide default model" },
   "set_project_default_model": { direction: "c2s", handler: "lib/project-sessions.js", description: "Set the project default model" },
   "set_permission_mode":      { direction: "c2s", handler: "lib/project-sessions.js", description: "Set permission mode for the current session" },
+  "reload_skills":            { direction: "c2s", handler: "lib/project-sessions.js", description: "Hot-reload skills/MCP/agents on the active query without a restart" },
+  "set_mcp_permission_mode_override": { direction: "c2s", handler: "lib/project-sessions.js", description: "Override permission mode (default/auto/null) for one MCP server" },
   "set_server_default_mode":  { direction: "c2s", handler: "lib/project-sessions.js", description: "Set the server-wide default permission mode" },
   "set_project_default_mode": { direction: "c2s", handler: "lib/project-sessions.js", description: "Set the project default permission mode" },
   "set_effort":               { direction: "c2s", handler: "lib/project-sessions.js", description: "Set effort level for the current session" },

package/lib/yoke/adapters/claude-worker.js

@@ -99,6 +99,7 @@ var abortController = null;
 var pendingPermissions = {};  // requestId -> resolve
 var pendingAskUser = {};      // toolUseId -> resolve
 var pendingElicitations = {}; // requestId -> resolve
+var pendingUserDialogs = {};  // requestId -> resolve
 var pendingMcpToolCalls = {}; // requestId -> { resolve, reject }
 var conn = null;
 var buffer = "";
@@ -271,6 +272,12 @@ function handleMessage(msg) {
     case "stop_task":
       handleStopTask(msg);
       break;
+    case "reload_skills":
+      handleReloadSkills(msg);
+      break;
+    case "set_mcp_permission_mode_override":
+      handleSetMcpPermissionModeOverride(msg);
+      break;
     case "rewind_files":
       handleRewindFiles(msg);
       break;
@@ -283,6 +290,9 @@ function handleMessage(msg) {
     case "elicitation_response":
       handleElicitationResponse(msg);
       break;
+    case "user_dialog_response":
+      handleUserDialogResponse(msg);
+      break;
     case "mcp_tool_result":
       handleMcpToolResult(msg);
       break;
@@ -343,6 +353,27 @@ function onElicitation(request, opts) {
   });
 }
 
+// --- onUserDialog: delegates to daemon via IPC ---
+function onUserDialog(request, opts) {
+  var requestId = crypto.randomUUID();
+  sendToDaemon({
+    type: "user_dialog_request",
+    requestId: requestId,
+    dialogKind: request.dialogKind,
+    payload: request.payload || {},
+    toolUseId: request.toolUseID || null,
+  });
+  return new Promise(function(resolve) {
+    pendingUserDialogs[requestId] = resolve;
+    if (opts.signal) {
+      opts.signal.addEventListener("abort", function() {
+        delete pendingUserDialogs[requestId];
+        resolve({ behavior: "cancelled" });
+      });
+    }
+  });
+}
+
 function handlePermissionResponse(msg) {
   var resolve = pendingPermissions[msg.requestId];
   if (resolve) {
@@ -367,6 +398,14 @@ function handleElicitationResponse(msg) {
   }
 }
 
+function handleUserDialogResponse(msg) {
+  var resolve = pendingUserDialogs[msg.requestId];
+  if (resolve) {
+    delete pendingUserDialogs[msg.requestId];
+    resolve(msg.result);
+  }
+}
+
 function handleMcpToolResult(msg) {
   var pending = pendingMcpToolCalls[msg.requestId];
   if (!pending) return;
@@ -477,6 +516,11 @@ async function handleQueryStart(msg) {
   options.onElicitation = function(request, elicitOpts) {
     return onElicitation(request, elicitOpts);
   };
+  // supportedDialogKinds arrives serialized via msg.options (already on `options`);
+  // the callback is non-serializable so we wire it here.
+  options.onUserDialog = function(request, dialogOpts) {
+    return onUserDialog(request, dialogOpts);
+  };
 
   perf("creating query instance");
   try {
@@ -630,6 +674,24 @@ async function handleStopTask(msg) {
   }
 }
 
+async function handleReloadSkills(msg) {
+  if (!queryInstance || typeof queryInstance.reloadSkills !== "function") return;
+  try {
+    await queryInstance.reloadSkills();
+  } catch (e) {
+    console.error("[sdk-worker] reloadSkills error:", e.message);
+  }
+}
+
+async function handleSetMcpPermissionModeOverride(msg) {
+  if (!queryInstance || typeof queryInstance.setMcpPermissionModeOverride !== "function") return;
+  try {
+    await queryInstance.setMcpPermissionModeOverride(msg.serverName, msg.mode);
+  } catch (e) {
+    console.error("[sdk-worker] setMcpPermissionModeOverride error:", e.message);
+  }
+}
+
 // --- Warmup ---
 async function handleWarmup(msg) {
   var sdk;

package/lib/yoke/adapters/claude.js

@@ -12,6 +12,12 @@ var crypto = require("crypto");
 var { spawn } = require("child_process");
 var { resolveOsUserInfo } = require("../../os-users");
 
+// SDK-specific knowledge stays in the adapter (not the relay): the host dialog
+// kinds this client can render, declared to the SDK when an onUserDialog
+// callback is wired. The CLI fails closed — kinds not listed here are never
+// emitted. Keep in sync with the client's generic user-dialog renderer.
+var SUPPORTED_DIALOG_KINDS = ["refusal_fallback_prompt"];
+
 // --- SDK loading ---
 // Async loader (ESM dynamic import, same pattern as current project.js getSDK)
 var _sdkPromise = null;
@@ -182,6 +188,68 @@ function flattenEvent(raw) {
       base.summary = raw.summary || null;
       return base;
     }
+    // Model refusal: the model declined and the CLI either fell back to
+    // another model or ended the turn. Translate to a vendor-neutral
+    // yokeType so the relay never sees SDK subtype strings.
+    if (raw.subtype === "model_refusal_fallback") {
+      base.yokeType = "model_refusal";
+      base.refusalKind = "fallback";
+      base.originalModel = raw.original_model || null;
+      base.fallbackModel = raw.fallback_model || null;
+      base.direction = raw.direction || null;
+      base.category = raw.api_refusal_category || null;
+      return base;
+    }
+    if (raw.subtype === "model_refusal_no_fallback") {
+      base.yokeType = "model_refusal";
+      base.refusalKind = "no_fallback";
+      base.originalModel = raw.original_model || null;
+      base.category = raw.api_refusal_category || null;
+      base.explanation = raw.api_refusal_explanation || null;
+      base.content = raw.content || null;
+      return base;
+    }
+    // Slash-command list changed mid-session (e.g. skills discovered dynamically).
+    if (raw.subtype === "commands_changed") {
+      base.yokeType = "commands_changed";
+      base.commandNames = Array.isArray(raw.commands)
+        ? raw.commands.map(function(c) { return (c && typeof c === "object") ? c.name : c; }).filter(Boolean)
+        : [];
+      return base;
+    }
+    // The session worker is shutting down (reason is a host-set snake_case code).
+    if (raw.subtype === "worker_shutting_down") {
+      base.yokeType = "worker_shutting_down";
+      base.reason = raw.reason || "";
+      return base;
+    }
+    // Live thinking-token estimate (ephemeral progress).
+    if (raw.subtype === "thinking_tokens") {
+      base.yokeType = "thinking_tokens";
+      base.estimatedTokens = raw.estimated_tokens || 0;
+      base.estimatedTokensDelta = raw.estimated_tokens_delta || 0;
+      return base;
+    }
+    // Informational system message (render-leveled: info/notice/suggestion/warning).
+    if (raw.subtype === "informational") {
+      base.yokeType = "informational";
+      base.level = raw.level || "info";
+      base.content = raw.content || "";
+      base.toolUseId = raw.tool_use_id || null;
+      base.preventContinuation = !!raw.prevent_continuation;
+      return base;
+    }
+    // A tool call was denied (by classifier, rule, mode, or async agent).
+    if (raw.subtype === "permission_denied") {
+      base.yokeType = "permission_denied";
+      base.toolName = raw.tool_name || "";
+      base.toolUseId = raw.tool_use_id || null;
+      base.agentId = raw.agent_id || null;
+      base.reasonType = raw.decision_reason_type || null;
+      base.reason = raw.decision_reason || null;
+      base.message = raw.message || "";
+      return base;
+    }
     // Catch-all system event
     base.yokeType = "system";
     base.subtype = raw.subtype;
@@ -338,6 +406,20 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
       return Promise.resolve();
     },
 
+    reloadSkills: function() {
+      if (rawQuery && typeof rawQuery.reloadSkills === "function") {
+        return rawQuery.reloadSkills();
+      }
+      return Promise.resolve(null);
+    },
+
+    setMcpPermissionModeOverride: function(serverName, mode) {
+      if (rawQuery && typeof rawQuery.setMcpPermissionModeOverride === "function") {
+        return rawQuery.setMcpPermissionModeOverride(serverName, mode);
+      }
+      return Promise.resolve(null);
+    },
+
     getContextUsage: function() {
       if (rawQuery && typeof rawQuery.getContextUsage === "function") {
         return rawQuery.getContextUsage();
@@ -684,7 +766,7 @@ function serializeWorkerValue(value, seen) {
 // in-process QueryHandle. This allows processQueryStream to iterate a worker
 // query identically to an in-process query.
 
-function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool) {
+function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool, onUserDialog) {
   // Async iterable state
   var iterQueue = [];
   var iterWaiting = null;
@@ -782,6 +864,24 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool)
         }
         break;
 
+      case "user_dialog_request":
+        if (onUserDialog) {
+          onUserDialog({
+            dialogKind: msg.dialogKind,
+            payload: msg.payload || {},
+            toolUseID: msg.toolUseId || undefined,
+          }, {
+            signal: { addEventListener: function() {} },
+          }).then(function(result) {
+            worker.send({ type: "user_dialog_response", requestId: msg.requestId, result: result });
+          }).catch(function(e) {
+            console.error("[yoke/claude] user_dialog_response send failed:", e.message || e);
+          });
+        } else {
+          worker.send({ type: "user_dialog_response", requestId: msg.requestId, result: { behavior: "cancelled" } });
+        }
+        break;
+
       case "mcp_tool_call":
         if (callMcpTool) {
           callMcpTool(msg.serverName, msg.toolName, msg.args || {}).then(function(result) {
@@ -919,6 +1019,16 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool)
       return Promise.resolve();
     },
 
+    reloadSkills: function() {
+      worker.send({ type: "reload_skills" });
+      return Promise.resolve(null);
+    },
+
+    setMcpPermissionModeOverride: function(serverName, mode) {
+      worker.send({ type: "set_mcp_permission_mode_override", serverName: serverName, mode: mode });
+      return Promise.resolve(null);
+    },
+
     getContextUsage: function() {
       return Promise.resolve(null);
     },
@@ -1218,6 +1328,10 @@ function createClaudeAdapter(opts) {
       if (queryOpts.toolServers) sdkOptions.mcpServers = queryOpts.toolServers;
       if (queryOpts.canUseTool) sdkOptions.canUseTool = queryOpts.canUseTool;
       if (queryOpts.onElicitation) sdkOptions.onElicitation = queryOpts.onElicitation;
+      if (queryOpts.onUserDialog) {
+        sdkOptions.onUserDialog = queryOpts.onUserDialog;
+        sdkOptions.supportedDialogKinds = SUPPORTED_DIALOG_KINDS;
+      }
       if (queryOpts.resumeSessionId) sdkOptions.resume = queryOpts.resumeSessionId;
 
       // Claude-specific options from adapterOptions.CLAUDE
@@ -1366,7 +1480,7 @@ function createClaudeAdapter(opts) {
     }
 
     // Create the worker query handle (sets up message handler on worker)
-    var handle = createWorkerQueryHandle(worker, queryOpts.canUseTool, queryOpts.onElicitation, queryOpts.callMcpTool);
+    var handle = createWorkerQueryHandle(worker, queryOpts.canUseTool, queryOpts.onElicitation, queryOpts.callMcpTool, queryOpts.onUserDialog);
 
     // Wait for worker to be ready before sending query_start
     if (!reusingWorker) {
@@ -1393,6 +1507,7 @@ function createClaudeAdapter(opts) {
     if (claudeOpts.settings) queryOptions.settings = claudeOpts.settings;
 
     if (queryOpts.toolServerDescriptors) queryOptions.mcpServerDescriptors = queryOpts.toolServerDescriptors;
+    if (queryOpts.onUserDialog) queryOptions.supportedDialogKinds = SUPPORTED_DIALOG_KINDS;
     if (queryOpts.model) queryOptions.model = queryOpts.model;
     if (queryOpts.effort) queryOptions.effort = queryOpts.effort;
     if (queryOpts.resumeSessionId) queryOptions.resume = queryOpts.resumeSessionId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "2.44.1-beta.2",
+  "version": "2.45.0-beta.1",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js",
@@ -48,7 +48,7 @@
   "homepage": "https://github.com/chadbyte/clay#readme",
   "author": "Chad",
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.132",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.196",
     "@lydell/node-pty": "^1.2.0-beta.3",
     "@openai/codex": "^0.124.0",
     "imapflow": "^1.3.1",