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

package/lib/personal-provider-settings.js

@@ -0,0 +1,94 @@
+// Personal provider discovery and sign-in authority. No credential files are read.
+var crypto = require('crypto');
+var os = require('os');
+var registry = require('./yoke/vendor-registry');
+var protocol = require('./yoke/login-protocol');
+var installRecipes = require('./yoke/provider-install-recipes');
+var LIFETIME = 5 * 60 * 1000;
+function attach(ctx) {
+  var receipts = new WeakMap();
+  function actor(ws) {
+    if (!ws || ws.readyState !== 1 || ws._clayPaneActivation || ws._clayPane || ctx.clients && !ctx.clients.has(ws)) throw new Error('Open Personal settings in the connected workspace.');
+    if (ctx.requestAccess && !ctx.requestAccess.canAccessProject(ws, ctx.slug)) throw new Error('Project access changed. Reopen Personal settings.');
+    var users = ctx.usersModule;
+    var user = ws._clayUser;
+    if (users && users.isMultiUser() && (!user || !users.findUserById(user.id))) throw new Error('Sign in again to manage providers.');
+    if (user && users && users.findUserById) user = users.findUserById(user.id);
+    if (ws._clayUser && !user) throw new Error('This account is no longer available.');
+    if (ctx.osUsers && (!user || !user.linuxUser)) throw new Error('Your mapped OS identity is unavailable.');
+    var info = ctx.osUsers ? (ctx.resolveOsUserInfo ? ctx.resolveOsUserInfo(user.linuxUser) : ctx.getOsUserInfoForWs({ _clayUser: user })) : null;
+    if (ctx.osUsers && (!info || !info.user || !info.home)) throw new Error('Your mapped OS identity is unavailable. Ask the server administrator to check the mapping.');
+    return { accountName:user ? user.displayName || user.username || String(user.id) : 'Personal account', role: user ? user.role : 'admin', runtime: info || {user:os.userInfo().username,uid:os.userInfo().uid,gid:os.userInfo().gid,home:os.homedir()}, owner: user ? String(user.id) : 'default', identity: { linuxUser: info ? info.user : null, osUserInfo: info } };
+  }
+  function signature() {
+    return JSON.stringify(Object.keys(registry.VENDOR_REGISTRY).map(function (id) {
+      var info = registry.getVendorInfo(id);
+      return [id, info.loginCommand, info.terminalLoginCommand, info.browserLoginCommand, info.oauthHosts, info.osUserIsolation, info.installRecipe];
+    }));
+  }
+  function current(ws, receipt) {
+    if (!receipt) return false;
+    try { return Object.keys(receipt.registry).length === Object.keys(registry.VENDOR_REGISTRY).length && Object.keys(receipt.registry).every(function (id) { return receipt.registry[id] === registry.getVendorInfo(id) && receipt.resolvers[id] === registry.getVendorInfo(id).resolveExecutable; }) && receipt.commands === signature() && receipts.get(ws) === receipt && receipt.expires > Date.now() && JSON.stringify(actor(ws)) === receipt.actor; }
+    catch (error) { return false; }
+  }
+  function catalog(ws, requestId) {
+    var target = actor(ws);
+    var receipt = { registry: Object.assign({}, registry.VENDOR_REGISTRY), resolvers: {}, commands: signature(), id: crypto.randomUUID(), actor: JSON.stringify(target), expires: Date.now() + LIFETIME };
+    Object.keys(receipt.registry).forEach(function (id) { receipt.resolvers[id] = receipt.registry[id].resolveExecutable; });
+    receipts.set(ws, receipt);
+    var info = target.identity.osUserInfo;
+    var scope = info ? 'Mapped OS account ' + info.user + ' · HOME ' + info.home :
+      'Shared server OS account ' + os.userInfo().username + ' · HOME ' + os.homedir() + '. Provider credentials are shared by processes using this HOME; they are not isolated by Clay Studio account.';
+    var rows = Object.keys(registry.VENDOR_REGISTRY).map(function (id) {
+      var provider = registry.getVendorInfo(id);
+      var supported = !ctx.osUsers || provider.osUserIsolation === true;
+      var installed = null, reason = '';
+      if (!supported) reason = 'This provider does not support mapped OS accounts in Clay Studio.';
+      else {
+        try { installed = !!provider.resolveExecutable({ user: target.identity.linuxUser }); }
+        catch (error) { reason = 'Installation discovery failed. Check the server setup, then refresh status.'; }
+      }
+      var installReason = installRecipes.eligible(provider.installRecipe, target.runtime);
+      if (!ctx.osUsers && target.role !== 'admin') installReason = 'Only the server administrator can install into the shared runtime HOME.';
+      var login = false;
+      try { protocol.command(id, false); login = true; } catch (error) {}
+      var permitted = !ctx.requestAccess || ctx.requestAccess.hasPermission(ws, 'terminal');
+      var canInstall = supported && installed === false && permitted && !installReason;
+      return { id: id, name: provider.displayName, icon: provider.avatar, setupUrl: provider.setupUrl, installed: installed,
+        authentication: 'unknown', tested: false, browser: !!provider.browserLoginCommand,
+        canSignIn: supported && installed === true && login && permitted,
+        canInstall: canInstall, installReason: installReason,
+        reason: reason || (!permitted ? 'Terminal permission is required for provider installation and sign-in.' : ''),
+        setup: canInstall ? 'Review the official installer for the runtime account shown above. Installation does not sign in or run a task.' : (installed === null ? (reason || 'Installation status is unknown. Refresh status before reviewing an installation.') : installReason || 'Review the registered installer before running it.') + ' Ask the server operator to install ' + provider.binaryName + ' for the runtime OS account shown above, using the provider’s official setup instructions. Then refresh status.',
+        loginCommand: supported && permitted && login ? protocol.command(id, false) : null };
+    });
+    if (!current(ws, receipt)) throw new Error('Provider account context changed. Refresh status.');
+    return { type: 'vendor_login_catalog', requestId: requestId, revision: receipt.id, owner: target.owner, accountName:target.accountName, runtime:Object.assign({shared:!info},target.runtime), scope: scope, providers: rows };
+  }
+  function resolve(ws, msg) {
+    var receipt = receipts.get(ws), info = registry.getVendorInfo(msg.vendor);
+    if (!current(ws, receipt) || msg.personalRequestId !== receipt.id || msg.sessionId || msg.workerAuthRequestId ||
+        !info || ctx.osUsers && info.osUserIsolation !== true || ctx.requestAccess && !ctx.requestAccess.hasPermission(ws, 'terminal')) {
+      throw new Error('Personal provider context expired or is no longer permitted. Refresh status before signing in.');
+    }
+    var target = actor(ws);
+    if (!info.resolveExecutable({user:target.identity.linuxUser})) throw new Error('Install this provider for the runtime OS account, then refresh status.');
+    return { identity: target.identity, validate: function (peer) {
+      return peer === ws && current(ws, receipt) && (!ctx.requestAccess || ctx.requestAccess.hasPermission(ws, 'terminal'));
+    } };
+  }
+  function resolveInstall(ws, msg) {
+    var receipt = receipts.get(ws), provider = registry.getVendorInfo(msg.vendor);
+    if (!current(ws, receipt) || msg.personalRequestId !== receipt.id || msg.sessionId || msg.workerAuthRequestId || !provider || ctx.osUsers && provider.osUserIsolation !== true || ctx.requestAccess && !ctx.requestAccess.hasPermission(ws, 'terminal')) throw new Error('Installation context expired or permission changed. Refresh status.');
+    var target = actor(ws), recipe = provider.installRecipe;
+    var reason = installRecipes.eligible(recipe, target.runtime);
+    if (!ctx.osUsers && target.role !== 'admin') reason = 'Only the server administrator can install into the shared runtime HOME.';
+    if (reason) throw new Error(reason);
+    if (provider.resolveExecutable({user:target.identity.linuxUser})) throw new Error('This provider is already installed. Refresh status.');
+    return { recipe:recipe, runtime:target.runtime, identity:target.identity, validate:function () {
+      try { return current(ws, receipt) && provider === registry.getVendorInfo(msg.vendor) && recipe === provider.installRecipe && (!ctx.requestAccess || ctx.requestAccess.hasPermission(ws,'terminal')) && !installRecipes.eligible(recipe,actor(ws).runtime); } catch(error) { return false; }
+    } };
+  }
+  return { catalog: catalog, resolve: resolve, resolveInstall:resolveInstall, release: function (ws) { receipts.delete(ws); } };
+}
+module.exports = { attach: attach };

