clay-server 4.2.0 → 4.3.0-beta.10

package/lib/project-session-pair-prompt.js

@@ -0,0 +1,26 @@
+var driverEligibility = require("./session-driver-eligibility");
+var driverOrchestration = require("./session-driver-orchestration");
+var prompts = require("./session-pair-prompts");
+
+function attachSessionPairPrompt(ctx) {
+  function getSystemPrompt(session) {
+    var roles = ctx.rolesFor(session);
+    if (roles && roles.workers.indexOf(session) !== -1) {
+      var taskId = session._pairDelegation && session._pairDelegation.taskId || "unknown";
+      return prompts.worker(taskId);
+    }
+    var group = ctx.store.groupForMember(session.localId);
+    var result = "";
+    if (group && group.pair && group.pair.driverId === session.localId) {
+      result = prompts.DRIVER_CORE + " " + ctx.workerProposal().getSystemPrompt(session);
+      if (driverOrchestration.isHighTierDriverSession(session, ctx.sm)) result += " " + prompts.DRIVER_DELEGATION;
+    } else if (!group && !ctx.isMate && driverEligibility.isEligibleDriverSession(session, ctx.sm) &&
+        driverOrchestration.isHighTierDriverSession(session, ctx.sm)) {
+      result = prompts.UNPAIRED + " " + ctx.workerProposal().getSystemPrompt(session);
+    }
+    return result;
+  }
+  return { getSystemPrompt: getSystemPrompt };
+}
+
+module.exports = { attachSessionPairPrompt: attachSessionPairPrompt };

package/lib/project-session-pair.js

@@ -1,52 +1,38 @@
-var pairMcp = require("./session-pair-mcp-server"), pairPrompts = require("./session-pair-prompts"); var { attachPairFactory } = require("./session-pair-factory"), { attachPairLifecycle } = require("./project-pair-lifecycle"),
-  { attachPairTurnControl } = require("./session-pair-turn-control");
-var driverEligibility = require("./session-driver-eligibility"), driverOrchestration = require("./session-driver-orchestration"), { attachWorkerPermission } = require("./project-worker-permission"), { attachWorkerProposal } = require("./project-worker-proposal");
+var pairMcp = require("./session-pair-mcp-server"); var { attachPairFactory } = require("./session-pair-factory"), { attachPairLifecycle } = require("./project-pair-lifecycle"), { attachPairTurnControl } = require("./session-pair-turn-control");
+var driverEligibility = require("./session-driver-eligibility"), { attachWorkerPermission } = require("./project-worker-permission"), { attachWorkerProposal } = require("./project-worker-proposal");
+var attachSessionPairPrompt = require("./project-session-pair-prompt").attachSessionPairPrompt;
+var attachPairCloseTransaction = require("./project-pair-close-transaction").attachPairCloseTransaction;
 var { attachPairMessage } = require("./project-pair-message"), { attachPairTaskControl } = require("./project-pair-task-control"), stopAutonomous = require("./project-pair-autonomous-stop").stopAutonomousWork, stopOwned = require("./project-pair-owned-stop").stopOwnedPair;
 var pairHistory = require("./session-pair-history"), responseText = pairHistory.responseText, errorSince = pairHistory.errorSince, recentTurns = pairHistory.recentTurns, operationFingerprint = require("./session-pair-operation").fingerprint;
