clay-server 4.1.0 → 4.2.0-beta.2

package/lib/daemon-project-access.js

@@ -41,6 +41,7 @@ function getProjectAccess(config, slug, osUsers) {
       visibility: visibility,
       allowedUsers: parentAllowedUsers,
       ownerId: project.ownerId || null,
+      sessionVisibilityDefault: project.sessionVisibilityDefault === "shared" ? "shared" : "private",
       isWorktree: false,
     };
   }
@@ -52,6 +53,7 @@ function getProjectAccess(config, slug, osUsers) {
     visibility: visibility,
     allowedUsers: uniqueUsers(parentAllowedUsers.concat(worktreeAllowedUsers)),
     ownerId: project.ownerId || null,
+    sessionVisibilityDefault: project.sessionVisibilityDefault === "shared" ? "shared" : "private",
     isWorktree: true,
     parentSlug: parentSlug,
     parentAllowedUsers: parentAllowedUsers,
@@ -61,6 +63,7 @@ function getProjectAccess(config, slug, osUsers) {
       visibility: visibility,
       allowedUsers: parentAllowedUsers,
       ownerId: project.ownerId || null,
+      sessionVisibilityDefault: project.sessionVisibilityDefault === "shared" ? "shared" : "private",
     },
   };
 }
@@ -84,6 +87,16 @@ function setAllowedUsers(config, slug, allowedUsers) {
   return { ok: true, isWorktree: true, allowedUsers: clean };
 }
 
+function setSessionVisibilityDefault(config, slug, visibility) {
+  if (visibility !== "private" && visibility !== "shared") return { error: "Invalid session visibility default" };
+  if (parentSlugFor(slug)) return { error: "Worktrees inherit this setting from their parent project." };
+  var project = findProject(config, slug);
+  if (!project) return { error: "Project not found" };
+  if (visibility === "shared") project.sessionVisibilityDefault = "shared";
+  else delete project.sessionVisibilityDefault;
+  return { ok: true, visibility: visibility };
+}
+
 function clearWorktreeGrant(config, slug) {
   var parentSlug = parentSlugFor(slug);
   var project = parentSlug ? findProject(config, parentSlug) : null;
@@ -113,6 +126,7 @@ module.exports = {
   parentSlugFor: parentSlugFor,
   getProjectAccess: getProjectAccess,
   setAllowedUsers: setAllowedUsers,
+  setSessionVisibilityDefault: setSessionVisibilityDefault,
   clearWorktreeGrant: clearWorktreeGrant,
   reconcileWorktreeGrants: reconcileWorktreeGrants,
 };

package/lib/daemon.js

@@ -556,6 +556,13 @@ var relay = createServer({
     });
     return { ok: true };
   },