package/lib/project-logs-service.js

@@ -375,9 +375,9 @@ function attachProjectLogsService(ctx) {
     };
   }
 
-  function setContextState(projectSlug, status) {
+  function setContextState(projectSlug, status, captured) {
     var project = projectFor(projectSlug);
-    var projectStatus = project && project.getStatus();
+    var projectStatus = captured || project && project.getStatus();
     if (!projectStatus || !projectStatus.isWorktree || !projectStatus.changeSetId) return false;
     return storeForStatus(projectStatus).setContextState(recordContext(projectStatus), status);
   }

package/lib/project-pair-task-control.js

@@ -267,7 +267,7 @@ function attachPairTaskControl(ctx) {
     };
   }
   function drain(caller, worker) {
-    if (ctx.turnControl.blockedReason(caller) || worker.isProcessing || worker._queryStarting || current(worker)) return false;
+    if (ctx.turnControl.blockedReason(caller) || worker._workerAuthRequired || worker.isProcessing || worker._queryStarting || current(worker)) return false;
     var queue = queueFor(worker);
     var next = null;
     for (var i = 0; i < queue.length; i++) {

package/lib/project-pending-message-queue.js

@@ -250,7 +250,7 @@ function createPendingMessageQueue(opts) {
   }
   function consumeOne(session, dispatch) {
     var foreground = require('./sdk-foreground-admission');
-    if (loadError || !session || session._pendingMessageClaimId || isPaused(session) || session._pendingMessageDrainPaused || session.taskStopRequested || session._queryStarting || (session._awaitingTurnResult || session.isProcessing) && !foreground.available(session)) return null;
+    if (loadError || !session || session._workerAuthRequired || session._pendingMessageClaimId || isPaused(session) || session._pendingMessageDrainPaused || session.taskStopRequested || session._queryStarting || (session._awaitingTurnResult || session.isProcessing) && !foreground.available(session)) return null;
     if (session.rateLimitResetsAt && session.rateLimitResetsAt > Date.now()) return null;
     for (var i = 0; i < data.items.length; i++) {
       var item = data.items[i];
@@ -325,7 +325,11 @@ function createPendingMessageQueue(opts) {
     }
     return null;
   }
-  return { admit: admit, upsertScheduled: upsertScheduled, releaseScheduled: releaseScheduled, cancelScheduled: cancelScheduled, edit: edit, cancel: cancel, reorder: reorder, pause: pause, resume: resume, consumeOne: consumeOne, hydrate: hydrate, inspect: inspect, hasActive: hasActive, isClaimed: isClaimed, isPaused: isPaused, list: visible, getRevision: function () { return data.revision; }, getLoadError: function () { return loadError; }, filePath: filePath };
+  function retireClaim(session) {
+    if (!session._pendingMessageClaimId) return true;
+    return finishClaim(session, session._pendingMessageClaimId, false, "Force stopped during delivery. Inspect the transcript before sending this message again.");
+  }
+  return { retireClaim: retireClaim, admit: admit, upsertScheduled: upsertScheduled, releaseScheduled: releaseScheduled, cancelScheduled: cancelScheduled, edit: edit, cancel: cancel, reorder: reorder, pause: pause, resume: resume, consumeOne: consumeOne, hydrate: hydrate, inspect: inspect, hasActive: hasActive, isClaimed: isClaimed, isPaused: isPaused, list: visible, getRevision: function () { return data.revision; }, getLoadError: function () { return loadError; }, filePath: filePath };
 }
 
 module.exports = { createPendingMessageQueue: createPendingMessageQueue };

package/lib/project-product-control.js

@@ -48,6 +48,7 @@ function attachProjectProductControl(ctx) {
     if (action === "vendor_new_session") return ctx.vendor.newSession(session, value, current);
     if (action === "runtime") return ctx.runtime.change(session, value, current);
     if (action === "rename") return ctx.actions.rename(session, value);
+    if (action === "force_stop") return ctx.actions.forceStop(session, user);
     if (action === "stop") return ctx.actions.stop(session, user);
     if (session.taskStopRequested && action !== "delete") throw new Error("Target was stopped; explicit Driver resumption is required.");
     if (action === "model") {

package/lib/project-session-actions.js

@@ -26,19 +26,62 @@ function attachSessionActions(ctx) {
     }
     return { title: title };
   }
-  function stop(session, actor) {
+  function stop(session, actor, retiring) {
     exact(session);
     session._humanStopRevision = (session._humanStopRevision || 0) + 1;
     if (ctx.autonomousRun && session.autonomousRun) ctx.autonomousRun.finish(session, "stopped", "Stopped by the user.");
     if (typeof ctx.sdk.cancelResponseRecovery === "function") ctx.sdk.cancelResponseRecovery(session);
     session._pendingMessageDrainPaused = true;
     if (ctx.onPendingQueuePause) ctx.onPendingQueuePause(session, actor || null);
-    if (!session.isProcessing && !session._queryStarting && !session._responseRecoveryStopPending) return { status: "completed", queuePaused: true };
     if (ctx.onHumanPairStop) ctx.onHumanPairStop(session);
+    if (!session.isProcessing && !session._queryStarting && !session._responseRecoveryStopPending && !session._awaitingTurnResult && !session.queryInstance) return { status: "completed", queuePaused: true };
     session.taskStopRequested = true;
+    if (retiring) return { status: "queued", queuePaused: true };
     if (session.abortController) session.abortController.abort();
+    else if (session.queryInstance && typeof session.queryInstance.abort === "function") session.queryInstance.abort();
     return { status: "queued", queuePaused: true, detail: "Stop requested; runtime completion is still pending." };
   }
+  async function forceStopOne(session, actor) {
+    exact(session);
+    var state = require('./session-force-stop-support').one(sm, session);
+    if (!state.supported) throw new Error(state.reason);
+    stop(session, actor, true);
+    var expectedRevision = (session._forceStopRevision || 0) + 1;
+    var expectedGeneration = Number(session._sdkQueryGeneration || 0) + 1, owner = session.ownerId, vendor = session.vendor;
+    var result = await ctx.sdk.forceStopSession(session);
+    if (sm.sessions.get(session.localId) !== session || session._forceStopRevision !== expectedRevision || session._sdkQueryGeneration !== expectedGeneration || session.ownerId !== owner || session.vendor !== vendor || session.queryInstance || session._queryStarting) return Object.assign({}, result, { status: 'failed', detail: 'Session runtime changed during termination.' });
+    if (ctx.usersModule && ctx.usersModule.isMultiUser() && (!actor || session.ownerId !== actor.id || !ctx.usersModule.canAccessSession(actor.id, session, ctx.getProjectAccess ? ctx.getProjectAccess() : {}))) return Object.assign({}, result, { status: 'failed', detail: 'Session access changed during termination.' });
+    if (ctx.onPendingQueueRetire && ctx.onPendingQueueRetire(session) === false) {
+      result.queueRecovery = "failed";
+      sm.sendAndRecord(session, { type: "error", text: "The connection was force stopped, but the pending delivery record could not be updated. Check queue storage before resuming." });
+    }
+    return result;
+  }
+  async function forceStop(session, actor) {
+    exact(session);
+    var support = require('./session-force-stop-support');
+    var targets = support.targets(sm, session), workers = targets.slice(1);
+    targets.forEach(function (target) {
+      exact(target);
+      if ((target.ownerId || null) !== (session.ownerId || null) || ctx.usersModule && ctx.usersModule.isMultiUser() &&
+          (!actor || target.ownerId !== actor.id || !ctx.usersModule.canAccessSession(actor.id, target, ctx.getProjectAccess ? ctx.getProjectAccess() : {}))) throw new Error("One of the session's Workers is no longer accessible.");
+    });
+    targets.forEach(function (target) {
+      var state = support.one(sm, target);
+      if (!state.supported) throw new Error(state.reason + (target === session ? '' : ' (owned Worker)'));
+    });
+    // Start all exact-query effects synchronously after the complete preflight.
+    var results = await Promise.all(targets.map(async function (target) {
+      try { return Object.assign({ sessionId: target.localId }, await forceStopOne(target, actor)); }
+      catch (error) { return { sessionId: target.localId, status: "failed", error: error.message || String(error) }; }
+    }));
+    var result = Object.assign({}, results[0], { workerCount: workers.length, sessions: results });
+    if (results.some(function (item) { return item.status === "failed" || item.queueRecovery === "failed"; })) {
+      result.status = "failed"; result.outcome = "partial";
+      if (sm.sendAndRecord) sm.sendAndRecord(session, { type: "error", text: "Some session or Worker force-stop actions failed. Inspect their state before continuing." });
+    }
+    return result;
+  }
   async function effort(session, value, revalidate) {
     exact(session);
     var vendor = session.vendor || sm.defaultVendor || "claude";
@@ -61,6 +104,6 @@ function attachSessionActions(ctx) {
     sm.sendToSession(session, Object.assign({ type: "config_state", sessionId: session.localId, vendor: session.vendor || sm.defaultVendor || "claude", mode: state.requestedPermissionMode, permissionRequestId: requestId || null, effort: session.effort || sm.currentEffort || "medium", betas: sm.currentBetas || [] }, state));
     return state;
   }
-  return { rename: rename, stop: stop, effort: effort, permission: permission };
+  return { rename: rename, stop: stop, forceStop: forceStop, effort: effort, permission: permission };
 }
 module.exports = { attachSessionActions: attachSessionActions };

package/lib/project-session-pair.js

@@ -227,6 +227,8 @@ function attachSessionPair(ctx) {
       broadcastDelegation(resolved.group, caller, partner, true);
       var sdk = ctx.getSdk();
       if (!sdk) throw new Error("SDK bridge is not ready");
+      partner._workerAuthRequired = false;
+      if (partner._forceStopRevision && !partner.isProcessing && !partner._queryStarting && !partner.queryInstance) partner.taskStopRequested = false;
       if (!partner.isProcessing) {
         partner.isProcessing = true;
         ctx.onProcessingChanged();

package/lib/project-sessions.js

@@ -1112,7 +1112,7 @@ function attachSessions(ctx) {
       return true;
     }
 
-    if (msg.type === "stop") {
+    if (msg.type === "stop" || msg.type === "force_stop") {
       var session = getSessionForWs(ws);
       if (msg.sessionId != null || msg.sessionOriginId != null) {
         session = sm.sessions.get(msg.sessionId);
@@ -1120,7 +1120,15 @@ function attachSessions(ctx) {
             !usersModule.isMultiUser() && session.ownerId ||
             usersModule.isMultiUser() && (!ws._clayUser || !usersModule.canAccessSession(ws._clayUser.id, session, getProjectAccess()))) return true;
       }
-      stopSession(session, ws && ws._clayUser);
+      if (!session) return true;
+      if (msg.workerGeneration != null || msg.parentSessionOriginId != null) {
+        var lineage = session.sessionProvenance;
+        if (!lineage || lineage.kind !== "worker" || lineage.generation !== msg.workerGeneration || lineage.parentSessionOriginId !== msg.parentSessionOriginId) return true;
+      }
+      if (msg.type === "force_stop") sessionActions.forceStop(session, ws && ws._clayUser).catch(function (error) {
+        sm.sendToSession(session, { type: 'error', text: error.message || String(error) });
+      });
+      else stopSession(session, ws && ws._clayUser);
       return true;
     }
 
@@ -1917,7 +1925,7 @@ function attachSessions(ctx) {
         return true;
       }
       if (typeof opts.onSetProjectIcon === "function") {
-        var iconResult = opts.onSetProjectIcon(msg.slug, msg.icon || null);
+        var iconResult = opts.onSetProjectIcon(msg.slug, msg.icon || null, ws._clayUser ? ws._clayUser.id : null);
         sendTo(ws, { type: "set_project_icon_result", ok: iconResult.ok, slug: msg.slug, error: iconResult.error, requestId: iconRequestId });
       } else {
         sendTo(ws, { type: "set_project_icon_result", ok: false, error: "Not supported", requestId: iconRequestId });

package/lib/project-user-message.js

@@ -141,6 +141,7 @@ function attachUserMessage(ctx) {
         queueResult = pendingMessageQueue.resume(queueSession, queueActor, msg.revision, msg.sessionId);
         if (queueResult.ok && !queueResult.paused) {
           queueSession._pendingMessageDrainPaused = false;
+          if (queueSession._forceStopRevision && !queueSession.isProcessing && !queueSession._queryStarting && !queueSession.queryInstance) queueSession.taskStopRequested = false;
           setImmediate(function () { consumePendingMessage(queueSession); });
         }
       }
@@ -505,7 +506,10 @@ function attachUserMessage(ctx) {
       }
       return true;
     }
-    if (!pendingInternal) session._pendingMessageDrainPaused = false;
+    if (!pendingInternal) {
+      session._pendingMessageDrainPaused = false;
+      if (session._forceStopRevision && !session.isProcessing && !session._queryStarting && !session.queryInstance) session.taskStopRequested = false;
+    }
     if (msg.autonomousRunToken) {
       if (!ctx.autonomousRun || !ctx.autonomousRun.consume(session, msg)) {
         sendTo(ws, { type: "error", text: "This Until complete submission is stale or no longer armed." });

package/lib/project-vendor-login.js

@@ -1,24 +1,4 @@
-// Vendor login flow coordinator.
-//
-// Owns the "the vendor CLI is not logged in" recovery path end to end so the
-// client never has to guess. One login terminal per vendor per requester is the
-// single source of truth: repeated auth_required events (other sessions, split
-// panes, a burst of 401 retries) re-use that record instead of spawning more
-// terminals.
-//
-// Lifecycle:
-//   vendor_login_start  -> create (or re-use) a PTY running the vendor login
-//                          command, reply with vendor_login_ready
-//   PTY output/exit     -> detect a successful login, restart the vendor's
-//                          YOKE adapter so it re-reads the credential file,
-//                          send auth_refreshed, close the terminal and browser
-//   vendor_login_cancel -> user dismissed the flow; kill the terminal
-//
-// The adapter restart is the actual bug fix: a Codex app-server is a long-lived
-// child process that reads ~/.codex/auth.json once at spawn, so without a
-// restart every query after a successful login keeps hitting 401 and re-arms
-// auth_required forever.
-
+// One requester-bound provider sign-in flow; auth refresh never replays a task.
 var vendorRegistry = require("./yoke/vendor-registry");
 var yoke = require("./yoke");
 
@@ -41,6 +21,8 @@ var looksLikeLoginSuccess = loginProtocol.successful;
  *   refreshVendorAuthEverywhere
  */
 function attachVendorLogin(ctx) {
+  var personal = require('./personal-provider-settings').attach(ctx);
+  var installation = require('./personal-provider-install').attach(ctx,personal);
   var slug = ctx.slug;
   var osUsers = ctx.osUsers;
 
@@ -61,12 +43,14 @@ function attachVendorLogin(ctx) {
   // Requester + vendor -> flow. Credentials and sign-in views stay user-bound.
   var _flows = Object.create(null);
   function flowKey(ws, vendor) {
-    return JSON.stringify([ws && ws._clayUser ? String(ws._clayUser.id) : null, vendor]);
+    var info = osUsers && getOsUserInfoForWs ? getOsUserInfoForWs(ws) : null;
+    return JSON.stringify([ws && ws._clayUser ? String(ws._clayUser.id) : null, vendor, info]);
   }
   var browserLogin = require("./vendor-login-browser-flow").attachBrowserLogin({
     osUsers: osUsers, sendTo: sendTo, hasTerminalPermission: hasTerminalPermission,
     createLoginBrowser: ctx.createLoginBrowser,
     flowKey: flowKey,
+    validate: function (ws, flow) { return !flow.validate || flow.validate(flow.requester) && flowKey(ws, flow.vendor) === flow.key; },
     cancel: function (vendor) { closeFlowTerminal(discardFlow(vendor)); broadcastState(); },
   });
 
@@ -82,13 +66,15 @@ function attachVendorLogin(ctx) {
     var vendors = Object.keys(_flows);
     for (var i = 0; i < vendors.length; i++) {
       var flow = _flows[vendors[i]];
-      if (ws && flowKey(ws, flow.vendor) !== vendors[i]) continue;
+      if (ws && (flowKey(ws, flow.vendor) !== vendors[i] || flow.validate && !flow.validate(flow.requester))) continue;
       result.push({
         vendor: flow.vendor,
         terminalId: flow.terminalId,
         startedAt: flow.startedAt,
         completed: !!flow.completed,
         browserId: flow.browser ? flow.browser.id : null,
+        workerAuthRequestId: flow.workerAuthRequestId,
+        personalRequestId: flow.personalRequestId,
       });
     }
     return result;
@@ -150,6 +136,8 @@ function attachVendorLogin(ctx) {
     delete _flows[vendor];
     if (flow.browser) flow.browser.close();
     if (flow.expiryTimer) clearTimeout(flow.expiryTimer);
+    if (flow.validationTimer) clearInterval(flow.validationTimer);
+    if (flow.onClose && flow.requester.removeListener) flow.requester.removeListener('close', flow.onClose);
     if (flow.closeTimer) {
       clearTimeout(flow.closeTimer);
       flow.closeTimer = null;
@@ -201,6 +189,7 @@ function attachVendorLogin(ctx) {
   function finishFlow(vendor, succeeded) {
     var flow = _flows[vendor];
     if (!flow || flow.finishing) return;
+    if (flow.validate && !flow.validate(flow.requester)) { closeFlowTerminal(discardFlow(vendor)); broadcastState(); return; }
     flow.finishing = true;
     flow.completed = !!succeeded;
 
@@ -210,26 +199,36 @@ function attachVendorLogin(ctx) {
     if (succeeded) yoke.invalidateAuthCache();
     var refresh = Promise.resolve(false);
     if (succeeded) {
-      refresh = typeof refreshVendorAuthEverywhere === "function"
-        ? refreshVendorAuthEverywhere(flow.vendor, flow.linuxUser || null)
-        : refreshVendorAuth(flow.vendor, flow.linuxUser || null);
+      refresh = Promise.resolve().then(function () {
+        if (_flows[vendor] !== flow || flow.validate && !flow.validate(flow.requester)) return false;
+        return typeof refreshVendorAuthEverywhere === "function"
+          ? refreshVendorAuthEverywhere(flow.vendor, flow.linuxUser || null)
+          : refreshVendorAuth(flow.vendor, flow.linuxUser || null);
+      });
     }
     refresh.then(function (restarted) {
       if (_flows[vendor] !== flow) return;
+      if (flow.validate && !flow.validate(flow.requester)) { closeFlowTerminal(discardFlow(vendor)); broadcastState(); return; }
       discardFlow(vendor);
       closeFlowTerminal(flow);
       if (succeeded) {
-        var message = { type: "auth_refreshed", slug: slug, vendor: flow.vendor, adapterRestarted: !!restarted };
+        var message = { type: "auth_refreshed", slug: slug, vendor: flow.vendor, adapterRestarted: !!restarted, workerAuthRequestId: flow.workerAuthRequestId, personalRequestId: flow.personalRequestId };
         if (ctx.clients) ctx.clients.forEach(function (ws) { if (flowKey(ws, flow.vendor) === vendor && hasTerminalPermission(ws)) sendTo(ws, message); });
         else send(message);
       }
       broadcastState();
+    }).catch(function (error) {
+      if (_flows[vendor] !== flow) return;
+      closeFlowTerminal(discardFlow(vendor));
+      sendTo(flow.requester, { type: 'vendor_login_error', vendor: flow.vendor, personalRequestId: flow.personalRequestId, error: 'Sign-in ended, but refreshing the provider failed. Check its status before explicitly retrying the task.' });
+      broadcastState();
     });
   }
 
   function handleFlowOutput(vendor, chunk) {
     var flow = _flows[vendor];
     if (!flow || flow.finishing || flow.succeeded) return;
+    if (flow.validate && !flow.validate(flow.requester)) { closeFlowTerminal(discardFlow(vendor)); broadcastState(); return; }
     flow.outputTail = (flow.outputTail + stripAnsi(chunk)).slice(-OUTPUT_TAIL_MAX);
     if (flow.browser) flow.browser.output(stripAnsi(chunk));
     if (!looksLikeLoginSuccess(flow.outputTail)) return;
@@ -252,9 +251,13 @@ function attachVendorLogin(ctx) {
     finishFlow(vendor, !!flow.succeeded);
   }
 
-  function startFlow(ws, vendor, msg) {
+  function startFlow(ws, vendor, msg, authorization) {
     var key = flowKey(ws, vendor);
-    var identity = resolveLoginIdentity(ws, msg);
+    var identity = msg.personalRequestId && authorization ? authorization.identity : resolveLoginIdentity(ws, msg);
+    if (osUsers && (!identity.linuxUser || !identity.osUserInfo) || authorization &&
+        (!authorization.validate(ws) || JSON.stringify(identity) !== JSON.stringify(authorization.identity))) {
+      throw new Error('The provider credential identity is unavailable or changed. Retry sign-in from its current session.');
+    }
     var command = loginCommandFor(vendor);
     var browserMode = msg.mode === "browser" && !!(vendorRegistry.getVendorInfo(vendor) || {}).browserLoginCommand;
     if (browserMode) command = loginProtocol.command(vendor, true);
@@ -271,6 +274,10 @@ function attachVendorLogin(ctx) {
       closing: false,
       completed: false,
       closeTimer: null,
+      validate: authorization && authorization.validate,
+      requester: ws,
+      workerAuthRequestId: msg.workerAuthRequestId || null,
+      personalRequestId: msg.personalRequestId || null,
     };
     // Registered before create() so the PTY's first output chunk (hooks fire
     // synchronously from spawn) already finds the record.
@@ -298,12 +305,37 @@ function attachVendorLogin(ctx) {
     }
 
     flow.terminalId = terminal.id;
+    if (flow.validate) {
+      flow.onClose = function () { closeFlowTerminal(discardFlow(key)); broadcastState(); };
+      if (ws.once) ws.once('close', flow.onClose);
+      flow.validationTimer = setInterval(function () {
+        if (_flows[key] === flow && !flow.validate(ws)) flow.onClose();
+      }, 1000);
+      if (flow.validationTimer.unref) flow.validationTimer.unref();
+    }
     if (!flow.browser) tm.attach(terminal.id, ws);
     send({ type: "term_list", terminals: tm.list(true) });
     return flow;
   }
 
   function handleVendorLoginMessage(ws, msg) {
+    if (installation.handle(ws,msg)) return true;
+    if (msg.type === 'vendor_login_catalog_request' || msg.type === 'vendor_login_personal_release') {
+      installation.release(ws); personal.release(ws);
+      Object.keys(_flows).forEach(function (key) { var flow = _flows[key]; if (flow.requester === ws && flow.personalRequestId) closeFlowTerminal(discardFlow(key)); });
+      if (msg.type === 'vendor_login_catalog_request') {
+        try { sendTo(ws, personal.catalog(ws, msg.requestId)); }
+        catch (error) { sendTo(ws, { type: 'vendor_login_catalog', requestId: msg.requestId, error: error.message }); }
+      }
+      broadcastState(); return true;
+    }
+    var scoped = _flows[flowKey(ws, String(msg.vendor || 'claude'))];
+    if (typeof msg.type === 'string' && msg.type.indexOf('vendor_login_') === 0 && scoped && scoped.validate && !scoped.validate(scoped.requester)) {
+      closeFlowTerminal(discardFlow(scoped.key));
+      sendTo(ws, { type: 'vendor_login_error', vendor: scoped.vendor, personalRequestId: scoped.personalRequestId, error: 'Sign-in context changed. Reopen provider settings or explicitly retry the task.' });
+      broadcastState();
+      return true;
+    }
     if (browserLogin.handle(ws, msg, _flows)) return true;
     if (msg.type === "vendor_login_state_request") {
       sendStateTo(ws);
@@ -312,6 +344,8 @@ function attachVendorLogin(ctx) {
 
     if (msg.type === "vendor_login_cancel") {
       var cancelVendor = String(msg.vendor || "");
+      if (scoped && (msg.personalRequestId || null) !== (scoped.personalRequestId || null)) return true;
+      if (scoped && msg.workerAuthRequestId && msg.workerAuthRequestId !== scoped.workerAuthRequestId) return true;
       var cancelled = discardFlow(flowKey(ws, cancelVendor));
       if (cancelled) closeFlowTerminal(cancelled);
       broadcastState();
@@ -321,11 +355,24 @@ function attachVendorLogin(ctx) {
     if (msg.type === "vendor_login_start") {
       var vendor = String(msg.vendor || "claude");
       if (!vendorRegistry.getVendorInfo(vendor)) {
-        sendTo(ws, { type: "vendor_login_error", vendor: vendor, error: "Unknown vendor: " + vendor });
+        sendTo(ws, { type: "vendor_login_error", vendor: vendor, personalRequestId: msg.personalRequestId || null, error: "Unknown vendor: " + vendor });
         return true;
       }
       if (!hasTerminalPermission(ws)) {
-        sendTo(ws, { type: "vendor_login_error", vendor: vendor, error: "Terminal access is not permitted" });
+        sendTo(ws, { type: "vendor_login_error", vendor: vendor, personalRequestId: msg.personalRequestId || null, error: "Terminal access is not permitted" });
+        return true;
+      }
+      var authorization = null;
+      try {
+        var targetSession = sm && sm.sessions && sm.sessions.get(msg.sessionId);
+        if (msg.personalRequestId) authorization = personal.resolve(ws, msg);
+        else if (msg.workerAuthRequestId || require('./session-provenance').isWorker(targetSession)) {
+          if (!ctx.workerAuth) throw new Error('Worker sign-in is unavailable.');
+          authorization = ctx.workerAuth.resolve(ws, msg);
+        }
+        loginCommandFor(vendor);
+      } catch (error) {
+        sendTo(ws, { type: 'vendor_login_error', vendor: vendor, personalRequestId: msg.personalRequestId || null, error: error.message || 'Provider sign-in is unavailable. Sign in manually on the server.' });
         return true;
       }
 
@@ -337,6 +384,9 @@ function attachVendorLogin(ctx) {
         existing = null;
       }
 
+      if (existing && (existing.personalRequestId || null) !== (msg.personalRequestId || null)) {
+        sendTo(ws, {type:'vendor_login_error', vendor:vendor, personalRequestId:msg.personalRequestId || null, error:'A sign-in is already running in another context. Finish or cancel it before starting another.'}); return true;
+      }
       if (existing) {
         // An auto-triggered request (a fresh auth_required from another
         // session or split pane) must not pop a second prompt; it only learns
@@ -350,17 +400,26 @@ function attachVendorLogin(ctx) {
             terminalId: existing.terminalId,
             reused: true,
             browserId: existing.browser ? existing.browser.id : null,
+            sessionId: msg.sessionId || null,
+            workerAuthRequestId: msg.workerAuthRequestId || null,
+            personalRequestId: msg.personalRequestId || null,
           });
         }
         sendStateTo(ws);
         return true;
       }
 
-      var started = startFlow(ws, vendor, msg);
+      var started;
+      try { started = startFlow(ws, vendor, msg, authorization); }
+      catch (error) {
+        sendTo(ws, { type: 'vendor_login_error', vendor: vendor, personalRequestId: msg.personalRequestId || null, error: error.message || 'Provider sign-in is unavailable.' });
+        return true;
+      }
       if (!started) {
         sendTo(ws, {
           type: "vendor_login_error",
           vendor: vendor,
+          personalRequestId: msg.personalRequestId || null,
           error: "Cannot create terminal (node-pty not available or limit reached)",
         });
         return true;
@@ -374,6 +433,9 @@ function attachVendorLogin(ctx) {
         terminalId: started.terminalId,
         reused: false,
         browserId: started.browser ? started.browser.id : null,
+        sessionId: msg.sessionId || null,
+        workerAuthRequestId: msg.workerAuthRequestId || null,
+        personalRequestId: msg.personalRequestId || null,
       });
       broadcastState();
       return true;
@@ -412,6 +474,7 @@ function attachVendorLogin(ctx) {
     isLoginTerminal: isLoginTerminal,
     refreshVendorAuth: refreshVendorAuth,
     destroy: function () {
+      installation.destroy();
       Object.keys(_flows).forEach(function (vendor) { closeFlowTerminal(discardFlow(vendor)); });
     },
   };

package/lib/project-worker-auth.js

@@ -0,0 +1,71 @@
+// Live owner-only authentication receipts. Never reconstructed from history.
+var crypto = require('crypto');
+var provenance = require('./session-provenance');
+var LIFETIME = 5 * 60 * 1000;
+function attach(ctx) {
+  var receipts = new WeakMap();
+  function identity(ws) {
+    return ctx.osUsers ? ctx.getOsUserInfoForWs(ws) : null;
+  }
+  function visible(ws, pair) {
+    return ws && ws.readyState === 1 && ctx.clients.has(ws) && !ws._clayPaneActivation &&
+      (ws._clayActiveSession === pair.driver.localId || ws._clayActiveSession === pair.worker.localId);
+  }
+  function valid(ws, receipt) {
+    if (!receipt || receipt.expires <= Date.now()) return false;
+    var pair = ctx.currentPair(ws, receipt.target);
+    return !!(pair && visible(ws, pair) && pair.driver === receipt.driver && pair.worker === receipt.worker &&
+      JSON.stringify([pair.group.id, pair.group.members, pair.group.pair]) === receipt.group &&
+      !pair.worker.hidden && !pair.driver.hidden && pair.worker.vendor === receipt.vendor && pair.linuxUser === receipt.linuxUser && !pair.worker.taskStopRequested &&
+      !pair.driver.taskStopRequested && !(pair.driver._pairTurnControl && pair.driver._pairTurnControl.humanStopped) &&
+      (pair.driver._forceStopRevision || 0) === receipt.driverStop &&
+      (pair.worker._forceStopRevision || 0) === receipt.stop &&
+      (pair.worker._queryGeneration || 0) === receipt.query &&
+      ctx.requestAccess.hasPermission(ws, 'terminal') &&
+      JSON.stringify(identity(ws)) === receipt.identity);
+  }
+  function emit(worker, message) {
+    if (!provenance.isWorker(worker)) return false;
+    if (ctx.sm.sessions.get(worker.localId) !== worker) return true;
+    worker._workerAuthRequired = true;
+    if (worker._workerAuthFailureQuery !== worker._queryGeneration || !worker._workerAuthFailureRecorded) {
+      worker._workerAuthFailureQuery = worker._queryGeneration;
+      worker._workerAuthFailureRecorded = true;
+      ctx.sm.sendAndRecord(worker, { type: 'error', text: 'The Worker needs provider sign-in. Complete sign-in, then explicitly retry the delegated task. No task was replayed.' });
+    }
+    var target = { parentSessionOriginId: worker.sessionProvenance.parentSessionOriginId,
+      workerSessionOriginId: worker.sessionOriginId, generation: worker.sessionProvenance.generation };
+    ctx.clients.forEach(function (ws) {
+      var pair = ctx.currentPair(ws, target);
+      if (!pair || pair.worker !== worker || !visible(ws, pair) || worker.hidden || worker.taskStopRequested) return;
+      var entries = receipts.get(ws) || new Map();
+      entries.forEach(function (entry, id) { if (!valid(ws, entry)) entries.delete(id); });
+      var receipt;
+      entries.forEach(function (entry) { if (entry.worker === worker) receipt = entry; });
+      if (!receipt) {
+        receipt = { id: crypto.randomUUID(), target: target, driver: pair.driver, worker: worker,
+          group: JSON.stringify([pair.group.id, pair.group.members, pair.group.pair]), vendor: worker.vendor,
+          identity: JSON.stringify(identity(ws)), linuxUser: pair.linuxUser, query: worker._queryGeneration || 0,
+          stop: worker._forceStopRevision || 0, driverStop: pair.driver._forceStopRevision || 0, expires: Date.now() + LIFETIME };
+        if (entries.size >= 16) entries.delete(entries.keys().next().value);
+        entries.set(receipt.id, receipt); receipts.set(ws, entries);
+      }
+      if (!valid(ws, receipt)) return;
+      ctx.sendTo(ws, { type: 'worker_auth_required', slug: ctx.slug, vendor: worker.vendor,
+        sessionId: worker.localId, workerAuthRequestId: receipt.id, text: message.text,
+        canAutoLogin: message.canAutoLogin, loginCommand: message.loginCommand });
+    });
+    // Worker events use this owner flow even when no eligible connection exists.
+    return true;
+  }
+  function resolve(ws, msg) {
+    var entries = receipts.get(ws), receipt = entries && entries.get(msg.workerAuthRequestId);
+    if (!valid(ws, receipt) || msg.vendor !== receipt.vendor || msg.sessionId !== receipt.worker.localId) {
+      throw new Error('This Worker sign-in request expired or its context changed. Retry the Worker explicitly to request sign-in again.');
+    }
+    return { identity: { linuxUser: receipt.linuxUser || null, osUserInfo: JSON.parse(receipt.identity) },
+      validate: function (peer) { return peer === ws && valid(ws, receipt); } };
+  }
+  return { emit: emit, resolve: resolve };
+}
+module.exports = { attach: attach };