-var beginPairQuery = require("./session-pair-query-start").beginPairQuery;
-function toolResult(value) { return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] }); }
-function toolError(err) { return Promise.resolve({ content: [{ type: "text", text: "Error: " + (err.message || err) }], isError: true }); }
+var beginPairQuery = require("./session-pair-query-start").beginPairQuery, attachPairResultPipeline = require("./project-pair-result-pipeline").attachPairResultPipeline;
+var pairTarget = require("./session-pair-target"), splitRoles = require("./session-split-group-roles"), stopAllWorkers = require("./project-pair-global-stop").stopAllWorkers;
+function toolResult(value) { return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] }); } function toolError(err) { return Promise.resolve({ content: [{ type: "text", text: "Error: " + (err.message || err) }], isError: true }); }
 function attachSessionPair(ctx) {
-  var sm = ctx.sm;
-  var store = ctx.splitStore;
-  var workerProposal;
-  var workerPermission;
-  var lifecycle;
-  var taskControl;
-  var turnControl = attachPairTurnControl({ sm: sm, splitStore: store });
+  var sm = ctx.sm, store = ctx.splitStore, workerProposal, workerPermission, lifecycle, taskControl, closeTransaction;
+  var turnControl = attachPairTurnControl({ sm: sm, splitStore: store }), resultCapture;
+  function targetOptions(options) { return Object.assign({}, options || {}, { multiWorkerFeature: ctx.multiWorkerFeature }); }
   function groupAndPartner(caller, missingPairMessage) {
+    var args = arguments[2];
+    var options = arguments[3];
     if (!caller) throw new Error("partner tools require a session-bound tool server");
     if (sm.sessions.get(caller.localId) !== caller) {
       throw new Error("this session is no longer live; the partner tools are bound to an exact session");
     }
     var group = store.groupForMember(caller.localId);
     if (!group) throw new Error(missingPairMessage || "this session is not in a split group");
-    if (group.pair && group.pair.driverId !== caller.localId) {
-      throw new Error("only the configured Driver can direct this pair");
-    }
-    var partnerId = group.members[0] === caller.localId ? group.members[1] : group.members[0];
-    var partner = sm.sessions.get(partnerId);
-    if (!partner) throw new Error("split partner session was not found");
-    if (caller.ownerId !== partner.ownerId) throw new Error("split partner access denied");
-    return { group: group, partner: partner };
+    return pairTarget.resolveGroupTarget(sm, group, caller, args, targetOptions(options));
   }
   function rolesFor(session) {
-    if (!session || sm.sessions.get(session.localId) !== session) return null;
-    var group = store.groupForMember(session.localId);
-    if (!group || !group.pair) return null;
-    var driver = sm.sessions.get(group.pair.driverId);
-    var worker = sm.sessions.get(group.pair.workerId);
-    if (!driver || !worker || driver.ownerId !== worker.ownerId) return null;
-    return { group: group, driver: driver, worker: worker };
+    return pairTarget.rolesFor(sm, store, session);
   }
   var pairMessage = attachPairMessage({
     sm: sm,
     getSdk: ctx.getSdk,
-    resolvePair: groupAndPartner,
+    resolvePair: function (caller, args) { return groupAndPartner(caller, null, args, { mutation: true }); },
     turnControl: turnControl,
   });
   taskControl = attachPairTaskControl({
-    sm: sm, resolvePair: groupAndPartner, rolesFor: rolesFor, turnControl: turnControl,
+    sm: sm, resolvePair: function (caller, args, options) { return groupAndPartner(caller, null, args, options); }, rolesFor: rolesFor, turnControl: turnControl,
     sendFollowup: function (args, caller) { return sendToPartner(args, caller); },
   });
   function broadcastDelegation(group, caller, partner, active) {
@@ -119,17 +105,21 @@ function attachSessionPair(ctx) {
   function requestDetach(worker) {
     var token = worker && worker._pairDelegation;
     if (!token || token.detached || token.detachRequested) return false;
-    token.detachRequested = true;
+    if (token.outboxKey && ctx.resultOutbox && !ctx.resultOutbox.setRoute(token.outboxKey, "callback").ok) return false;
+    token.wait = false; token.detachRequested = true;
     return true;
   }
   function handleTurnDone(partner) {
     var token = partner && partner._pairDelegation;
     if (!token) return false;
+    if (token._capturePending || token._captureComplete) return false;
+    if (!taskControl.matchesGeneration(partner, token)) return false;
     var group = store.groupForMember(partner.localId);
     if (!group || group.id !== token.groupId || group.members.indexOf(token.from) === -1) return false;
     var caller = sm.sessions.get(token.from);
     if (!caller || caller.ownerId !== partner.ownerId) return false;
-    if (group.pair && (group.pair.driverId !== caller.localId || group.pair.workerId !== partner.localId)) {
+    var liveRoles = splitRoles.resolveLiveRoles(sm, group);
+    if (group.pair && (!liveRoles || liveRoles.driver !== caller || liveRoles.workers.indexOf(partner) === -1)) {
       finishDelegation(group, caller, partner, token);
       return false;
     }
@@ -137,19 +127,16 @@ function attachSessionPair(ctx) {
     token.failure = errorSince(partner.history || [], token.startIndex);
     token.interrupted = !token.failure && !!partner._lastTurnInterrupted;
     if (token.interrupted) taskControl.ensureSystemInterruption(partner, token);
-    taskControl.complete(partner, caller, token, token.failure ? "failed" : (token.interrupted ? "interrupted" : "completed"), token.response, token.failure);
-    finishDelegation(group, caller, partner, token);
-    if (typeof ctx.onPartnerResult === "function") ctx.onPartnerResult(caller, partner, token);
-    var resumed = resumeDriverWithResult(caller, partner, token);
-    taskControl.drain(caller, partner);
-    return resumed;
+    var outcome = taskControl.complete(partner, caller, token, token.failure ? "failed" : (token.interrupted ? "interrupted" : "completed"), token.response, token.failure);
+    return resultCapture.capture(caller, partner, token, outcome);
   }
   function waitForPartner(group, caller, partner, token, timeoutSeconds) {
     return new Promise(function (resolve, reject) {
       var deadline = Date.now() + timeoutSeconds * 1000;
       var timer = setInterval(function () {
         var currentGroup = store.groupForMember(caller.localId);
-        if (!currentGroup || currentGroup.id !== group.id || currentGroup.members.indexOf(partner.localId) === -1) {
+        var exactTarget = splitRoles.matchesLiveTarget(sm, currentGroup, caller, partner);
+        if (!currentGroup || currentGroup.id !== group.id || !exactTarget) {
           clearInterval(timer);
           finishDelegation(group, caller, partner, token);
           reject(new Error("the split group was dissolved while waiting for the partner"));
@@ -157,28 +144,34 @@ function attachSessionPair(ctx) {
         }
         if (!partner.isProcessing && !partner._queryStarting) {
           clearInterval(timer);
-          finishDelegation(group, caller, partner, token);
+          if (!taskControl.matchesGeneration(partner, token)) return reject(new Error("the delegated task no longer matches this Worker generation"));
           var failure = errorSince(partner.history || [], token.startIndex);
           var interrupted = !failure && !!partner._lastTurnInterrupted;
           var response = responseText(partner.history || [], token.startIndex);
           if (interrupted) taskControl.ensureSystemInterruption(partner, token);
           var outcome = taskControl.complete(partner, caller, token, failure ? "failed" : (interrupted ? "interrupted" : "completed"), response, failure);
+          resultCapture.capture(caller, partner, token, outcome);
           resolve({
-            status: failure ? "error" : (outcome.status === "completed" ? "complete" : outcome.status),
+            status: token._capturePending ? "capture_pending" : (failure ? "error" : (outcome.status === "completed" ? "complete" : outcome.status)),
             taskId: token.taskId,
             generation: token.generation,
             response: response,
             error: failure || undefined,
             outcome: outcome,
           });
-          taskControl.drain(caller, partner);
           return;
         }
         if (Date.now() >= deadline || token.detachRequested) {
           clearInterval(timer);
-          token.detached = true;
+          var routed = token.outboxKey && ctx.resultOutbox ? ctx.resultOutbox.setRoute(token.outboxKey, "callback") : { ok: true };
+          if (!routed.ok) {
+            monitorPartner(group, caller, partner, token);
+            resolve({ status: "capture_pending", taskId: token.taskId, generation: token.generation, response: responseText(partner.history || [], token.startIndex), error: routed.error });
+            return;
+          }
+          token.wait = false; token.detached = true;
           monitorPartner(group, caller, partner, token);
-          resolve({ status: "running", taskId: token.taskId, generation: token.generation, response: responseText(partner.history || [], token.startIndex), hint: "The completed result will be pushed back automatically. Use read_partner only for an interim status check." });
+          resolve({ status: "running", taskId: token.taskId, generation: token.generation, response: responseText(partner.history || [], token.startIndex), hint: "The completed result will be pushed back automatically. Use read_partner only for a requested status, concrete failure or stall diagnosis, or capacity/queue decision; do not poll routinely." });
         }
       }, 500);
     });
@@ -186,29 +179,37 @@ function attachSessionPair(ctx) {
   function monitorPartner(group, caller, partner, token) {
     var timer = setInterval(function () {
       var currentGroup = store.groupForMember(caller.localId);
-      if (!currentGroup || currentGroup.id !== group.id || (!partner.isProcessing && !partner._queryStarting)) {
+      var exactTarget = splitRoles.matchesLiveTarget(sm, currentGroup, caller, partner);
+      if (!currentGroup || currentGroup.id !== group.id || !exactTarget || (!partner.isProcessing && !partner._queryStarting)) {
         clearInterval(timer);
-        if (currentGroup && currentGroup.id === group.id) handleTurnDone(partner);
+        if (currentGroup && currentGroup.id === group.id && exactTarget) handleTurnDone(partner);
         else finishDelegation(group, caller, partner, token);
       }
     }, 500);
+    if (timer && typeof timer.unref === "function") timer.unref();
   }
   async function sendToPartner(args, caller) {
     try {
       if (caller && caller._delegatedBy) throw new Error("delegated turns cannot delegate to another session");
       var resolved = groupAndPartner(caller,
-        "send_to_partner requires an exact existing Driver/Split Worker pair; call propose_worker while unpaired");
+        "send_to_partner requires an exact existing Driver/Split Worker pair; call propose_worker while unpaired", args, { mutation: true });
       var message = typeof args.message === "string" ? args.message.trim() : "";
       if (!message) throw new Error("message is required");
       turnControl.assertWorkerAction(caller);
-      var wait = args.wait !== false;
+      var wait = args.wait === true;
       var timeout = Number.isFinite(args.timeoutSeconds) ? Math.floor(args.timeoutSeconds) : 300;
       timeout = Math.max(1, Math.min(900, timeout));
       var partner = resolved.partner;
       if (partner._pairDelegation) throw new Error("the partner is already handling a delegated task");
       delete partner._pairInterruption; delete partner._lastInterruptedPairTask;
       var task = taskControl.begin(partner, caller, message, args.taskId);
-      var token = Object.assign(task, { from: caller.localId, groupId: resolved.group.id, startIndex: partner.history.length });
+      var token = Object.assign(task, { from: caller.localId, groupId: resolved.group.id, startIndex: partner.history.length, wait: wait });
+      var started = resultCapture.begin(caller, partner, token, message, ctx.projectSlug);
+      if (!started.ok) {
+        token._retainOnError = true; partner._pairDelegation = token; partner._delegatedBy = caller.localId;
+        sm.sendAndRecord(caller, { type: "error", text: "The Split Worker task was not dispatched because its durable completion record could not be created: " + started.error });
+        return toolError(new Error(started.error));
+      }
       partner._pairDelegation = token;
       partner._delegatedBy = caller.localId;
       sm.sendAndRecord(partner, {
@@ -243,14 +244,15 @@ function attachSessionPair(ctx) {
       if (!wait) {
         token.detached = true;
         monitorPartner(resolved.group, caller, partner, token);
-        return toolResult({ status: "running", partnerId: partner.localId, taskId: token.taskId, generation: token.generation, hint: "The completed result will be pushed back automatically. Use read_partner only for an interim status check." });
+        return toolResult({ status: "running", partnerId: partner.localId, taskId: token.taskId, generation: token.generation, hint: "The completed result will be pushed back automatically. Use read_partner only for a requested status, concrete failure or stall diagnosis, or capacity/queue decision; do not poll routinely." });
       }
       if (!partner.isProcessing && !partner._queryStarting) {
-        finishDelegation(resolved.group, caller, partner, token);
+        if (!taskControl.matchesGeneration(partner, token)) return toolError(new Error("the delegated task no longer matches this Worker generation"));
         var immediateFailure = errorSince(partner.history || [], token.startIndex);
         var immediateResponse = responseText(partner.history || [], token.startIndex);
         var immediateOutcome = taskControl.complete(partner, caller, token, immediateFailure ? "failed" : "completed", immediateResponse, immediateFailure);
-        taskControl.drain(caller, partner);
+        var immediateCapture = resultCapture.capture(caller, partner, token, immediateOutcome);
+        if (!immediateCapture && token._capturePending) return toolError(new Error("The completed Split Worker result could not be durably captured yet."));
         return toolResult({
           status: immediateFailure ? "error" : (immediateOutcome.status === "completed" ? "complete" : immediateOutcome.status),
           taskId: token.taskId,
@@ -266,9 +268,10 @@ function attachSessionPair(ctx) {
       if (caller) {
         var group = store.groupForMember(caller.localId);
         if (group) {
-          var partnerId = group.members[0] === caller.localId ? group.members[1] : group.members[0];
-          var partner = sm.sessions.get(partnerId);
-          if (partner && partner._pairDelegation && partner._pairDelegation.from === caller.localId && !partner.isProcessing) {
+          var failedRoles = splitRoles.resolveLiveRoles(sm, group);
+          var failedTarget = failedRoles && splitRoles.resolveWorkerTarget(failedRoles.role, args && args.workerId);
+          var partner = failedTarget && failedTarget.ok ? sm.sessions.get(failedTarget.workerId) : null;
+          if (partner && partner._pairDelegation && partner._pairDelegation.from === caller.localId && !partner.isProcessing && !partner._pairDelegation._retainOnError) {
             finishDelegation(group, caller, partner, partner._pairDelegation);
           }
         }
@@ -278,7 +281,7 @@ function attachSessionPair(ctx) {
   }
   function readPartner(args, caller) {
     try {
-      var resolved = groupAndPartner(caller);
+      var resolved = groupAndPartner(caller, null, args, { readOnly: true });
       var count = Number.isFinite(args.lastTurns) ? Math.floor(args.lastTurns) : 1;
       count = Math.max(0, Math.min(5, count));
       var payload = {
@@ -287,7 +290,7 @@ function attachSessionPair(ctx) {
         title: resolved.partner.title || "New Session",
         turns: count > 0 ? recentTurns(resolved.partner, count) : [],
       };
-      payload.capacity = lifecycle.optionalStatus(caller);
+      payload.capacity = lifecycle.optionalStatus(caller, args);
       return toolResult(payload);
     } catch (e) {
       return toolError(e);
@@ -295,7 +298,7 @@ function attachSessionPair(ctx) {
   }
   function interruptPartner(args, caller) {
     try {
-      var resolved = groupAndPartner(caller);
+      var resolved = groupAndPartner(caller, null, args, { mutation: true });
       var partner = resolved.partner;
       if (!partner.isProcessing && !partner._queryStarting) {
         return toolResult({ status: "idle", partnerId: partner.localId, title: partner.title || "New Session" });
@@ -308,42 +311,26 @@ function attachSessionPair(ctx) {
       return toolError(e);
     }
   }
+  function closeWorker(args, caller) {
+    return closeTransaction.close(args, caller);
+  }
   function closePartner(args, caller) {
     try {
-      var resolved = groupAndPartner(caller);
-      var partner = resolved.partner;
-      var interrupted = !!(partner.isProcessing || partner._queryStarting);
-      if (interrupted) {
-        taskControl.markInterruption(partner, "driver", "The Driver closed the Split Worker pair.");
-        partner.taskStopRequested = true;
-        if (partner.abortController) partner.abortController.abort();
-      }
-      if (partner._pairDelegation) {
-        completeInterruptedTask(partner, caller, partner._pairDelegation);
-        finishDelegation(resolved.group, caller, partner, partner._pairDelegation);
-      }
-      workerPermission.cancelForSession(partner, "The Driver closed the Split Worker pair.");
-      var ws = { _clayUser: caller.ownerId ? { id: caller.ownerId } : null };
-      var result = store.dissolve(ws, { id: resolved.group.id });
-      if (!result.ok) throw new Error(result.error || "could not close the Worker pair");
-      return toolResult({ status: "closed", partnerId: partner.localId, interrupted: interrupted, historyPreserved: true });
+      return toolResult(closeWorker(args, caller));
     } catch (e) {
       return toolError(e);
     }
   }
   function handleHumanStop(session) {
     var roles = turnControl.markHumanStop(session);
-    if (!roles) return false;
-    taskControl.markInterruption(roles.worker, "user", "The human stopped this Split Worker turn.");
-    workerPermission.cancelForSession(roles.worker, "The human stopped this Split Worker turn.");
-    return true;
+    return stopAllWorkers(session, roles, { resultOutbox: ctx.resultOutbox, taskControl: taskControl, workerPermission: workerPermission });
   }
   function stopOwnedPair(session, reason) { return stopOwned(session, rolesFor(session), turnControl, taskControl, workerPermission, reason); }
   function stopAutonomousWork(session) { return stopAutonomous(session, rolesFor(session), turnControl, taskControl, workerPermission); }
   function beginHumanTurn(session) {
     var resumed = turnControl.beginHumanTurn(session);
     var roles = resumed && rolesFor(session);
-    if (roles) taskControl.drain(roles.driver, roles.worker);
+    if (roles) for (var i = 0; i < roles.workers.length; i++) taskControl.drain(roles.driver, roles.workers[i]);
     return resumed;
   }
   function stopBarrier(session) { return turnControl.blockedReason(session); }
@@ -359,7 +346,8 @@ function attachSessionPair(ctx) {
       evaluate: function () { return toolError(new Error("record_partner_evaluation requires a session-bound tool server")); },
     });
     var group = store.groupForMember(boundSession.localId);
-    if (group && group.pair && group.pair.driverId !== boundSession.localId) return taskControl.workerToolDefs(boundSession);
+    var boundRoles = group && group.pair ? splitRoles.resolveLiveRoles(sm, group) : null;
+    if (boundRoles && boundRoles.workers.indexOf(boundSession) !== -1) return taskControl.workerToolDefs(boundSession);
     var adHocSplit = !!(group && !group.pair);
     if (!driverEligibility.isEligibleDriverSession(boundSession, sm)) return [];
     var persistentCatalog = boundSession.vendor === "codex" && (!group || !!group.pair);
@@ -372,7 +360,7 @@ function attachSessionPair(ctx) {
       send: function (args) {
         return turnControl.runOperation(boundSession, "send", args && args.operationId, function () {
           return sendToPartner(args || {}, boundSession);
-        }, operationFingerprint(args, ["message", "wait", "timeoutSeconds", "taskId"])).catch(toolError);
+        }, operationFingerprint(args, ["message", "wait", "timeoutSeconds", "taskId", "workerId"])).catch(toolError);
       },
       read: function (args) { return readPartner(args, boundSession); },
       message: function (args) {
@@ -388,7 +376,7 @@ function attachSessionPair(ctx) {
       replace: function (args) {
         return turnControl.runOperation(boundSession, "replace", args && args.operationId, function () {
           return workerProposal.proposeReplacement(args || {}, boundSession);
-        }, operationFingerprint(args, ["interrupt", "message", "workerVendor", "workerModel", "workerEffort", "recommendationRationale", "evaluation", "supersedeProposalId"])).catch(toolError);
+        }, operationFingerprint(args, ["interrupt", "message", "workerVendor", "workerModel", "workerEffort", "recommendationRationale", "evaluation", "supersedeProposalId", "workerId"])).catch(toolError);
       },
       evaluate: lifecycleHandlers.evaluate,
     }, { lifecycle: persistentCatalog || !adHocSplit });
@@ -409,12 +397,14 @@ function attachSessionPair(ctx) {
   }
   var factory = attachPairFactory(ctx), createPairRecord = factory.createPairRecord,
     createWorkerForDriver = factory.createWorkerForDriver, createPair = factory.createPair,
+    addWorkerForDriver = factory.addWorkerForDriver, replaceWorkerForDriver = factory.replaceWorkerForDriver,
     preflightWorkerForDriver = factory.preflightWorkerForDriver, createOwnedPair = factory.createOwnedPair, removeOwnedPair = factory.removeOwnedPair,
     preflightRuntime = factory.preflightRuntime;
   lifecycle = attachPairLifecycle({
     sm: sm,
     splitStore: store,
     createWorkerForDriver: function (driver, args) { return createWorkerForDriver(driver, args); },
+    replaceWorkerForDriver: function (driver, worker, args) { return replaceWorkerForDriver(driver, worker, args); },
     preflightWorkerForDriver: function (driver, args) { return preflightWorkerForDriver(driver, args); },
     sendToPartner: function (args, caller) { return sendToPartner(args, caller); },
     finishDelegation: finishDelegation,
@@ -424,6 +414,7 @@ function attachSessionPair(ctx) {
     taskStatus: function (worker) { return taskControl.status(worker); },
     proposalStatus: function (driver) { return workerProposal ? workerProposal.proposalStatus(driver) : null; },
     turnControl: turnControl,
+    multiWorkerFeature: ctx.multiWorkerFeature,
   });
   workerPermission = attachWorkerPermission({
     sm: sm,
@@ -447,7 +438,9 @@ function attachSessionPair(ctx) {
     recordGenerationStart: function (driver, worker) { return lifecycle.recordGenerationStart(driver, worker); },
     sendToPartner: sendToPartner,
     replacePartner: function (args, session) { return lifecycle.replacePartner(args, session); },
+    addWorkerForDriver: function (driver, args) { return addWorkerForDriver(driver, args); },
     preflightWorkerForDriver: preflightWorkerForDriver,
+    multiWorkerFeature: ctx.multiWorkerFeature,
   });
   function handleMessage(ws, msg) {
     if (workerProposal.handleMessage(ws, msg)) return true;
@@ -468,27 +461,15 @@ function attachSessionPair(ctx) {
     }
     return false;
   }
-  function getSystemPrompt(session) {
-    var roles = rolesFor(session);
-    if (roles && roles.worker === session) {
-      var taskId = session._pairDelegation && session._pairDelegation.taskId || "unknown";
-      return pairPrompts.worker(taskId);
-    }
-    var group = store.groupForMember(session.localId);
-    var pairPrompt = "";
-    if (group && group.pair && group.pair.driverId === session.localId) {
-      pairPrompt = pairPrompts.DRIVER_CORE;
-      if (driverOrchestration.isHighTierDriverSession(session, sm)) {
-        pairPrompt += " " + pairPrompts.DRIVER_DELEGATION;
-      }
-    } else if (!group && !ctx.isMate && driverEligibility.isEligibleDriverSession(session, sm) &&
-      driverOrchestration.isHighTierDriverSession(session, sm)) {
-      pairPrompt = pairPrompts.UNPAIRED + " " + workerProposal.getSystemPrompt(session);
-    }
-    return pairPrompt;
-  }
-  return { beginHumanTurn: beginHumanTurn, getToolDefs: getToolDefs, handleHumanStop: handleHumanStop, stopOwnedPair: stopOwnedPair, stopAutonomousWork: stopAutonomousWork, stopBarrier: stopBarrier,
-    handleMessage: handleMessage, handleTurnDone: handleTurnDone, getSystemPrompt: getSystemPrompt,
-    respondToWorkerProposal: workerProposal.respondToProposal, workerPermission: workerPermission, createOwnedPair: createOwnedPair, removeOwnedPair: removeOwnedPair, preflightRuntime: preflightRuntime,
-    sendToPartner: sendToPartner, rolesFor: rolesFor };
+  var pairPrompt = attachSessionPairPrompt({ sm: sm, store: store, isMate: ctx.isMate, rolesFor: rolesFor,
+    workerProposal: function () { return workerProposal; } });
+  var resultPipeline = attachPairResultPipeline({ sm: sm, store: store, resultOutbox: ctx.resultOutbox, getSdk: ctx.getSdk, getLinuxUserForSession: ctx.getLinuxUserForSession, acceptanceTimeoutMs: ctx.acceptanceTimeoutMs, finishDelegation: finishDelegation, resumeDriverWithResult: resumeDriverWithResult, onPartnerResult: ctx.onPartnerResult, onStateChange: ctx.onResultStateChange, blockedReason: turnControl.blockedReason, drain: function (caller, partner) { return taskControl.drain(caller, partner); } });
+  resultCapture = resultPipeline.capture; var resultDelivery = resultPipeline.delivery;
+  closeTransaction = attachPairCloseTransaction({ store: store, multiWorkerFeature: ctx.multiWorkerFeature,
+    resolvePair: function (caller, args) { return groupAndPartner(caller, null, args, { mutation: true, structural: true }); },
+    taskControl: taskControl, resultCapture: resultCapture, workerPermission: workerPermission,
+    responseText: responseText, errorSince: errorSince });
+  return { beginHumanTurn: beginHumanTurn, getToolDefs: getToolDefs, handleHumanStop: handleHumanStop, stopOwnedPair: stopOwnedPair, stopAutonomousWork: stopAutonomousWork, stopBarrier: stopBarrier, handleMessage: handleMessage, handleTurnDone: handleTurnDone, getSystemPrompt: pairPrompt.getSystemPrompt,
+    respondToWorkerProposal: workerProposal.respondToProposal, workerPermission: workerPermission, addWorkerForDriver: addWorkerForDriver, createOwnedPair: createOwnedPair, removeOwnedPair: removeOwnedPair, preflightRuntime: preflightRuntime,
+    sendToPartner: sendToPartner, closeWorker: closeWorker, rolesFor: rolesFor, resultCapture: resultCapture, resultOutbox: ctx.resultOutbox, wakePartnerResult: function (caller, partner, token) { return resultDelivery.wake(caller, partner, token); }, getResultOutboxStatus: function () { return ctx.resultOutbox ? ctx.resultOutbox.status() : { records: [], persistenceError: null }; } };
 } module.exports = { attachSessionPair: attachSessionPair, responseText: responseText, recentTurns: recentTurns };

package/lib/project-sessions.js

@@ -989,6 +989,8 @@ function attachSessions(ctx) {
         // TUI session: kill the underlying PTY before deleting the session
         // record so the `claude` process is reaped and not left orphaned.
         var dsTarget = sm.sessions.get(msg.id);
+        if (usersModule.isMultiUser() && (!ws._clayUser ||
+            !usersModule.canAccessSession(ws._clayUser.id, dsTarget, getProjectAccess()))) return true;
         if (dsTarget && dsTarget.mode === "tui" && typeof dsTarget.terminalId === "number" && tm) {
           try { tm.close(dsTarget.terminalId); } catch (e) {}
         }
@@ -1001,6 +1003,8 @@ function attachSessions(ctx) {
     if (msg.type === "rename_session") {
       if (msg.id && sm.sessions.has(msg.id) && msg.title) {
         var s = sm.sessions.get(msg.id);
+        if (usersModule.isMultiUser() && (!ws._clayUser ||
+            !usersModule.canAccessSession(ws._clayUser.id, s, getProjectAccess()))) return true;
         s.title = String(msg.title).substring(0, 100);
         s.titleProvisional = false;
         s.titleAutoGenerated = false;

package/lib/project-user-message.js

@@ -1,5 +1,6 @@
 var path = require("path");
 var fs = require("fs");
+var continuationLease = require("./driver-continuation-lease");
 
 /**
  * Attach user-message handler and remaining small handlers
@@ -398,6 +399,13 @@ function attachUserMessage(ctx) {
       if (pendingInternal && typeof pendingInternal.complete === "function") pendingInternal.complete(outcome, reason);
     }
 
+    var deliveryContext = messageDelivery.validateContext(ws, session, msg);
+    if (!deliveryContext.ok) {
+      sendTo(ws, { type: "error", text: deliveryContext.reason || "Message context changed." });
+      finishPendingEarly(false, deliveryContext.reason || "Message context changed");
+      return true;
+    }
+
     if (session.loopInterviewHandoff && session.loopInterviewHandoff.state === "starting") {
       sendTo(ws, { type: "error", text: "Wait for the approved Loop handoff to finish." });
       finishPendingEarly("release", "Loop handoff is still starting");
@@ -433,6 +441,19 @@ function attachUserMessage(ctx) {
       finishPendingEarly(false, "Pending messages cannot be delivered to a Driver-operated Split Worker");
       return true;
     }
+    if (!pendingInternal && session._driverContinuationLease && pendingMessageQueue) {
+      var continuationQueued = pendingMessageQueue.admit(session, msg, ws && ws._clayUser);
+      if (continuationQueued.ok) {
+        messageDelivery.acknowledge(ws, deliveryReceipt, null, session);
+        sendTo(ws, { type: "message_queued", clientMessageId: msg.clientMessageId || null,
+          sessionId: session.localId, projectSlug: slug, state: "pending",
+          paused: pendingMessageQueue.isPaused(session), revision: pendingMessageQueue.getRevision() });
+        continuationLease.cancelForHumanMessage(session);
+      } else {
+        sendTo(ws, { type: "error", text: continuationQueued.error || "Unable to queue message" });
+      }
+      return true;
+    }
     if (!pendingInternal && pendingMessageQueue && (pendingMessageQueue.hasActive(session) || session.isProcessing || session._queryStarting || session._awaitingTurnResult)) {
       var queuedResult = pendingMessageQueue.admit(session, msg, ws && ws._clayUser);
       if (queuedResult.ok) {