clay-server 3.3.2-beta.3 → 3.4.0-beta.10

package/lib/daemon-projects.js

@@ -41,10 +41,10 @@ function scanAndRegisterWorktrees(relay, parentPath, parentSlug, parentIcon, par
       if (worktreeRegistry[parentSlug][j] === wtSlug) { alreadyRegistered = true; break; }
     }
     if (alreadyRegistered) continue;
-    var wtMeta = { parentSlug: parentSlug, branch: wt.branch || wt.dirName, accessible: wt.accessible };
+    var wtMeta = { parentSlug: parentSlug, branch: wt.branch || wt.dirName, external: wt.external };
     relay.addProject(wt.path, wtSlug, wt.branch || wt.dirName, parentIcon, parentOwnerId, wtMeta);
     worktreeRegistry[parentSlug].push(wtSlug);
-    console.log("[daemon] Registered worktree:", wtSlug, "->", wt.path, wt.accessible ? "(accessible)" : "(inaccessible)");
+    console.log("[daemon] Registered worktree:", wtSlug, "->", wt.path, wt.external ? "(external)" : "(inside project folder)");
   }
   daemonSync.register(getWorktreeSyncKey(parentSlug), function () {
     rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId);
@@ -79,7 +79,7 @@ function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerI
         if (existingSlugs[ei] === wtSlug) { found = true; break; }
       }
       if (!found) {
-        var wtMeta = { parentSlug: parentSlug, branch: wt.branch || wt.dirName, accessible: wt.accessible };
+        var wtMeta = { parentSlug: parentSlug, branch: wt.branch || wt.dirName, external: wt.external };
         relay.addProject(wt.path, wtSlug, wt.branch || wt.dirName, parentIcon, parentOwnerId, wtMeta);
         if (!worktreeRegistry[parentSlug]) worktreeRegistry[parentSlug] = [];
         worktreeRegistry[parentSlug].push(wtSlug);

package/lib/daemon.js

@@ -978,7 +978,7 @@ var relay = createServer({
     if (!result.ok) return result;
     // Register the new worktree as ephemeral project
     var wtSlug = parentSlug + "--" + dirName;
-    var wtMeta = { parentSlug: parentSlug, branch: branchName, accessible: true };
+    var wtMeta = { parentSlug: parentSlug, branch: branchName, external: false };
     relay.addProject(result.path, wtSlug, branchName, parent.icon, parent.ownerId, wtMeta);
     registerWorktreeSlug(parentSlug, wtSlug);
     console.log("[daemon] Created worktree:", wtSlug, "->", result.path);

package/lib/project-connection.js

@@ -22,6 +22,17 @@ function dispatchMessageSafely(handleMessage, sendTo, slug, ws, msg) {
   }
 }
 
+function buildInitialModelInfo(sm, initialVendor, initialModel, initialModels) {
+  return {
+    type: "model_info",
+    model: initialModel || "",
+    models: initialModels || [],
+    vendor: initialVendor,
+    availableVendors: sm.availableVendors || [],
+    installedVendors: sm.installedVendors || [],
+  };
+}
+
 /**
  * Attach connection/disconnection handlers to a project context.
  *
@@ -116,7 +127,7 @@ function attachConnection(ctx) {
     if (!_warmedUp) {
       _warmedUp = true;
       if (typeof warmup === "function") {
-        try { warmup(); }
+        try { warmup(wsUser && wsUser.linuxUser ? wsUser.linuxUser : null); }
         catch (e) { console.error("[project-connection] warmup failed for " + slug + ":", e && e.message ? e.message : e); }
       }
     }
@@ -167,9 +178,9 @@ function attachConnection(ctx) {
       sendTo(ws, { type: "slash_commands", commands: sm.slashCommands });
     }
     var initialModel = (restoredActive && restoredActive.model) || sm.currentModel || "";
-    if (initialModel) {
-      sendTo(ws, { type: "model_info", model: initialModel, models: initialModels, vendor: initialVendor, availableVendors: sm.availableVendors || [], installedVendors: sm.installedVendors || [] });
-    }
+    // Vendor installation state is needed even before a new project has a
+    // model. Always send it so reconnects cannot fall back to "Not installed."
+    sendTo(ws, buildInitialModelInfo(sm, initialVendor, initialModel, initialModels));
     sendTo(ws, { type: "config_state", model: initialModel, mode: sm.currentPermissionMode || "default", 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)));
@@ -333,4 +344,8 @@ function attachConnection(ctx) {
   };
 }
 
-module.exports = { attachConnection: attachConnection, dispatchMessageSafely: dispatchMessageSafely };
+module.exports = {
+  attachConnection: attachConnection,
+  buildInitialModelInfo: buildInitialModelInfo,
+  dispatchMessageSafely: dispatchMessageSafely,
+};

package/lib/project-debate.js

@@ -604,6 +604,7 @@ function attachDebate(ctx) {
     var _modMate = matesModule.getMate(mateCtx, debate.moderatorId);
     ctx.sdk.createMentionSession({
       vendor: _modMate ? _modMate.vendor : null,
+      linuxUser: mateCtx.linuxUser || undefined,
       claudeMd: claudeMd,
       initialContext: digests,
       initialMessage: quickBriefPrompt,
@@ -799,6 +800,7 @@ function attachDebate(ctx) {
     var _modMate2 = matesModule.getMate(mateCtx, debate.moderatorId);
     ctx.sdk.createMentionSession({
       vendor: _modMate2 ? _modMate2.vendor : null,
+      linuxUser: mateCtx.linuxUser || undefined,
       claudeMd: claudeMd,
       initialContext: moderatorContext,
       initialMessage: "Begin the debate on: " + debate.topic,
@@ -994,6 +996,7 @@ function attachDebate(ctx) {
       var _panMate = matesModule.getMate(debate.mateCtx, mateId);
       ctx.sdk.createMentionSession({
         vendor: _panMate ? _panMate.vendor : null,
+        linuxUser: debate.mateCtx && debate.mateCtx.linuxUser ? debate.mateCtx.linuxUser : undefined,
         claudeMd: claudeMd,
         initialContext: panelistContext + historyContext,
         initialMessage: "The moderator addresses you:\n\n" + moderatorText,
@@ -1530,6 +1533,7 @@ function attachDebate(ctx) {
         var _modMate3 = matesModule.getMate(mateCtx, debate.moderatorId);
         ctx.sdk.createMentionSession({
           vendor: _modMate3 ? _modMate3.vendor : null,
+          linuxUser: mateCtx.linuxUser || undefined,
           claudeMd: claudeMd,
           initialContext: moderatorContext,
           initialMessage: resumePrompt,

package/lib/project-file-watch.js

@@ -21,12 +21,22 @@ function attachFileWatch(ctx) {
   // one browser tab silently replace another tab's live preview subscription.
   var fileWatchers = new Map();
 
+  function settleFileWatchReady(entry, ready) {
+    if (!entry || !entry.resolveReady) return;
+    var resolve = entry.resolveReady;
+    entry.resolveReady = null;
+    resolve(ready);
+  }
+
   function closeFileWatch(key) {
     var entry = fileWatchers.get(key);
     if (!entry) return;
     clearTimeout(entry.debounce);
+    if (entry.reconcile) clearImmediate(entry.reconcile);
+    if (entry.pollTimer) clearInterval(entry.pollTimer);
     try { entry.watcher.close(); } catch (e) {}
     fileWatchers.delete(key);
+    settleFileWatchReady(entry, false);
   }
 
   function sendFileChanged(client, message) {
@@ -37,6 +47,36 @@ function attachFileWatch(ctx) {
     }
   }
 
+  function readFileSnapshot(absPath) {
+    var stat = fs.statSync(absPath);
+    var ext = path.extname(absPath).toLowerCase();
+    if (stat.size > FS_MAX_SIZE || BINARY_EXTS.has(ext)) return null;
+    return { content: fs.readFileSync(absPath, "utf8"), size: stat.size };
+  }
+
+  function publishFileChanged(key, client, relPath, absPath) {
+    var latest = fileWatchers.get(key);
+    if (!latest || latest.relPath !== relPath) return;
+    try {
+      var snapshot = readFileSnapshot(absPath);
+      if (!snapshot) return;
+      if (latest.hasSnapshot && latest.content === snapshot.content && latest.size === snapshot.size) return;
+      latest.hasSnapshot = true;
+      latest.content = snapshot.content;
+      latest.size = snapshot.size;
+      sendFileChanged(client, {
+        type: "fs_file_changed",
+        path: relPath,
+        content: snapshot.content,
+        size: snapshot.size,
+      });
+    } catch (e) {
+      // Atomic saves can briefly remove the destination path between rename
+      // events. Keep the parent watcher alive for the next event.
+      if (e.code !== "ENOENT") closeFileWatch(key);
+    }
+  }
+
   function startFileWatch(client, relPath) {
     // Preserve the old single-argument API for callers outside the websocket
     // file browser. They share one legacy subscription.
@@ -45,10 +85,10 @@ function attachFileWatch(ctx) {
       client = null;
     }
     var absPath = safePath(cwd, relPath);
-    if (!absPath) return;
+    if (!absPath) return Promise.resolve(false);
     var key = client || "_legacy";
     var existing = fileWatchers.get(key);
-    if (existing && existing.relPath === relPath) return;
+    if (existing && existing.relPath === relPath) return existing.ready;
     closeFileWatch(key);
 
     // Watch the parent directory rather than the file inode. Editors and agent
@@ -56,6 +96,8 @@ function attachFileWatch(ctx) {
     // misses later edits even though the path still exists.
     var parentPath = path.dirname(absPath);
     var baseName = path.basename(absPath);
+    var initialSnapshot = null;
+    try { initialSnapshot = readFileSnapshot(absPath); } catch (e) {}
     try {
       var watcher = fs.watch(parentPath, function (eventType, filename) {
         if (filename && String(filename) !== baseName) return;
@@ -63,25 +105,44 @@ function attachFileWatch(ctx) {
         if (!active || active.relPath !== relPath) return;
         clearTimeout(active.debounce);
         active.debounce = setTimeout(function () {
-          var latest = fileWatchers.get(key);
-          if (!latest || latest.relPath !== relPath) return;
-          try {
-            var stat = fs.statSync(absPath);
-            var ext = path.extname(absPath).toLowerCase();
-            if (stat.size > FS_MAX_SIZE || BINARY_EXTS.has(ext)) return;
-            var content = fs.readFileSync(absPath, "utf8");
-            sendFileChanged(client, { type: "fs_file_changed", path: relPath, content: content, size: stat.size });
-          } catch (e) {
-            // Atomic saves can briefly remove the destination path between
-            // rename events. Keep the parent watcher alive for the next event.
-            if (e.code !== "ENOENT") closeFileWatch(key);
-          }
+          publishFileChanged(key, client, relPath, absPath);
         }, 200);
       });
-      fileWatchers.set(key, { watcher: watcher, relPath: relPath, debounce: null });
+      var resolveReady = null;
+      var ready = new Promise(function (resolve) { resolveReady = resolve; });
+      var entry = {
+        watcher: watcher,
+        relPath: relPath,
+        debounce: null,
+        reconcile: null,
+        pollTimer: null,
+        ready: ready,
+        resolveReady: resolveReady,
+        hasSnapshot: !!initialSnapshot,
+        content: initialSnapshot ? initialSnapshot.content : null,
+        size: initialSnapshot ? initialSnapshot.size : null,
+      };
+      fileWatchers.set(key, entry);
+      // Directory events are the low-latency path, but macOS can coalesce or
+      // drop them under load. Periodic content reconciliation is the source of
+      // truth and also survives atomic replacements with identical metadata.
+      entry.pollTimer = setInterval(function () {
+        publishFileChanged(key, client, relPath, absPath);
+      }, 1000);
+      // fs.watch has no readiness event. Reconcile once on the next event-loop
+      // turn so a change between the initial read and native watcher activation
+      // cannot leave the browser showing stale content.
+      entry.reconcile = setImmediate(function () {
+        var active = fileWatchers.get(key);
+        if (active) active.reconcile = null;
+        publishFileChanged(key, client, relPath, absPath);
+        if (fileWatchers.get(key) === entry) settleFileWatchReady(entry, true);
+      });
       watcher.on("error", function () { closeFileWatch(key); });
+      return ready;
     } catch (e) {
       closeFileWatch(key);
+      return Promise.resolve(false);
     }
   }
 

package/lib/project-mate-interaction.js

@@ -179,6 +179,7 @@ function attachMateInteraction(ctx) {
   var _digestQueue = [];
   var _digestBusy = false;
   var _digestWorkerTurns = 0;
+  var _digestWorkerLinuxUser = null;
   var DIGEST_WORKER_MAX_TURNS = 20;
 
   function enqueueDigest(job) {
@@ -191,6 +192,13 @@ function attachMateInteraction(ctx) {
     _digestBusy = true;
     var job = _digestQueue.shift();
 
+    if (_digestWorker && _digestWorkerLinuxUser !== (job.linuxUser || null)) {
+      try { _digestWorker.close(); } catch (e) {}
+      _digestWorker = null;
+      _digestWorkerTurns = 0;
+      _digestWorkerLinuxUser = null;
+    }
+
     var mateDir = matesModule.getMateDir(job.mateCtx, job.mateId);
     var knowledgeDir = path.join(mateDir, "knowledge");
 
@@ -315,6 +323,7 @@ function attachMateInteraction(ctx) {
       try { _digestWorker.close(); } catch (e) {}
       _digestWorker = null;
       _digestWorkerTurns = 0;
+      _digestWorkerLinuxUser = null;
     }
 
     var responseText = "";
@@ -328,12 +337,14 @@ function attachMateInteraction(ctx) {
           console.error("[digest-worker] Error:", err);
           _digestWorker = null;
           _digestWorkerTurns = 0;
+          _digestWorkerLinuxUser = null;
           if (job.onError) job.onError(err);
           processDigestQueue();
         },
       });
     } else {
       sdk.createMentionSession({
+        linuxUser: job.linuxUser || undefined,
         claudeMd: "",
         model: "haiku",
         initialContext: "[Digest Worker] You generate memory digests. Respond with ONLY JSON.",
@@ -344,10 +355,15 @@ function attachMateInteraction(ctx) {
         onError: function (err) {
           console.error("[digest-worker] Create error:", err);
           _digestWorker = null;
+          _digestWorkerLinuxUser = null;
           if (job.onError) job.onError(err);
           processDigestQueue();
         },
-      }).then(function (ws) { _digestWorker = ws; _digestWorkerTurns = 1; }).catch(function (err) {
+      }).then(function (ws) {
+        _digestWorker = ws;
+        _digestWorkerTurns = 1;
+        _digestWorkerLinuxUser = job.linuxUser || null;
+      }).catch(function (err) {
         if (job.onError) job.onError(err || new Error("digest worker creation failed"));
         processDigestQueue();
       });
@@ -378,6 +394,7 @@ function attachMateInteraction(ctx) {
 
     enqueueDigest({
       mateCtx: mateCtx,
+      linuxUser: mateCtx.linuxUser || undefined,
       mateId: mateId,
       type: "mention",
       conversationContent: conversationContent,
@@ -473,6 +490,7 @@ function attachMateInteraction(ctx) {
 
     enqueueDigest({
       mateCtx: mateCtx,
+      linuxUser: mateCtx.linuxUser || undefined,
       mateId: mateId,
       type: "dm",
       priorSummary: priorSummary || "",
@@ -716,6 +734,7 @@ function attachMateInteraction(ctx) {
       // Create new persistent mention session
       sdk.createMentionSession({
         vendor: mate.vendor || null,
+        linuxUser: getLinuxUserForSession(session) || undefined,
         claudeMd: claudeMd,
         initialContext: mentionContext,
         initialMessage: mentionFullInput,
@@ -887,6 +906,7 @@ function attachMateInteraction(ctx) {
     ].join("\n");
 
     sdk.createMentionSession({
+      linuxUser: mateCtx.linuxUser || undefined,
       claudeMd: "",
       model: "haiku",
       initialContext: synthesisContext,

package/lib/project-memory.js

@@ -339,6 +339,7 @@ function attachMemory(ctx) {
     var gateText = "";
     var _gateSession = null;
     sdk.createMentionSession({
+      linuxUser: mateCtx.linuxUser || undefined,
       claudeMd: "",
       model: "haiku",
       initialContext: gateContext,
@@ -448,6 +449,7 @@ function attachMemory(ctx) {
     var updateText = "";
     var _updateSession = null;
     sdk.createMentionSession({
+      linuxUser: mateCtx.linuxUser || undefined,
       claudeMd: "",
       model: "haiku",
       initialContext: updateContext,
@@ -553,6 +555,7 @@ function attachMemory(ctx) {
     var initText = "";
     var _initSession = null;
     sdk.createMentionSession({
+      linuxUser: mateCtx.linuxUser || undefined,
       claudeMd: "",
       model: "haiku",
       initialContext: initContext,

package/lib/project-shell-command.js

@@ -0,0 +1,160 @@
+var { spawn } = require("child_process");
+var { buildUserEnv } = require("./build-user-env");
+var { wrapSpawnAsUser } = require("./os-users");
+
+var MAX_COMMAND_LENGTH = 16 * 1024;
+var MAX_OUTPUT_LENGTH = 64 * 1024;
+var COMMAND_TIMEOUT_MS = 30 * 1000;
+
+function stripTerminalCodes(value) {
+  return String(value || "")
+    .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-?]*[ -\/]*[@-~]/g, "")
+    .replace(/\r/g, "");
+}
+
+function attachShellCommand(ctx) {
+  var runningBySocket = new WeakMap();
+
+  function sendResult(ws, data) {
+    ctx.sendTo(ws, Object.assign({ type: "shell_command_result" }, data));
+  }
+
+  function handleShellCommand(ws, msg) {
+    if (msg.type !== "shell_command") return false;
+
+    var requestId = typeof msg.requestId === "string" ? msg.requestId.slice(0, 100) : "";
+    var command = typeof msg.command === "string" ? msg.command.trim() : "";
+    if (!requestId || !command) {
+      sendResult(ws, { requestId: requestId, error: "Enter a command to run." });
+      return true;
+    }
+    if (command.length > MAX_COMMAND_LENGTH) {
+      sendResult(ws, { requestId: requestId, error: "Command is too long." });
+      return true;
+    }
+
+    if (ws._clayUser) {
+      var permissions = ctx.usersModule.getEffectivePermissions(ws._clayUser, ctx.osUsers);
+      if (!permissions.terminal) {
+        sendResult(ws, { requestId: requestId, error: "Terminal access is not permitted." });
+        return true;
+      }
+    }
+    if (runningBySocket.get(ws)) {
+      sendResult(ws, { requestId: requestId, error: "Another shell command is still running." });
+      return true;
+    }
+
+    var session = ctx.getSessionForWs(ws);
+    if (!session) {
+      sendResult(ws, { requestId: requestId, error: "No active session." });
+      return true;
+    }
+
+    var osUserInfo = ctx.getOsUserInfoForWs(ws);
+    var shell = (osUserInfo && osUserInfo.shell)
+      || process.env.SHELL
+      || (process.platform === "win32" ? process.env.COMSPEC || "cmd.exe" : "/bin/sh");
+    var args = process.platform === "win32" ? ["/d", "/s", "/c", command] : ["-lc", command];
+    var spawnOptions = {
+      cwd: ctx.cwd,
+      env: buildUserEnv(osUserInfo),
+      stdio: ["ignore", "pipe", "pipe"],
+    };
+    if (osUserInfo) {
+      spawnOptions.uid = osUserInfo.uid;
+      spawnOptions.gid = osUserInfo.gid;
+    }
+
+    var wrapped = wrapSpawnAsUser(shell, args, spawnOptions);
+    var child;
+    try {
+      child = spawn(wrapped.command, wrapped.args, wrapped.options);
+    } catch (e) {
+      sendResult(ws, { requestId: requestId, error: e.message || "Failed to start command." });
+      return true;
+    }
+
+    runningBySocket.set(ws, child);
+    var chunks = [];
+    var outputLength = 0;
+    var truncated = false;
+    var timedOut = false;
+    var finished = false;
+
+    function collect(data) {
+      if (outputLength >= MAX_OUTPUT_LENGTH) {
+        truncated = true;
+        return;
+      }
+      var text = data.toString("utf8");
+      var remaining = MAX_OUTPUT_LENGTH - outputLength;
+      if (text.length > remaining) {
+        text = text.slice(0, remaining);
+        truncated = true;
+      }
+      chunks.push(text);
+      outputLength += text.length;
+    }
+
+    child.stdout.on("data", collect);
+    child.stderr.on("data", collect);
+
+    var timer = setTimeout(function () {
+      timedOut = true;
+      try { child.kill("SIGTERM"); } catch (e) {}
+      setTimeout(function () {
+        if (!finished) {
+          try { child.kill("SIGKILL"); } catch (e) {}
+        }
+      }, 1000).unref();
+    }, COMMAND_TIMEOUT_MS);
+    timer.unref();
+
+    child.on("error", function (error) {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      runningBySocket.delete(ws);
+      sendResult(ws, { requestId: requestId, command: command, error: error.message || "Command failed." });
+    });
+
+    child.on("close", function (code, signal) {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      runningBySocket.delete(ws);
+
+      var output = stripTerminalCodes(chunks.join(""));
+      if (truncated) output += "\n… output truncated at 64 KB";
+      if (timedOut) output += (output ? "\n" : "") + "Command timed out after 30 seconds.";
+      var exitCode = typeof code === "number" ? code : null;
+      var context = [
+        "[Shell command executed by the user]",
+        "$ " + command,
+        output || "(no output)",
+        "[Exit code: " + (exitCode == null ? (signal || "unknown") : exitCode) + "]",
+      ].join("\n");
+      if (!session.pendingShellContexts) session.pendingShellContexts = [];
+      session.pendingShellContexts.push(context);
+
+      sendResult(ws, {
+        requestId: requestId,
+        sessionId: session.localId,
+        command: command,
+        output: output,
+        exitCode: exitCode,
+        signal: signal || null,
+        timedOut: timedOut,
+        truncated: truncated,
+      });
+    });
+
+    return true;
+  }
+
+  return { handleShellCommand: handleShellCommand };
+}
+
+module.exports = { attachShellCommand: attachShellCommand };

package/lib/project-user-message.js

@@ -374,6 +374,16 @@ function attachUserMessage(ctx) {
       fullText = mentionPrefix + "\n\n" + fullText;
     }
 
+    // Inject one-shot shell results captured from the composer command mode.
+    if (session.pendingShellContexts && session.pendingShellContexts.length > 0) {
+      var shellPrefix = session.pendingShellContexts.join("\n\n");
+      session.pendingShellContexts = [];
+      fullText = shellPrefix + "\n\n" + fullText;
+    }
+    if (msg.shellCommandResponse) {
+      fullText += "\n\n[Respond to the shell command result above now.]";
+    }
+
     // Inject active terminal context sources (delta only: send new output since last message)
     var TERM_CONTEXT_MAX = 8192; // 8KB max per terminal per message
     var TERM_HEAD_SIZE = 2048;   // keep first 2KB for error context

package/lib/project.js

@@ -28,6 +28,7 @@ var { attachKnowledge } = require("./project-knowledge");
 var { attachFilesystem } = require("./project-filesystem");
 var { attachSessions } = require("./project-sessions");
 var { attachUserMessage } = require("./project-user-message");
+var { attachShellCommand } = require("./project-shell-command");
 var { attachConnection } = require("./project-connection");
 var { attachMcp } = require("./project-mcp");
 var { createLocalMcp } = require("./mcp-local");
@@ -162,7 +163,7 @@ function createProjectContext(opts) {
   var updateChannel = opts.updateChannel || "stable";
   var osUsers = opts.osUsers || false;
   var projectOwnerId = opts.projectOwnerId || null;
-  var worktreeMeta = opts.worktreeMeta || null; // { parentSlug, branch, accessible }
+  var worktreeMeta = opts.worktreeMeta || null; // { parentSlug, branch, external }
   var isMate = opts.isMate || false;
   var onCreateWorktree = opts.onCreateWorktree || null;
   var serverPort = opts.port || 2633;
@@ -834,6 +835,7 @@ function createProjectContext(opts) {
     getNotificationsModule: function () { return _notifications; },
     mateDisplayName: opts.mateDisplayName || "",
     isMate: isMate,
+    osUsers: osUsers,
     dangerouslySkipPermissions: dangerouslySkipPermissions,
     mcpServers: getLocalMcpServers,
     getRemoteMcpServers: function () { return _mcp.getMcpServers(); },
@@ -1077,6 +1079,7 @@ function createProjectContext(opts) {
               try {
                 var readyResult = await vendorAdapter.init({
                   cwd: cwd,
+                  linuxUser: modelLinuxUser || undefined,
                   clayPort: serverPort,
                   clayTls: serverTls,
                   clayAuthToken: serverAuthToken,
@@ -1176,6 +1179,9 @@ function createProjectContext(opts) {
     // --- Filesystem, settings, env (delegated to project-filesystem.js) ---
     if (_filesystem.handleFilesystemMessage(ws, msg)) return;
 
+    // --- Shell command context ---
+    if (_shellCommand.handleShellCommand(ws, msg)) return;
+
     // --- Notes, terminals, context, user message (delegated to project-user-message.js) ---
     if (_userMessage.handleUserMessage(ws, msg)) return;
   }
@@ -1424,6 +1430,15 @@ function createProjectContext(opts) {
     _email: _email,
   });
 
+  var _shellCommand = attachShellCommand({
+    cwd: cwd,
+    osUsers: osUsers,
+    usersModule: usersModule,
+    sendTo: sendTo,
+    getSessionForWs: getSessionForWs,
+    getOsUserInfoForWs: getOsUserInfoForWs,
+  });
+
   // --- Filesystem handler (delegated to project-filesystem.js) ---
   var _filesystem = attachFilesystem({
     cwd: cwd,
@@ -1673,8 +1688,8 @@ function createProjectContext(opts) {
     getProject: function () { return project; },
     // Exposed so the first websocket connection can lazily warm up the
     // adapters for this project (see project-connection handleConnection).
-    warmup: function () {
-      sdk.warmup();
+    warmup: function (linuxUser) {
+      sdk.warmup(osUsers ? linuxUser : null);
       sdk.startIdleReaper();
       if (!osUsers && !sessionTitleMigrationScheduled) {
         sessionTitleMigrationScheduled = true;
@@ -1800,7 +1815,7 @@ function createProjectContext(opts) {
       status.isWorktree = true;
       status.parentSlug = worktreeMeta.parentSlug;
       status.branch = worktreeMeta.branch;
-      status.worktreeAccessible = worktreeMeta.accessible;
+      status.worktreeExternal = worktreeMeta.external === true;
     }
     if (usersModule.isMultiUser()) {
       var seen = {};