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

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/server.js

@@ -153,6 +153,7 @@ function createServer(opts) {
   var onGetDaemonConfig = opts.onGetDaemonConfig || null;
   var onSetPin = opts.onSetPin || null;
   var onSetKeepAwake = opts.onSetKeepAwake || null;
+  var onSetInheritGroups = opts.onSetInheritGroups || null;
   var onSetImageRetention = opts.onSetImageRetention || null;
   var onShutdown = opts.onShutdown || null;
   var onRestart = opts.onRestart || null;
@@ -1257,6 +1258,7 @@ function createServer(opts) {
       onGetDaemonConfig: onGetDaemonConfig,
       onSetPin: onSetPin,
       onSetKeepAwake: onSetKeepAwake,
+      onSetInheritGroups: onSetInheritGroups,
       onSetImageRetention: onSetImageRetention,
       onSetUpdateChannel: onSetUpdateChannel,
       updateChannel: onGetDaemonConfig ? (onGetDaemonConfig().updateChannel || "stable") : "stable",

package/lib/terminal.js

@@ -39,7 +39,10 @@ function createTerminal(cwd, cols, rows, osUserInfo, opts) {
   }
 
   var args = osUserInfo ? ["-l"] : [];
-  var term = pty.spawn(shell, args, spawnOpts);
+  // Route through setpriv when group inheritance is enabled so the terminal
+  // gets the user's supplementary groups (docker, etc.), not just primary gid.
+  var ptySpawn = require("./os-users").wrapSpawnAsUser(shell, args, spawnOpts);
+  var term = pty.spawn(ptySpawn.command, ptySpawn.args, ptySpawn.options);
 
   if (opts && opts.initialInput) {
     try { term.write(opts.initialInput); } catch (e) {}

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;