+  onSetProjectSessionVisibilityDefault: function (slug, visibility) {
+    var result = daemonProjectAccess.setSessionVisibilityDefault(config, slug, visibility);
+    if (result.error) return { ok: false, error: result.error };
+    saveConfig(config);
+    relay.broadcastAll({ type: "projects_updated", projects: relay.getProjects(), projectCount: config.projects.length });
+    return result;
+  },
   onProjectOwnerChanged: function (slug, ownerId) {
     console.log("[daemon] onProjectOwnerChanged:", slug, "→", ownerId);
     var oldOwnerId = null;

package/lib/project-connection.js

@@ -5,6 +5,7 @@ var userPresence = require("./user-presence");
 var emailAccounts = require("./email-accounts");
 var { getCodexConfig } = require("./codex-defaults");
 var yoke = require("./yoke");
+var permissionModes = require("./session-permission-mode");
 
 function dispatchMessageSafely(handleMessage, sendTo, slug, ws, msg) {
   try {
@@ -195,7 +196,8 @@ function attachConnection(ctx) {
     // model. Always send it so reconnects cannot fall back to "Not installed."
     var initialModelInfo = buildInitialModelInfo(sm, initialVendor, initialModel, initialModels, restoredActive ? restoredActive.localId : null);
     sendTo(ws, initialModelInfo);
-    sendTo(ws, { type: "config_state", model: initialModelInfo.model, vendor: initialVendor, sessionId: restoredActive ? restoredActive.localId : null, mode: sm.currentPermissionMode || "default", effort: initialEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+    var initialPermissionState = permissionModes.clientState(restoredActive, sm.currentPermissionMode, sm.defaultVendor);
+    sendTo(ws, { type: "config_state", model: initialModelInfo.model, vendor: initialVendor, sessionId: restoredActive ? restoredActive.localId : null, mode: initialPermissionState.requestedPermissionMode, effectivePermissionMode: initialPermissionState.effectivePermissionMode, permissionCapabilities: initialPermissionState.permissionCapabilities, mcpPermissionModeOverrides: initialPermissionState.mcpPermissionModeOverrides, effort: initialEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
     sendTo(ws, { type: "last_vendor", vendor: sm.lastVendor || "" });
     sendTo(ws, Object.assign({ type: "codex_config" }, getCodexConfig(sm)));
     sendTo(ws, { type: "term_list", terminals: tm.list() });
@@ -270,7 +272,8 @@ function attachConnection(ctx) {
         try { resolveSessionForView(active, ws); } catch (e) {}
       }
       var _vendorCaps = (sm.capabilitiesByVendor && sm.capabilitiesByVendor[active.vendor || sm.defaultVendor || "claude"]) || {};
-      sendTo(ws, { type: "session_switched", id: active.localId, cliSessionId: active.cliSessionId || null, loop: active.loop || null, vendor: active.vendor || null, model: active.model || null, effort: active.effort || initialEffort || null, hasHistory: (active.history && active.history.length > 0), capabilities: _vendorCaps, mode: active.mode || "gui", terminalId: typeof active.terminalId === "number" ? active.terminalId : null, runtimeMode: active.runtimeMode || null, runtimeTerminalId: typeof active.runtimeTerminalId === "number" ? active.runtimeTerminalId : null, tuiSuspended: !!active.tuiSuspended, permissionMode: active.permissionMode || null });
+      var activePermissionState = permissionModes.clientState(active, sm.currentPermissionMode, sm.defaultVendor);
+      sendTo(ws, { type: "session_switched", id: active.localId, cliSessionId: active.cliSessionId || null, loop: active.loop || null, vendor: active.vendor || null, model: active.model || null, effort: active.effort || initialEffort || null, hasHistory: (active.history && active.history.length > 0), capabilities: _vendorCaps, mode: active.mode || "gui", terminalId: typeof active.terminalId === "number" ? active.terminalId : null, runtimeMode: active.runtimeMode || null, runtimeTerminalId: typeof active.runtimeTerminalId === "number" ? active.runtimeTerminalId : null, tuiSuspended: !!active.tuiSuspended, permissionMode: activePermissionState.requestedPermissionMode, effectivePermissionMode: activePermissionState.effectivePermissionMode, permissionCapabilities: activePermissionState.permissionCapabilities, mcpPermissionModeOverrides: activePermissionState.mcpPermissionModeOverrides });
       if (ctx.autonomousRun) sendTo(ws, { type: "autonomous_run_state", sessionId: active.localId, run: ctx.autonomousRun.project(active.autonomousRun) });
       // Send per-session context sources
       var sessionSources = loadContextSources(slug, active.localId);

package/lib/project-full-access.js

@@ -1,86 +1,99 @@
-// Shared, transactional control for Clay-managed per-session Skip Permissions.
+// Serialized, transactional owner for every per-session permission selection.
+// Skip is Clay-managed and deliberately maps the SDK to default.
 
 function createFullAccessService(ctx) {
   var sm = ctx.sm;
   var transitions = new Map();
-
   function serialize(session, action) {
     var prior = transitions.get(session.localId) || Promise.resolve();
     var next = prior.catch(function () {}).then(action);
     transitions.set(session.localId, next);
-    return next.finally(function () {
-      if (transitions.get(session.localId) === next) transitions.delete(session.localId);
-    });
+    return next.finally(function () { if (transitions.get(session.localId) === next) transitions.delete(session.localId); });
   }
-
   function snapshot(session) {
-    return {
-      permissionMode: session.permissionMode || null,
-      permissionModeBeforeFullAccess: session.permissionModeBeforeFullAccess || null,
-      enabled: session.permissionMode === "bypassPermissions",
-    };
+    return { permissionMode: session.permissionMode || null, permissionModeBeforeFullAccess: session.permissionModeBeforeFullAccess || null,
+      effectivePermissionMode: session.effectivePermissionMode || null, permissionModeFallbackReason: session.permissionModeFallbackReason || null,
+      enabled: session.permissionMode === "bypassPermissions" };
   }
-
-  function notify(session) {
+  function persist(session) {
+    sm.saveSessionFile(session);
+    sm.broadcastSessionList();
     if (typeof sm.sendToSession === "function") sm.sendToSession(session, { type: "session_full_access_changed", id: session.localId,
       enabled: session.permissionMode === "bypassPermissions", permissionMode: session.permissionMode });
   }
-
-  async function applyNativeMode(session, enabled) {
+  async function setNative(session, mode) {
     if (!session.queryInstance || typeof session.queryInstance.setPermissionMode !== "function") return;
-    // Clay's common permission callback remains the approval authority.
-    await session.queryInstance.setPermissionMode(enabled ? "default" : session.permissionMode);
+    await session.queryInstance.setPermissionMode(mode === "bypassPermissions" ? "default" : mode);
   }
-
-  async function applyEnabled(session, enabled) {
+  async function applyMode(session, mode) {
     var previous = snapshot(session);
-    if (previous.enabled === !!enabled) return previous;
-    if (enabled) {
-      session.permissionModeBeforeFullAccess = session.permissionMode || sm.currentPermissionMode || "default";
-      session.permissionMode = "bypassPermissions";
-    } else {
-      session.permissionMode = session.permissionModeBeforeFullAccess || "default";
-      session.permissionModeBeforeFullAccess = null;
-    }
+    if (previous.permissionMode === mode) return previous;
+    // Clear stale confirmation before the setter. An init/status event may
+    // arrive while it is pending; do not clear that newer observation later.
+    session.effectivePermissionMode = null;
+    session.permissionModeFallbackReason = null;
     try {
-      await applyNativeMode(session, !!enabled);
-      sm.saveSessionFile(session);
-      sm.broadcastSessionList();
-      notify(session);
-      return previous;
+      await setNative(session, mode);
     } catch (error) {
+      session.effectivePermissionMode = previous.effectivePermissionMode;
+      session.permissionModeFallbackReason = previous.permissionModeFallbackReason;
+      throw error;
+    }
+    session.permissionMode = mode;
+    session.permissionModeBeforeFullAccess = mode === "bypassPermissions" ? (previous.permissionMode || sm.currentPermissionMode || "default") : null;
+    try { persist(session); return previous; }
+    catch (error) {
       session.permissionMode = previous.permissionMode;
       session.permissionModeBeforeFullAccess = previous.permissionModeBeforeFullAccess;
+      session.effectivePermissionMode = previous.effectivePermissionMode;
+      session.permissionModeFallbackReason = previous.permissionModeFallbackReason;
+      try { await setNative(session, previous.permissionMode || "default"); }
+      catch (rollbackError) {
+        session.effectivePermissionMode = null;
+        session.permissionModeFallbackReason = "Permission rollback failed: " + (rollbackError.message || rollbackError);
+      }
       throw error;
     }
   }
-
+  function setMode(session, mode) { return serialize(session, function () { return applyMode(session, mode); }); }
   function setEnabled(session, enabled) {
-    return serialize(session, function () { return applyEnabled(session, enabled); });
-  }
-
-  async function applyRestore(session, prior) {
-    if (!prior) return;
-    var current = snapshot(session);
-    session.permissionMode = prior.permissionMode;
-    session.permissionModeBeforeFullAccess = prior.permissionModeBeforeFullAccess;
-    try {
-      await applyNativeMode(session, prior.enabled);
-      sm.saveSessionFile(session);
-      sm.broadcastSessionList();
-      notify(session);
-    } catch (error) {
-      session.permissionMode = current.permissionMode;
-      session.permissionModeBeforeFullAccess = current.permissionModeBeforeFullAccess;
-      throw error;
-    }
+    return serialize(session, function () {
+      return applyMode(session, enabled ? "bypassPermissions" : (session.permissionModeBeforeFullAccess || "default"));
+    });
   }
-
   function restore(session, prior) {
-    return serialize(session, function () { return applyRestore(session, prior); });
+    if (!prior) return Promise.resolve();
+    return serialize(session, async function () {
+      var current = snapshot(session);
+      // Runtime-effective state is an observation, not part of the selection
+      // snapshot. Clear it before the native setter and preserve any newer
+      // init/status event that arrives while the acknowledgement is pending.
+      session.effectivePermissionMode = null;
+      session.permissionModeFallbackReason = null;
+      try {
+        await setNative(session, prior.permissionMode || "default");
+      } catch (error) {
+        session.effectivePermissionMode = current.effectivePermissionMode;
+        session.permissionModeFallbackReason = current.permissionModeFallbackReason;
+        throw error;
+      }
+      session.permissionMode = prior.permissionMode;
+      session.permissionModeBeforeFullAccess = prior.permissionModeBeforeFullAccess;
+      try { persist(session); }
+      catch (error) {
+        session.permissionMode = current.permissionMode;
+        session.permissionModeBeforeFullAccess = current.permissionModeBeforeFullAccess;
+        session.effectivePermissionMode = null;
+        session.permissionModeFallbackReason = null;
+        try { await setNative(session, current.permissionMode || "default"); }
+        catch (rollbackError) {
+          session.effectivePermissionMode = null;
+          session.permissionModeFallbackReason = "Permission rollback failed: " + (rollbackError.message || rollbackError);
+        }
+        throw error;
+      }
+    });
   }
-
-  return { restore: restore, setEnabled: setEnabled, snapshot: snapshot };
+  return { restore: restore, setEnabled: setEnabled, setMode: setMode, snapshot: snapshot };
 }
-
 module.exports = { createFullAccessService: createFullAccessService };

package/lib/project-issue-launch.js

@@ -2,6 +2,7 @@
 
 var yoke = require("./yoke");
 var provenance = require("./session-provenance");
+var sessionVisibility = require("./session-visibility");
 
 function attachIssueLaunch(ctx) {
   var requests = new Map();
@@ -79,8 +80,9 @@ function attachIssueLaunch(ctx) {
     var liveLinuxUser = typeof ctx.getLinuxUserForSession === "function" ? ctx.getLinuxUserForSession({ ownerId: actorId }) : null;
     if (osUsersEnabled() && liveLinuxUser !== expectedLinuxUser) throw new Error("The OS identity changed while issue work was being prepared.");
 
+    var projectAccess = typeof ctx.getProjectAccess === "function" ? ctx.getProjectAccess() : null;
     var session = ctx.sm.createSessionRaw({ vendor: runtime.vendor, model: runtime.model, effort: runtime.effort || null,
-      mode: "gui", ownerId: actor && actor.id || null, sessionVisibility: "private" });
+      mode: "gui", ownerId: actor && actor.id || null, sessionVisibility: sessionVisibility.defaultForProject(projectAccess) });
     provenance.ensureOrigin(session);
     if (session.hidden === true || session.delegated === true || provenance.isWorker(session)) {
       ctx.sm.deleteSession(session.localId);

package/lib/project-sessions.js

@@ -88,6 +88,7 @@ function attachSessions(ctx) {
   var slug = ctx.slug;
   var isMate = ctx.isMate;
   var osUsers = ctx.osUsers;
+  var dangerouslySkipPermissions = ctx.dangerouslySkipPermissions === true;
   var currentVersion = ctx.currentVersion;
   var sm = ctx.sm;
   var sdk = ctx.sdk;
@@ -98,6 +99,7 @@ function attachSessions(ctx) {
   var sendToAdmins = ctx.sendToAdmins;
   var broadcastUpdateAvailable = ctx.broadcastUpdateAvailable || function () {};
   var broadcastUpdateStarted = ctx.broadcastUpdateStarted || function () {};
+  var isDriverOperatedSession = ctx.isDriverOperatedSession || function () { return false; };
   var sendToUpdateUser = ctx.sendToUpdateUser || function () {};
   var sendToSession = ctx.sendToSession;
   var sendToSessionOthers = ctx.sendToSessionOthers;
@@ -555,7 +557,7 @@ function attachSessions(ctx) {
     }
     sm.sweepBlankSessions();
     var sessionOpts = {
-      sessionVisibility: sessionVisibility.normalize(msg.sessionVisibility),
+      sessionVisibility: "private",
       vendor: prepared.runtime.vendor,
       model: prepared.runtime.model,
       effort: prepared.runtime.effort || null,
@@ -619,7 +621,15 @@ function attachSessions(ctx) {
       sm.sweepBlankSessions();
       var sessionOpts = {};
       if (ws._clayUser && usersModule.isMultiUser()) sessionOpts.ownerId = ws._clayUser.id;
-      sessionOpts.sessionVisibility = sessionVisibility.normalize(msg.sessionVisibility);
+      // Only ordinary project conversations may opt into this setting.
+      // Scheduled interviews and background/worker creation paths remain explicit.
+      var visibilityChoice = sessionVisibility.resolveNewSessionVisibility(getProjectAccess(), msg, isMate);
+      if (visibilityChoice.error) {
+        scheduledRequestError(ws, msg, visibilityChoice.error);
+        if (!msg.requestId) sendTo(ws, { type: "error", text: visibilityChoice.error });
+        return true;
+      }
+      sessionOpts.sessionVisibility = visibilityChoice.visibility;
       if (msg.vendor) sessionOpts.vendor = msg.vendor;
       // Mode resolution: vendors without a TUI session mode are always GUI.
       // TUI-capable sessions honor the explicit msg.mode if provided, otherwise
@@ -701,8 +711,7 @@ function attachSessions(ctx) {
         if (reusable) {
           if (sessionOpts.vendor && reusable.vendor !== sessionOpts.vendor) reusable.vendor = sessionOpts.vendor;
           if (!reusable.effort) reusable.effort = sessionOpts.effort;
-          sm.setSessionVisibility(reusable.localId, sessionOpts.sessionVisibility);
-          sessionVisibility.revokeViewers(ctx, reusable);
+          // Reusable blanks already exist; do not retroactively change them.
           sm.switchSession(reusable.localId, ws);
           newSess = reusable;
         } else {
@@ -735,6 +744,14 @@ function attachSessions(ctx) {
       return true;
     }
 
+    if (msg.type === "set_project_session_visibility_default") {
+      sessionVisibility.handleDefaultChange({
+        slug: slug, isMate: isMate, osUsers: osUsers, usersModule: usersModule, getProjectAccess: getProjectAccess,
+        opts: opts, sendTo: sendTo,
+      }, ws, msg);
+      return true;
+    }
+
     if (msg.type === "set_session_bookmark") {
       if (typeof msg.sessionId === "number") {
         var bookmarkTarget = sm.sessions.get(msg.sessionId);
@@ -1166,13 +1183,62 @@ function attachSessions(ctx) {
       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);
+    if (msg.type === "set_mcp_permission_mode_override") {
+      var mcpRequestId = typeof msg.requestId === "string" && msg.requestId.length <= 128 ? msg.requestId : null;
+      var mcpProjectSlug = typeof msg.projectSlug === "string" && msg.projectSlug.length <= 256 ? msg.projectSlug : null;
+      var mcpSessionId = Number(msg.sessionId);
+      var mcpServerName = typeof msg.serverName === "string" && msg.serverName.length > 0 && msg.serverName.length <= 256 ? msg.serverName : null;
+      var mcpSession = Number.isSafeInteger(mcpSessionId) ? sm.sessions.get(mcpSessionId) : null;
+      function mcpPermissionResult(ok, error, overrides) {
+        sendTo(ws, {
+          type: "mcp_permission_mode_result",
+          ok: ok === true,
+          requestId: mcpRequestId,
+          projectSlug: mcpProjectSlug,
+          sessionId: Number.isSafeInteger(mcpSessionId) ? mcpSessionId : null,
+          serverName: mcpServerName,
+          mode: ok ? mcpMode : null,
+          mcpPermissionModeOverrides: ok ? overrides || {} : {},
+          error: error || null,
+        });
+      }
+      var mcpMode = msg.mode === "auto" || msg.mode === "default" ? msg.mode : null;
+      var mcpModeValid = msg.mode == null || msg.mode === "" || msg.mode === "auto" || msg.mode === "default";
+      if (mcpProjectSlug !== slug) {
+        mcpPermissionResult(false, "The AI review request belongs to a different project.");
+        return true;
+      }
+      if (!mcpServerName || !mcpModeValid) {
+        mcpPermissionResult(false, "The AI review request is invalid.");
+        return true;
       }
+      var mcpRuntimeMode = mcpSession && (mcpSession.runtimeMode || mcpSession.mode || "gui");
+      if (!mcpSession || !ownsSearchSession(ws, mcpSession) || mcpRuntimeMode !== "gui" || isDriverOperatedSession(mcpSession)) {
+        mcpPermissionResult(false, "AI review controls are only available on an accessible Driver GUI session.");
+        return true;
+      }
+      var mcpApplicable = (mcpSession.effectivePermissionMode === "auto" || mcpSession.effectivePermissionMode === "bypassPermissions") &&
+        mcpSession.permissionCapabilities && mcpSession.permissionCapabilities.mcpOverride === true && typeof sdk.setMcpPermissionModeOverride === "function";
+      if (!mcpApplicable) {
+        mcpPermissionResult(false, "AI review controls are not available for this session.");
+        return true;
+      }
+      (async function () {
+        try {
+          var result = await sdk.setMcpPermissionModeOverride(mcpSession, mcpServerName, mcpMode);
+          if (!result || result.ok === false) {
+            mcpPermissionResult(false, result && result.error || "Failed to change AI review policy.");
+            return;
+          }
+          mcpSession.mcpPermissionModeOverrides = mcpSession.mcpPermissionModeOverrides || {};
+          if (mcpMode) mcpSession.mcpPermissionModeOverrides[mcpServerName] = mcpMode;
+          else delete mcpSession.mcpPermissionModeOverrides[mcpServerName];
+          if (typeof sm.saveSessionFile === "function") sm.saveSessionFile(mcpSession);
+          mcpPermissionResult(true, null, mcpSession.mcpPermissionModeOverrides);
+        } catch (error) {
+          mcpPermissionResult(false, "Failed to change AI review policy: " + (error.message || error));
+        }
+      })();
       return true;
     }
 
@@ -1189,6 +1255,10 @@ function attachSessions(ctx) {
             " is bound to '" + vendorSession.vendor + "', refused rebind to '" + msg.vendor + "'");
         } else {
           vendorSession.vendor = msg.vendor;
+          if (vendorSession.permissionMode === "auto" && msg.vendor !== "claude") {
+            vendorSession.permissionMode = "default";
+            vendorSession.effectivePermissionMode = null;
+          }
           if (vendorSession.vendor !== msg.vendor) vendorSession.model = "";
           sm.saveSessionFile(vendorSession);
           sm.broadcastSessionList();
@@ -1231,16 +1301,62 @@ function attachSessions(ctx) {
       return true;
     }
 
-    if (msg.type === "set_permission_mode" && msg.mode) {
-      sm.currentPermissionMode = msg.mode;
-      var session = getSessionForWs(ws);
-      if (session) {
-        session.permissionMode = msg.mode;
-        sm.saveSessionFile(session);
-        sm.broadcastSessionList();
-        sdk.setPermissionMode(session, msg.mode);
+    if (msg.type === "set_permission_mode") {
+      var permissionModes = require("./session-permission-mode");
+      var requestId = typeof msg.requestId === "string" && msg.requestId.length <= 128 ? msg.requestId : null;
+      var requestedProjectSlug = typeof msg.projectSlug === "string" && msg.projectSlug.length <= 256 ? msg.projectSlug : null;
+      var requestedSessionId = Number(msg.sessionId);
+      var session = Number.isSafeInteger(requestedSessionId) ? sm.sessions.get(requestedSessionId) : null;
+      function permissionResult(ok, error, includeState) {
+        var state = includeState && session ? permissionModes.clientState(session, sm.currentPermissionMode, sm.defaultVendor) : null;
+        sendTo(ws, {
+          type: "permission_mode_result",
+          ok: ok === true,
+          requestId: requestId,
+          projectSlug: requestedProjectSlug,
+          sessionId: Number.isSafeInteger(requestedSessionId) ? requestedSessionId : null,
+          mode: state ? state.requestedPermissionMode : null,
+          effectivePermissionMode: state ? state.effectivePermissionMode : null,
+          permissionCapabilities: state ? state.permissionCapabilities : null,
+          mcpPermissionModeOverrides: state ? state.mcpPermissionModeOverrides : {},
+          error: error || null,
+        });
       }
-      send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      if (requestedProjectSlug !== slug) {
+        permissionResult(false, "The permission request belongs to a different project.", false);
+        return true;
+      }
+      if (!session || !ownsSearchSession(ws, session) || isDriverOperatedSession(session)) {
+        permissionResult(false, "Permissions can only be changed on an accessible Driver session.", false);
+        return true;
+      }
+      var permissionRuntimeMode = session.runtimeMode || session.mode || "gui";
+      if (permissionRuntimeMode !== "gui") {
+        permissionResult(false, "Permissions can only be changed on a GUI session.", true);
+        return true;
+      }
+      if (dangerouslySkipPermissions) {
+        permissionResult(false, "Skip permissions is forced by the server setting.", true);
+        return true;
+      }
+      var valid = permissionModes.validate(session, msg.mode, sm.defaultVendor);
+      if (!valid.ok) { permissionResult(false, valid.error, true); return true; }
+      (async function() {
+        try {
+          if (session.permissionMode === "bypassPermissions" && valid.mode !== "bypassPermissions" && autonomousRun) {
+            await autonomousRun.stopForPermissionChange(session);
+          }
+          await fullAccessService.setMode(session, valid.mode);
+          var state = permissionModes.clientState(session, sm.currentPermissionMode, sm.defaultVendor);
+          sm.sendToSession(session, { type: "config_state", sessionId: session.localId, vendor: session.vendor || sm.defaultVendor || "claude", mode: state.requestedPermissionMode,
+            effectivePermissionMode: state.effectivePermissionMode, permissionRequestId: requestId,
+            permissionCapabilities: state.permissionCapabilities, mcpPermissionModeOverrides: state.mcpPermissionModeOverrides,
+            effort: session.effort || sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+          permissionResult(true, null, true);
+        } catch (error) {
+          permissionResult(false, "Failed to change permission mode: " + (error.message || error), true);
+        }
+      })();
       return true;
     }
 
@@ -1248,12 +1364,12 @@ function attachSessions(ctx) {
       var fullAccessSession = msg.id ? sm.sessions.get(Number(msg.id)) : getSessionForWs(ws);
       var fullAccessEnabled = msg.enabled === true;
       var fullAccessMode = fullAccessSession && (fullAccessSession.runtimeMode || fullAccessSession.mode || "gui");
-      if (!fullAccessSession || fullAccessMode !== "gui") {
+      if (!fullAccessSession || fullAccessMode !== "gui" || isDriverOperatedSession(fullAccessSession)) {
         sendTo(ws, { type: "session_full_access_result", ok: false, id: msg.id || null, error: "Skip Permissions is only available for GUI sessions." });
         return true;
       }
       if (usersModule.isMultiUser() && ws._clayUser &&
-          !usersModule.canAccessSession(ws._clayUser.id, fullAccessSession, { visibility: "public" })) {
+          !usersModule.canAccessSession(ws._clayUser.id, fullAccessSession, getProjectAccess())) {
         sendTo(ws, { type: "session_full_access_result", ok: false, id: fullAccessSession.localId, error: "You do not have access to this session." });
         return true;
       }
@@ -1493,7 +1609,11 @@ function attachSessions(ctx) {
           } else {
             forkHistory = session.history.slice();
           }
-          var forked = sm.createSession({ vendor: session.vendor, ownerId: session.ownerId || null }, ws);
+          var forked = sm.createSession({
+            vendor: session.vendor,
+            ownerId: session.ownerId || null,
+            sessionVisibility: sessionVisibility.normalize(session.sessionVisibility),
+          }, ws);
           forked.cliSessionId = result.sessionId;
           forked.title = forkTitle;
           forked.history = forkHistory;
@@ -1511,7 +1631,14 @@ function attachSessions(ctx) {
           // Read history from CLI session files
           var cliSess = require("./cli-sessions");
           return cliSess.readCliSessionHistory(resolveSessionHome(session), cwd, result.sessionId).then(function(history) {
-            var forked = sm.resumeSession(result.sessionId, { history: history, title: forkTitle }, ws);
+            var forked = sm.resumeSession(result.sessionId, {
+              history: history,
+              title: forkTitle,
+              vendor: session.vendor,
+              ownerId: session.ownerId || null,
+              sessionVisibility: sessionVisibility.normalize(session.sessionVisibility),
+              sessionVisibilityExplicit: session.sessionVisibilityExplicit === true,
+            }, ws);
             if (forked) {
               ws._clayActiveSession = forked.localId;
               sendTo(ws, { type: "fork_complete", sessionId: forked.localId });
@@ -1577,11 +1704,13 @@ function attachSessions(ctx) {
 
       // --- Plan approval: "allow_accept_edits" -- approve + switch to acceptEdits mode ---
       if (decision === "allow_accept_edits") {
-        sdk.setPermissionMode(session, "acceptEdits");
-        sm.currentPermissionMode = "acceptEdits";
-        send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
-        pending.resolve({ behavior: "allow", updatedInput: pending.toolInput });
-        sm.sendAndRecord(session, { type: "permission_resolved", requestId: requestId, decision: decision });
+        fullAccessService.setMode(session, "acceptEdits").then(function() {
+          pending.resolve({ behavior: "allow", updatedInput: pending.toolInput });
+          sm.sendAndRecord(session, { type: "permission_resolved", requestId: requestId, decision: decision });
+        }).catch(function(error) {
+          pending.resolve({ behavior: "deny", message: "Could not enter the accepted-edits workflow." });
+          sendTo(ws, { type: "error", text: "Failed to change permission mode: " + (error.message || error) });
+        });
         return true;
       }
 
@@ -1606,10 +1735,6 @@ function attachSessions(ctx) {
           }
         });
 
-        // Update permission mode for the new session
-        sm.currentPermissionMode = "acceptEdits";
-        send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
-
         // Build prompt from plan content (sent from client) or plan file path
         var clientPlanContent = msg.planContent || "";
         var planPrompt;
@@ -1628,6 +1753,7 @@ function attachSessions(ctx) {
         ]).then(function () {
           try {
             var newSession = sm.createSession(null, ws);
+            newSession.permissionMode = "acceptEdits";
             // 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);

package/lib/project-user-message.js

@@ -122,10 +122,13 @@ function attachUserMessage(ctx) {
   function handleUserMessage(ws, msg, forcedSession, internal) {
     if (msg.type === "pending_message_get" || msg.type === "pending_message_edit" || msg.type === "pending_message_cancel" || msg.type === "pending_message_reorder" || msg.type === "pending_message_resume") {
       var queueSession = forcedSession || getSessionForWs(ws);
-      if (!queueSession || !pendingMessageQueue) return true;
       var queueActor = ws && ws._clayUser;
       var queueResult;
-      if (msg.projectSlug !== slug) queueResult = { ok: false, error: "Project changed", sessionId: queueSession.localId, projectSlug: slug };
+      var requestedQueue = { ok: false, projectSlug: msg.projectSlug || slug, sessionId: msg.sessionId == null ? null : msg.sessionId, revision: 0, paused: false, items: [] };
+      if (!pendingMessageQueue) queueResult = Object.assign({}, requestedQueue, { error: "The message queue is unavailable." });
+      else if (!queueSession) queueResult = Object.assign({}, requestedQueue, { error: "The session is no longer available." });
+      else if (msg.projectSlug !== slug) queueResult = Object.assign({}, requestedQueue, { error: "Project changed" });
+      else if (msg.sessionId == null || String(msg.sessionId) !== String(queueSession.localId)) queueResult = Object.assign({}, requestedQueue, { error: "Session changed" });
       else if (msg.type === "pending_message_resume") {
         queueResult = pendingMessageQueue.resume(queueSession, queueActor, msg.revision, msg.sessionId);
         if (queueResult.ok && !queueResult.paused) {

package/lib/project.js

@@ -794,6 +794,10 @@ function createProjectContext(opts) {
   var _issueWork = require("./project-issue-launch").attachIssueLaunch({
     sm: sm, resolveDefaultAi: opts.resolveDefaultAi, getSdk: function () { return sdk; },
     getLinuxUserForSession: getLinuxUserForSession, osUsers: osUsers,
+    getProjectAccess: function () {
+      if (isMate) return { visibility: "private", ownerId: projectOwnerId || null, allowedUsers: [] };
+      return opts.getProjectAccess ? opts.getProjectAccess() : { visibility: "public", ownerId: projectOwnerId || null };
+    },
     ensureProjectAccessForSession: ensureProjectAccessForSession,
     canStartWork: function (ws, actor) { return clients.has(ws) && ws.readyState === 1 && ws._clayUser === actor; },
     onProcessingChanged: onProcessingChanged, sendTo: sendTo,
@@ -1941,6 +1945,7 @@ function createProjectContext(opts) {
     adapter: adapter,
     fullAccessService: _fullAccess,
     autonomousRun: _autonomousRun,
+    isDriverOperatedSession: function (session) { return !isMate && _sessionPair.workerPermission.isDriverOperated(session); },
     getProjectList: getProjectList,
     getProjectCount: getProjectCount,
     getScheduleCount: getScheduleCount,

package/lib/public/app.js

@@ -333,6 +333,7 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     cursorSharingHydrated: false,
     pendingOutboundMessages: [],
     pendingMessageQueue: { projectSlug: null, sessionId: null, revision: 0, paused: false, items: [], loading: false, error: "" },
+    pendingMessageQueueRecovery: false,
     pendingMessageQueueRequests: {},
     pendingMessageQueueEdit: null,
     pendingMessageQueueDrag: null,
@@ -432,6 +433,7 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     defaultAiDraft: { vendor: "", model: "", effort: "" },
     defaultAiDraftDirty: false,
     defaultVendorState: { loading: false, saving: false, getRequestId: null, saveRequestId: null, preference: null, preferencePresent: false, installedVendors: [], accountId: null, projectSlug: null, serverEpoch: null, canonicalRevision: 0, error: "" },
+    projectSessionVisibilityState: { active: null, pending: null },
 
     // dm
     dmTargetUser: null,
@@ -492,6 +494,11 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     // new-session menu doesn't flash the TUI-only entry.
     claudeOpenMode: "gui",
     currentMode: "default",
+    effectivePermissionMode: null,
+    permissionCapabilities: { auto: false, mcpOverride: false },
+    permissionModePendingByTarget: {},
+    mcpPermissionModePendingByTarget: {},
+    mcpPermissionModeOverrides: {},
     currentEffort: "medium",
     currentBetas: [],
     currentThinking: "adaptive",