clay-server 5.5.0-beta.2 → 5.5.0-beta.4

package/lib/sdk-bridge.js

@@ -1075,7 +1075,7 @@ function createSDKBridge(opts) {
       console.log("[sdk-bridge] processQueryStream ended: isProcessing=" + session.isProcessing + " taskStopRequested=" + session.taskStopRequested);
       var stillOwnsRuntime = session.queryInstance === myQueryInstance && !responseRecovery.stopping(session);
       settleContinuationStartup(session, myQueryInstance, myQueryGeneration, false, "The successor query ended before initialization.");
-      if (session.isProcessing && session.taskStopRequested && stillOwnsRuntime) {
+      if ((session.isProcessing || session._awaitingTurnResult) && session.taskStopRequested && stillOwnsRuntime) {
         session._lastTurnInterrupted = true;
         session.isProcessing = false;
         session._awaitingTurnResult = false;
@@ -1088,7 +1088,7 @@ function createSDKBridge(opts) {
         sendAndRecord(session, { type: "info", text: interruptMsg });
         sendAndRecord(session, { type: "done", code: 0 });
         sm.broadcastSessionList();
-      } else if (session.isProcessing && stillOwnsRuntime) {
+      } else if ((session.isProcessing || session._awaitingTurnResult) && stillOwnsRuntime) {
         // Codex and Kiro can report a protocol error and then close their
         // iterator without a result event. Treat any result-less stream end as
         // a failed turn so the UI cannot remain on processing forever.
@@ -1109,7 +1109,7 @@ function createSDKBridge(opts) {
       }
     } catch (err) {
       settleContinuationStartup(session, myQueryInstance, myQueryGeneration, false, err.message || "The successor query failed before initialization.");
-      if (session.isProcessing && session.queryInstance === myQueryInstance && !responseRecovery.stopping(session)) {
+      if ((session.isProcessing || session._awaitingTurnResult) && session.queryInstance === myQueryInstance && !responseRecovery.stopping(session)) {
         session.isProcessing = false;
         session._awaitingTurnResult = false;
         session._queuedTurnCount = 0;
@@ -1360,6 +1360,15 @@ function createSDKBridge(opts) {
     // Claude: conversation rollback is handled by rewindFiles + local history trim
   }
 
+  function forceProvider(session) {
+    var vendor = session.vendor || sm.defaultVendor || adapter && adapter.vendor;
+    return adapters[vendor] || (adapter && adapter.vendor === vendor ? adapter : vendor);
+  }
+  sm.getForceStopSupport = function (session) {
+    if (session._queryStarting) return { supported: false, reason: 'Force termination is unavailable while this runtime is starting' };
+    return require('./yoke/force-termination').support(forceProvider(session), session.queryInstance);
+  };
+
   function getAdapterForSession(session) {
     var vendor = session.vendor || sm.defaultVendor || "claude";
     return adapters[vendor] || adapter;
@@ -1405,8 +1414,9 @@ function createSDKBridge(opts) {
     var payload = { text: text, images: images, linuxUser: linuxUser, beforePush: beforePush };
     var recoveryState = responseRecovery.begin(session, payload, retryState);
     if (recoveryState) recoveryState.handle = null;
+    var startRevision = session._forceStopRevision || 0;
     var guardedPush = function() {
-      return !session.destroying && !session.taskStopRequested
+      return (session._forceStopRevision || 0) === startRevision && !session.destroying && !session.taskStopRequested
         && (!recoveryState || responseRecovery.valid(session, recoveryState) && !recoveryState.stopping)
         && (typeof beforePush !== "function" || beforePush() === true);
     };
@@ -1417,6 +1427,7 @@ function createSDKBridge(opts) {
     if (recoveryState) recoveryState.starting = starting;
     try {
       var accepted = await starting;
+      if ((session._forceStopRevision || 0) !== startRevision) return false;
       if (accepted === false && (!recoveryState || !recoveryState.stopping)) {
         responseRecovery.cancel(session);
         session.isProcessing = false;
@@ -1424,6 +1435,7 @@ function createSDKBridge(opts) {
       }
       return accepted;
     } catch (error) {
+      if ((session._forceStopRevision || 0) !== startRevision) return false;
       // Includes synchronous input queue failures, before stream consumption.
       var failedHandle = session.queryInstance;
       if (failedHandle) {
@@ -1446,6 +1458,7 @@ function createSDKBridge(opts) {
       }
       return false;
     } finally {
+      if ((session._forceStopRevision || 0) !== startRevision) return false;
       session._queryStarting = false;
       delete session._providerRecoveryWaiting;
       if (!session.queryInstance && session.pendingPush && session.pendingPush.length) session.pendingPush = [];
@@ -1580,11 +1593,18 @@ function createSDKBridge(opts) {
         }
       }
     }
+    if (typeof beforePush === "function" && beforePush() !== true) return false;
     // If still not available after lazy check, send auth_required
     if (session.vendor && !adapters[session.vendor]) {
       var missingVendorInfo = yoke.getVendorInfo(session.vendor);
       var vendorName = (missingVendorInfo && missingVendorInfo.displayName)
         || session.vendor.charAt(0).toUpperCase() + session.vendor.slice(1);
+      var installedForIdentity = linuxUser ? require('./yoke/discovery').installed({ user: linuxUser, env: sessionRuntimeEnv }) : yoke.checkInstalled();
+      if (!installedForIdentity[session.vendor]) {
+        sendAndRecord(session, { type: 'error', text: vendorName + ' is not installed for this runtime. Install the provider before retrying the task.' });
+        sendAndRecord(session, { type: 'done', code: 1 });
+        return false;
+      }
       var authUser = session.ownerId ? usersModule.findUserById(session.ownerId) : null;
       var authLinuxUser = authUser && authUser.linuxUser ? authUser.linuxUser : null;
       var canAutoLogin = !usersModule.isMultiUser()
@@ -1650,6 +1670,7 @@ function createSDKBridge(opts) {
       if (typeof preparation === "function") preparation(linuxUser, session, cwd);
     }
 
+    if (typeof beforePush === "function" && beforePush() !== true) return false;
     session.blocks = {};
     session.sentToolResults = {};
     taskLifecycle.clearAll(session);
@@ -1882,6 +1903,7 @@ function createSDKBridge(opts) {
     // the SDK ignores Options.title in favor of the persisted title.
     var initialTitle = null;
     var initialTitleProvisional = false;
+    if (typeof beforePush === "function" && beforePush() !== true) return false;
     if (!session.cliSessionId && !session.titleManuallySet && !session.titleAutoGenerated) {
       var initialTitleChoice = sessionTitlePolicy.selectInitialTitle(session, text);
       initialTitle = initialTitleChoice.title;
@@ -2014,6 +2036,15 @@ function createSDKBridge(opts) {
     console.log("[sdk-bridge] calling adapter.createQuery... vendor=" + sessionAdapter.vendor);
     try {
       handle = await sessionAdapter.createQuery(queryOpts);
+      if (Number(session._sdkQueryGeneration || 0) !== queryGeneration || !(recoveryState && recoveryState.stopping) && typeof beforePush === "function" && beforePush() !== true) {
+        try { if (handle.abort) Promise.resolve(handle.abort()).catch(function () {}); } catch (e) {}
+        try { if (handle.close) Promise.resolve(handle.close()).catch(function () {}); } catch (e) {}
+        if (Number(session._sdkQueryGeneration || 0) === queryGeneration) {
+          sendAndRecord(session, { type: "info", text: "Stopped before sending your message." });
+          sendAndRecord(session, { type: "done", code: 0 });
+        }
+        return false;
+      }
       // A guarded delivery must still own the exact startup after provider
       // creation. Never replace a newer handle or publish to a deleted target.
       if (beforePush && beforePush.exactProductDelivery) {
@@ -2046,7 +2077,7 @@ function createSDKBridge(opts) {
       console.error("[sdk-bridge] Failed to create query for session " + session.localId + ":", e.message || e);
       console.error("[sdk-bridge] cliSessionId:", session.cliSessionId, "resume:", !!session.cliSessionId);
       console.error("[sdk-bridge] Stack:", e.stack || "(no stack)");
-      if (beforePush && beforePush.exactProductDelivery && (sm.sessions.get(session.localId) !== session || session.queryInstance !== startupHandle || Number(session._sdkQueryGeneration || 0) !== queryGeneration)) return false;
+      if (sm.sessions.get(session.localId) !== session || session.queryInstance !== startupHandle || Number(session._sdkQueryGeneration || 0) !== queryGeneration) return false;
       session.isProcessing = false;
       session._awaitingTurnResult = false;
       session._queuedTurnCount = 0;
@@ -2110,7 +2141,8 @@ function createSDKBridge(opts) {
     if (typeof beforePush === "function" && beforePush() !== true) {
       try { if (typeof handle.abort === "function") handle.abort(); } catch (e) {}
       try { handle.close(); } catch (e) {}
-      if (session.queryInstance === handle) session.queryInstance = null;
+      if (session.queryInstance !== handle || Number(session._sdkQueryGeneration || 0) !== queryGeneration) return false;
+      session.queryInstance = null;
       session.messageQueue = null;
       session.abortController = null;
       session.isProcessing = false;
@@ -2735,6 +2767,8 @@ function createSDKBridge(opts) {
   }
 
   return {
+    getForceStopSupport: sm.getForceStopSupport,
+    forceStopSession: require("./sdk-force-stop").createForceStop({ sm: sm, provider: forceProvider, record: sendAndRecord, changed: onProcessingChanged }),
     createMessageQueue: createMessageQueue,
     processSDKMessage: processSDKMessage,
     checkToolWhitelist: checkToolWhitelist,

package/lib/sdk-force-stop.js

@@ -0,0 +1,62 @@
+// Retire one exact query and invoke only its declared YOKE force operation.
+function createForceStop(ctx) {
+  return async function forceStop(session) {
+    if (ctx.sm.sessions.get(session.localId) !== session) throw new Error('Session was deleted or replaced.');
+    if (session._queryStarting) throw new Error('Force termination is unavailable while this runtime is starting');
+    var terminate = require("./yoke/force-termination").operation(ctx.provider(session), session.queryInstance);
+    var undelivered = session.pendingPush || [];
+    session._forceStopRevision = (session._forceStopRevision || 0) + 1;
+    session._sdkQueryGeneration = Number(session._sdkQueryGeneration || 0) + 1;
+    session._queryGeneration = (session._queryGeneration || 0) + 1;
+    session.taskStopRequested = true;
+    session._pendingMessageDrainPaused = true;
+    session.queryInstance = null;
+    session.abortController = null;
+    session.messageQueue = null;
+    session._queryStarting = false;
+    session._responseRecoveryStopPending = null;
+    session.isProcessing = false;
+    session._awaitingTurnResult = false;
+    session._queuedTurnCount = 0;
+    session.pendingPush = [];
+    delete session._foregroundAdmission;
+    delete session._providerRecoveryWaiting;
+    session._lastTurnInterrupted = true;
+    var probe = session._continuationStartupProbe;
+    if (probe && probe.timer) clearTimeout(probe.timer);
+    delete session._continuationStartupProbe;
+    if (probe && typeof probe.resolve === 'function') probe.resolve({ accepted: false, reason: 'Force stopped.' });
+    var permissions = session.pendingPermissions || {};
+    Object.keys(permissions).forEach(function (id) {
+      if (typeof permissions[id].resolve === 'function') permissions[id].resolve({ behavior: 'deny', message: 'Force stopped.' });
+      if (ctx.sm.permissionRequestIndex) delete ctx.sm.permissionRequestIndex[id];
+    });
+    var questions = session.pendingAskUser || {};
+    Object.keys(questions).forEach(function (id) {
+      var respond = questions[id] && questions[id].respond;
+      if (respond && typeof respond.cancel === 'function') respond.cancel('Force stopped.');
+    });
+    session.pendingPermissions = {};
+    session.pendingAskUser = {};
+    var dialogs = session.pendingUserDialogs || {};
+    Object.keys(dialogs).forEach(function (id) { if (typeof dialogs[id].resolve === 'function') dialogs[id].resolve({ behavior: 'cancelled' }); });
+    var elicitations = session.pendingElicitations || {};
+    Object.keys(elicitations).forEach(function (id) { if (typeof elicitations[id].resolve === 'function') elicitations[id].resolve({ action: 'cancel' }); });
+    session.pendingUserDialogs = {};
+    session.pendingElicitations = {};
+    var revision = session._forceStopRevision, generation = session._sdkQueryGeneration, owner = session.ownerId, vendor = session.vendor;
+    ctx.changed(); ctx.sm.broadcastSessionList();
+    var outcome;
+    try { outcome = await terminate(); }
+    catch (error) { outcome = { status: 'unconfirmed', externalEffects: 'unconfirmed' }; }
+    if (ctx.sm.sessions.get(session.localId) !== session || session._forceStopRevision !== revision || session._sdkQueryGeneration !== generation || session.ownerId !== owner || session.vendor !== vendor || session.queryInstance || session._queryStarting) return { status: 'failed', runtimeEffect: 'connection_retired', providerStop: outcome.status, externalEffects: 'unconfirmed', queuePaused: true, detail: 'Session was replaced during termination.' };
+    ctx.changed();
+    if (undelivered.length) ctx.record(session, { type: 'error', text: 'Buffered messages were not replayed after force stop. Review them before sending again.', recoveryAdmission: { state: 'not_sent', messages: undelivered.map(function (item) { return { text: item.text, images: item.images || null }; }) } });
+    ctx.record(session, { type: 'thinking_stop' });
+    ctx.record(session, { type: 'info', text: (outcome.status === 'terminated' ? 'The query runtime exited.' : 'Query runtime termination could not be confirmed.') + ' Queued messages are paused. Commands or external requests already sent may still be running; inspect their outcome before continuing.' });
+    ctx.record(session, { type: 'done', code: outcome.status === 'terminated' ? 0 : 1 });
+    ctx.sm.broadcastSessionList();
+    return { status: outcome.status === 'terminated' ? 'completed' : 'failed', runtimeEffect: 'connection_retired', providerStop: outcome.status, externalEffects: 'unconfirmed', queuePaused: true };
+  };
+}
+module.exports = { createForceStop: createForceStop };

package/lib/sdk-message-processor.js

@@ -81,8 +81,9 @@ function attachMessageProcessor(ctx) {
   // per session to avoid spamming when multiple auth errors arrive in a burst.
   function emitAuthRequired(session) {
     var now = Date.now();
-    if (session._lastAuthEmit && (now - session._lastAuthEmit) < 5000) return;
+    if (session._lastAuthQuery === session._queryGeneration && session._lastAuthEmit && (now - session._lastAuthEmit) < 5000) return;
     session._lastAuthEmit = now;
+    session._lastAuthQuery = session._queryGeneration;
 
     var vendor = session.vendor || "claude";
 

package/lib/server-worktree-controls.js

@@ -0,0 +1,34 @@
+// HTTP keeps the observed result reachable after the target project's sockets close.
+var crypto = require('crypto');
+function attachWorktreeHttp(ctx) {
+  function reply(res, code, data) { res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' }); res.end(JSON.stringify(data)); }
+  function handleRequest(req, res, url) {
+    if (url !== '/api/worktree-removal/preview' && url !== '/api/worktree-removal/execute') return false;
+    if (!ctx.isRequestAuthed(req)) { reply(res, 401, { ok: false, error: 'Authentication required.' }); return true; }
+    if (!ctx.service) { reply(res, 503, { ok: false, error: 'Worktree removal is unavailable in this server runtime.' }); return true; }
+    if (req.method !== 'POST' || req.headers['x-clay-worktree-control'] !== '1' ||
+        (req.headers['content-type'] || '').split(';')[0].trim().toLowerCase() !== 'application/json' ||
+        req.headers['sec-fetch-site'] && ['same-origin', 'none'].indexOf(req.headers['sec-fetch-site']) < 0) {
+      reply(res, 403, { ok: false, error: 'Use the worktree menu in Clay Studio.' }); return true;
+    }
+    var actor = ctx.getMultiUserFromReq(req), userId = actor && actor.id || null;
+    function validate() {
+      var current = ctx.getMultiUserFromReq(req);
+      if (!ctx.isRequestAuthed(req) || (current && current.id || null) !== userId) throw new Error('The authenticated owner session changed.');
+    }
+    var connection = crypto.createHash('sha256').update(req.headers.cookie || '').digest('hex');
+    var body = '', bytes = 0, oversized = false;
+    req.setEncoding('utf8');
+    req.on('data', function (chunk) { bytes += Buffer.byteLength(chunk); if (bytes > 4096) { if (!oversized) reply(res, 413, { ok: false, error: 'Request is too large.' }); oversized = true; } else body += chunk; });
+    req.on('end', function () {
+      if (oversized) return;
+      Promise.resolve().then(function () {
+        validate(); var data = JSON.parse(body);
+        return url.endsWith('/preview') ? ctx.service.preview(data.slug, data.action, userId, connection, data.deleteBranch) : ctx.service.execute(data.token, userId, connection, validate, data.deleteBranch);
+      }).then(function (result) { reply(res, 200, result); }, function (error) { reply(res, 409, Object.assign({ ok: false, error: error.message }, error.lifecycleResult || {})); });
+    });
+    return true;
+  }
+  return { handleRequest: handleRequest };
+}
+module.exports = { attachWorktreeHttp: attachWorktreeHttp };

package/lib/server.js

@@ -636,6 +636,10 @@ function createServer(opts) {
     res.setHeader("Content-Security-Policy", securityHeaders["Content-Security-Policy"] + " frame-src " + frameSrcFor(req) + ";");
   }
 
+  var worktreeHttp = require("./server-worktree-controls").attachWorktreeHttp({
+    service: opts.worktreeControls, isRequestAuthed: isRequestAuthed, getMultiUserFromReq: getMultiUserFromReq,
+  });
+
   // --- HTTP handler ---
   var appHandler = function (req, res) {
     setSecurityHeaders(res, req);
@@ -899,6 +903,7 @@ function createServer(opts) {
     if (linear.handleRequest(req, res, fullUrl)) return;
     if (speech.handleRequest(req, res, fullUrl)) return;
     if (githubStars.handleRequest(req, res, fullUrl)) return;
+    if (worktreeHttp.handleRequest(req, res, fullUrl)) return;
     if (networkSettings.handleRequest(req, res, fullUrl)) return;
     if (storageSettings.handleRequest(req, res, fullUrl)) return;
     if (settings.handleRequest(req, res, fullUrl)) return;
@@ -1475,7 +1480,7 @@ function createServer(opts) {
           var mate = mates.getMate(mates.buildMateCtx(users.isMultiUser() ? projectOwnerId : null), extra.mateId || path.basename(cwd));
           return { isMate: true, visibility: "private", ownerId: projectOwnerId || null, allowedUsers: [], lifecycleExecutionPaused: !mate || !!mate.lifecycleDeletion };
         }
-        return onGetProjectAccess ? onGetProjectAccess(slug) : { visibility: "public", ownerId: projectOwnerId || null };
+        return onGetProjectAccess ? onGetProjectAccess(slug, { slug: slug, path: cwd, changeSetId: worktreeMeta && worktreeMeta.changeSetId }) : { visibility: "public", ownerId: projectOwnerId || null };
       },
       shouldSuppressResponseNotification: function (session) {
         return shouldSuppressHomeResponse(projects, slug, session);
@@ -2118,6 +2123,11 @@ function createServer(opts) {
     destroyAll: destroyAll,
     durableScheduler: durableScheduler,
     setProjectLogContextState: setProjectLogContextState,
+    captureWorktreeLogContext: function (slug) {
+      var project = projects.get(slug), status = project && project.getStatus();
+      if (!status || !status.isWorktree) throw new Error('Worktree context is unavailable.');
+      return function (state) { return projectLogsService.setContextState(slug, state, status); };
+    },
   };
 }
 

package/lib/session-force-stop-support.js

@@ -0,0 +1,15 @@
+var provenance = require('./session-provenance');
+var termination = require('./yoke/force-termination');
+function targets(sm, session) {
+  return [session].concat(provenance.isWorker(session) ? [] : provenance.ownedWorkersByDriver(Array.from(sm.sessions.values()))[session.localId] || []);
+}
+function one(sm, session) {
+  if (session._queryStarting) return { supported: false, reason: 'Force termination is unavailable while this runtime is starting' };
+  return typeof sm.getForceStopSupport === 'function' ? sm.getForceStopSupport(session) : termination.support(session.vendor || sm.defaultVendor, session.queryInstance);
+}
+function describe(sm, session) {
+  var scope = targets(sm, session), unavailable = scope.find(function (target) { return !one(sm, target).supported; });
+  if (unavailable) return { supported: false, reason: one(sm, unavailable).reason + (unavailable === session ? '' : ' (owned Worker)') };
+  return { supported: true, scope: 'query-runtime', externalEffects: 'unconfirmed' };
+}
+module.exports = { targets: targets, one: one, describe: describe };

package/lib/sessions.js

@@ -634,6 +634,7 @@ function createSessionManager(opts) {
       var node = hierarchy[session.localId];
       var ownedCount = ownedWorkerCountFor(session, node, owned, viewerId);
       if (ownedCount !== undefined) mapped.ownedWorkerCount = ownedCount;
+      mapped.forceTermination = ownedCount !== undefined && (!users.isMultiUser() || viewerId && session.ownerId === viewerId) ? require('./session-force-stop-support').describe(api || { sessions: sessions, defaultVendor: defaultVendor }, session) : { supported: false, reason: 'Force termination requires the session owner' };
       mapped.sessionRole = node.role;
       mapped.parentSessionId = node.parentSessionId;
       mapped.parentAvailable = node.parentAvailable;
@@ -1058,6 +1059,7 @@ function createSessionManager(opts) {
   }
 
   function doSendToSession(session, obj) {
+    if (obj.type === 'auth_required' && opts.onAuthRequired && opts.onAuthRequired(session, obj)) return;
     // Send to active clients without recording to history/disk (ephemeral data)
     if (sendEach) {
       var data = JSON.stringify(obj);
@@ -1074,12 +1076,14 @@ function createSessionManager(opts) {
   }
 
   function doSendAndRecord(session, obj, clientObj) {
+    if (obj.type === 'auth_required') { doSendToSession(session, clientObj || obj); return true; }
     // Stamp every recorded message so history replay preserves original times
     if (!obj._ts) obj._ts = Date.now();
     var outgoingObj = clientObj || obj;
     if (!outgoingObj._ts) outgoingObj._ts = obj._ts;
     session.history.push(obj);
     if (appendToSessionFile(session, obj) === false) return false;
+    require('./worker-activity').observe(session, outgoingObj);
     // Per-session out-of-band subscribers mirror mate session events into
     // a parallel UI without joining the project's
     // ws clients set). Subscribers receive the same obj that goes to ws
@@ -1394,7 +1398,7 @@ function createSessionManager(opts) {
     }).catch(function() {});
   }
 
-  return {
+  var api = {
     setSessionHydrator: function (fn) { onSessionHydrate = typeof fn === "function" ? fn : null; },
     get activeSessionId() { return activeSessionId; },
     get nextLocalId() { return nextLocalId; },
@@ -1567,6 +1571,7 @@ function createSessionManager(opts) {
     },
     permissionRequestIndex: permissionRequestIndex,
   };
+  return api;
 }
 
 module.exports = { createSessionManager };

package/lib/terminal-manager.js

@@ -163,7 +163,7 @@ function createTerminalManager(opts) {
 
   function write(id, data) {
     var session = terminals.get(id);
-    if (session && session.pty) {
+    if (session && session.pty && session.kind !== "provider-install") {
       session.lastActivityAt = Date.now(); // user input counts as activity
       session.pty.write(data);
     }

package/lib/terminal.js

@@ -43,12 +43,24 @@ function createTerminal(cwd, cols, rows, osUserInfo, opts) {
   }
 
   var args = osUserInfo ? ["-l"] : [];
+  if (opts && opts.providerInstall) {
+    var recipe = require('./yoke/vendor-registry').getVendorInfo(opts.providerInstall);
+    recipe = recipe && recipe.installRecipe;
+    var reason = require('./yoke/provider-install-recipes').eligible(recipe,osUserInfo);
+    if (reason || typeof opts.revalidateInstall !== 'function') throw new Error(reason || 'Installation authority is missing.');
+    opts.revalidateInstall();
+    shell = '/bin/bash';
+    args = ['--noprofile','--norc','-o','pipefail','-c',recipe.command];
+    spawnOpts.cwd = osUserInfo.home;
+    // Bash must not source daemon/user startup files; installers receive no keys.
+    delete termEnv.NODE_OPTIONS;
+  }
   // 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) {
+  if (opts && opts.initialInput && !opts.providerInstall) {
     try { term.write(opts.initialInput); } catch (e) {}
   }
 

package/lib/vendor-login-browser-flow.js

@@ -3,7 +3,7 @@ var createLoginBrowser = require("./vendor-login-browser").createLoginBrowser;
 function attachBrowserLogin(ctx) {
   function allowed(ws, flow) {
     var userId = ws && ws._clayUser ? String(ws._clayUser.id) : null;
-    return userId === flow.ownerId && ctx.hasTerminalPermission(ws);
+    return userId === flow.ownerId && ctx.hasTerminalPermission(ws) && (!ctx.validate || ctx.validate(ws, flow));
   }
   function prepare(ws, flow, identity) {
     if (ctx.osUsers && !identity.osUserInfo) throw new Error("OS user identity is unavailable");

package/lib/worker-activity.js

@@ -0,0 +1,26 @@
+// Live recorded output only. Reading history or projecting a snapshot never stamps activity.
+var crypto = require('crypto');
+var provenance = require('./session-provenance');
+var tools = { Bash: 'Running a command', Read: 'Reading files', Edit: 'Editing files', Write: 'Writing files',
+  Grep: 'Searching files', Glob: 'Finding files', WebSearch: 'Searching the web', WebFetch: 'Reading a web page', Task: 'Delegating work' };
+function summary(event) {
+  if (!event) return null;
+  if (event.type === 'delta' || event.type === 'assistant_message') return typeof event.text === 'string' && event.text.trim() ? 'Writing a reply' : null;
+  if (event.type === 'thinking_delta') return typeof event.text === 'string' && event.text.trim() ? 'Thinking' : null;
+  if (event.type === 'thinking_start') return 'Thinking';
+  if (event.type === 'tool_start' || event.type === 'tool_executing') return Object.prototype.hasOwnProperty.call(tools, event.name) ? tools[event.name] : 'Using a tool';
+  if (event.type === 'tool_result') return 'Tool result received';
+  return null;
+}
+function observe(session, event) {
+  if (!provenance.isWorker(session)) return;
+  var label = summary(event); if (!label) return;
+  var previous = session._workerActivity;
+  session._workerActivity = { epoch: previous ? previous.epoch : crypto.randomUUID(), sequence: previous ? previous.sequence + 1 : 1,
+    queryGeneration: Number(session._sdkQueryGeneration || 0), timestamp: Date.now(), summary: label };
+}
+function project(session) {
+  var activity = session._workerActivity;
+  return activity && activity.queryGeneration === Number(session._sdkQueryGeneration || 0) ? Object.assign({}, activity) : null;
+}
+module.exports = { observe: observe, project: project, summary: summary };

package/lib/worker-message-previews.js

@@ -29,16 +29,21 @@ function attach(ctx) {
       function send(live) {
         var current = ctx.resolve(ws, target);
         if (subscriptions.get(ws) !== state || ws.readyState !== 1 || !current || current.driver !== pair.driver || current.worker !== pair.worker) { if (entry.release) entry.release(); return; }
-        var preview = latest(pair.worker.history || []); if (!preview) return;
-        preview.vendor = pair.worker.vendor || null;
-        if (entry.last === JSON.stringify(preview)) return;
-        entry.last = JSON.stringify(preview);
+        var preview = latest(pair.worker.history || []), activity = require('./worker-activity').project(pair.worker);
+        if (preview) preview.vendor = pair.worker.vendor || null;
+        var signature = JSON.stringify([preview, activity, pair.worker.isProcessing === true]);
+        if (entry.last === signature) return;
+        entry.last = signature;
         ctx.send(ws, { type: 'split_worker_message_preview', requestId: msg.requestId, parentSessionOriginId: target.parentSessionOriginId,
-          workerSessionOriginId: target.workerSessionOriginId, generation: target.generation, live: live, preview: preview });
+          workerSessionOriginId: target.workerSessionOriginId, generation: target.generation, live: live, preview: preview, activity: activity, isProcessing: pair.worker.isProcessing === true, observedAt: Date.now(), vendor: pair.worker.vendor || null });
       }
       entry.release = ctx.sm.subscribeSession(pair.worker.localId, function (event) {
-        if (!event || ['delta', 'assistant_message'].indexOf(event.type) < 0 || entry.timer) return;
-        entry.timer = setTimeout(function () { entry.timer = null; send(true); }, 60);
+        if (!event) return;
+        var genuine = !!require('./worker-activity').summary(event);
+        if (!genuine && event.type !== 'done' && event.type !== 'error') return;
+        entry.pendingLive = entry.pendingLive || genuine;
+        if (entry.timer) return;
+        entry.timer = setTimeout(function () { entry.timer = null; var live = !!entry.pendingLive; entry.pendingLive = false; send(live); }, 60);
       });
       state.entries.push(entry); send(false);
     });

package/lib/worktree-branch.js

@@ -0,0 +1,57 @@
+// Optional local-ref removal, bound to a reviewed tip and retained parent HEAD.
+var identities = require('./worktree-identity');
+var git = require('./git-cli').runGitSync;
+var refTransaction = require('./worktree-ref-transaction');
+function run(snapshot, args, os, options) { return git(snapshot.parent.path, args, options || null, os).trim(); }
+function symbolic(snapshot, ref, os) {
+  try { return run(snapshot, ['symbolic-ref', '--quiet', ref], os); }
+  catch (error) { if (error.status === 1) return null; throw error; }
+}
+function inputFor(snapshot, branch, os, deleting) {
+  var input = 'start\noption no-deref\n';
+  // Git cannot verify HEAD's symref and its referent in one transaction.
+  if (symbolic(snapshot, 'HEAD', os) !== branch.parentRef) throw new Error('The retained parent HEAD/ref changed.');
+  input += 'verify ' + (branch.parentRef || 'HEAD') + ' ' + branch.parentHead + '\n';
+  input += 'option no-deref\n' + (deleting ? 'delete ' : 'verify ') + branch.ref + ' ' + branch.tip + '\nprepare\n';
+  // No dereferencing: a replacement symbolic ref must never delete its target.
+  return input;
+}
+function inspect(snapshot, os, removed, locked) {
+  if (!/^refs\/heads\//.test(snapshot.branch)) throw new Error('Detached HEAD has no local branch to delete.');
+  if (JSON.stringify(identities.identity(snapshot.parent.path, true)) !== JSON.stringify(snapshot.parent) ||
+      JSON.stringify(identities.identity(snapshot.common.path, true)) !== JSON.stringify(snapshot.common)) throw new Error('The retained repository identity changed.');
+  var ref = snapshot.branch;
+  run(snapshot, ['check-ref-format', ref], os);
+  if (symbolic(snapshot, ref, os)) throw new Error('The local branch was replaced by a symbolic ref.');
+  var tip = run(snapshot, ['show-ref', '--verify', '--hash', ref], os);
+  var parentRef = symbolic(snapshot, 'HEAD', os);
+  var parentHead = run(snapshot, ['rev-parse', '--verify', 'HEAD'], os);
+  if (parentRef === ref) throw new Error('The local branch is the current parent branch.');
+  if (parentRef && symbolic(snapshot, parentRef, os)) throw new Error('The retained parent branch is a symbolic ref.');
+  var blocks = run(snapshot, ['worktree', 'list', '--porcelain', '-z'], os).split('\0\0').filter(Boolean);
+  blocks.forEach(function (block) {
+    var fields = block.split('\0');
+    if (fields.indexOf('branch ' + ref) >= 0 && (removed || fields[0] !== 'worktree ' + snapshot.target.path)) throw new Error('The local branch is checked out by another worktree.');
+  });
+  try { run(snapshot, ['merge-base', '--is-ancestor', tip, parentHead], os); }
+  catch (error) { throw new Error('The local branch is not merged into the retained parent HEAD. Keep the branch or merge it first.'); }
+  var branch = { ref: ref, tip: tip, parentRef: parentRef, parentHead: parentHead };
+  // Probe the fixed transaction syntax before runtime or directory effects.
+  if (!locked) run(snapshot, ['update-ref', '--stdin'], os, { input: inputFor(snapshot, branch, os, false) + 'commit\n' });
+  return branch;
+}
+function exact(snapshot, branch, os, removed, locked) {
+  if (JSON.stringify(inspect(snapshot, os, removed, locked)) !== JSON.stringify(branch)) throw new Error('The reviewed local branch tip or retained parent HEAD/ref changed. Review again.');
+}
+async function remove(snapshot, branch, os, validate) {
+  exact(snapshot, branch, os, true);
+  await refTransaction.remove(snapshot.parent.path, inputFor(snapshot, branch, os, true), os, function () {
+    if (validate) validate();
+    // CAS alone permits same-tip symbolic replacements. Inspect under the prepared locks.
+    exact(snapshot, branch, os, true, true);
+  });
+  var refs = run(snapshot, ['for-each-ref', '--format=%(refname)', branch.ref], os).split('\n');
+  if (refs.indexOf(branch.ref) >= 0) throw new Error('Local branch absence was not confirmed. Inspect it before recovery.');
+  return true;
+}
+module.exports = { inspect: inspect, exact: exact, remove: remove };

package/lib/worktree-identity.js

@@ -0,0 +1,39 @@
+// Exact Git and filesystem identities for reviewed linked-worktree removal.
+var fs = require('fs');
+var path = require('path');
+var git = require('./git-cli').runGitSync;
+function identity(value, directory) {
+  var resolved = path.resolve(value), real = fs.realpathSync(resolved), stat = fs.lstatSync(resolved);
+  if (resolved !== real || stat.isSymbolicLink() || (directory && !stat.isDirectory())) throw new Error('Worktree paths must be real directories without symlink aliases.');
+  return { path: real, dev: stat.dev, ino: stat.ino, uid: stat.uid };
+}
+function inspect(parentPath, targetPath, osUserInfo, clean) {
+  var parent = identity(parentPath, true), target = identity(targetPath, true);
+  function run(root, args) { return git(root, args, null, osUserInfo).trim(); }
+  if (parent.path === target.path) throw new Error('The main repository cannot be deleted as a worktree.');
+  var common = identity(path.resolve(parent.path, run(parent.path, ['rev-parse', '--git-common-dir'])), true);
+  var parentGit = identity(run(parent.path, ['rev-parse', '--absolute-git-dir']), true);
+  if (JSON.stringify(common) !== JSON.stringify(parentGit)) throw new Error('Choose the main repository as the parent.');
+  if (run(parent.path, ['rev-parse', '--show-toplevel']) !== parent.path || run(target.path, ['rev-parse', '--show-toplevel']) !== target.path) throw new Error('The registered path is not an exact repository root.');
+  var targetCommon = identity(path.resolve(target.path, run(target.path, ['rev-parse', '--git-common-dir'])), true);
+  var targetGit = identity(run(target.path, ['rev-parse', '--absolute-git-dir']), true);
+  if (JSON.stringify(common) !== JSON.stringify(targetCommon) || targetGit.path === common.path || path.dirname(targetGit.path) !== path.join(common.path, 'worktrees')) throw new Error('The target is not a linked worktree of this parent.');
+  var marker = identity(path.join(target.path, '.git'), false);
+  if (!fs.lstatSync(marker.path).isFile() || fs.readFileSync(marker.path, 'utf8').trim() !== 'gitdir: ' + targetGit.path) throw new Error('Worktree Git binding is invalid.');
+  if (fs.readFileSync(path.join(targetGit.path, 'gitdir'), 'utf8').trim() !== marker.path) throw new Error('Worktree Git backlink changed.');
+  var records = git(parent.path, ['worktree', 'list', '--porcelain', '-z'], null, osUserInfo).split('\0\0').filter(Boolean);
+  var matches = records.filter(function (block) { return block.split('\0')[0] === 'worktree ' + target.path; });
+  if (matches.length !== 1) throw new Error('Exact Git worktree membership is unavailable.');
+  var fields = matches[0].split('\0');
+  if (fields.some(function (field) { return /^prunable(?: |$)|^bare$/.test(field) || clean && /^locked(?: |$)/.test(field); })) throw new Error('The worktree is locked, prunable or unavailable.');
+  if (clean && git(target.path, ['status', '--porcelain=v1', '-z', '--untracked-files=all', '--ignored=matching'], null, osUserInfo)) throw new Error('Worktree contains changed, untracked or ignored files. Save or remove them before deleting.');
+  return { parent: parent, target: target, common: common, git: targetGit, marker: marker, membership: matches[0], branch: (fields.find(function (field) { return field.indexOf('branch ') === 0; }) || 'branch (detached)').slice(7) };
+}
+function remove(snapshot, osUserInfo) {
+  var current = inspect(snapshot.parent.path, snapshot.target.path, osUserInfo, true);
+  if (JSON.stringify(current) !== JSON.stringify(snapshot)) throw new Error('Worktree identity changed after review.');
+  git(snapshot.parent.path, ['worktree', 'remove', '--', snapshot.target.path], { timeout: 15000 }, osUserInfo);
+  if (fs.existsSync(snapshot.target.path) || fs.existsSync(snapshot.git.path)) throw new Error('Git returned without confirming removal. Inspect the worktree before another attempt.');
+  return true;
+}
+module.exports = { identity: identity, inspect: inspect, remove: remove };

package/lib/worktree-preferences.js

@@ -0,0 +1,25 @@
+// Worktree display preferences are parent-owned and bound to the Git change set.
+function entry(config, parentSlug, slug) {
+  var parent = (config.projects || []).find(function (item) { return item.slug === parentSlug; });
+  return parent && parent.worktreePreferences && parent.worktreePreferences[slug];
+}
+function matches(record, targetPath, changeSetId) {
+  return !!record && record.path === targetPath && record.changeSetId === changeSetId;
+}
+function icon(config, parentSlug, slug, targetPath, changeSetId) {
+  var record = entry(config, parentSlug, slug);
+  return matches(record, targetPath, changeSetId) ? record.icon || null : null;
+}
+function blocked(config, parentSlug, slug, targetPath, changeSetId) {
+  var record = entry(config, parentSlug, slug);
+  return matches(record, targetPath, changeSetId) && (record.excluded || record.lifecycleState);
+}
+// A durable shutdown reservation fences parent mutations even if a display record is replaced.
+function pendingRemoval(config, parentSlug) {
+  var parent = (config.projects || []).find(function (item) { return item.slug === parentSlug; });
+  return !!parent && Object.values(config.projectLifecycleOperations || {}).some(function (operation) {
+    return operation.phase === 'pending' && operation.action === 'remove' &&
+      operation.projectKnowledgeId === parent.projectKnowledgeId && operation.slug.indexOf(parentSlug + '--') === 0;
+  });
+}
+module.exports = { pendingRemoval: pendingRemoval, entry: entry, matches: matches, icon: icon, blocked: blocked };