clay-server 4.0.0 → 4.1.0-beta.1

package/lib/project-pair-usage.js

@@ -0,0 +1,73 @@
+function firstNumber() {
+  for (var i = 0; i < arguments.length; i++) {
+    var value = arguments[i];
+    if (typeof value === "number" && isFinite(value) && value >= 0) return value;
+  }
+  return null;
+}
+
+function matchingWindow(modelUsage, model) {
+  if (!modelUsage || !model || !modelUsage[model]) return null;
+  return firstNumber(modelUsage[model].contextWindow);
+}
+
+function contextStatus(session) {
+  var snapshot = session.lastContextUsage || null;
+  var used = null;
+  var window = null;
+  var source = "unavailable";
+  if (snapshot && typeof snapshot === "object") {
+    if (session.vendor === "claude") {
+      used = firstNumber(snapshot.totalTokens);
+      window = firstNumber(snapshot.maxTokens);
+      if (used !== null || window !== null) source = "claude_sdk_context_usage";
+    } else {
+      used = firstNumber(snapshot.input_tokens);
+      window = firstNumber(snapshot.contextWindow);
+      if (used !== null || window !== null) source = "adapter_context_usage";
+    }
+  }
+  var history = session.history || [];
+  var cumulativeInput = 0;
+  var cumulativeOutput = 0;
+  var results = 0;
+  var observedInput = false;
+  var observedOutput = false;
+  var lastTask = null;
+  var compactions = 0;
+  var compacting = false;
+  var lastCompactionAt = null;
+  for (var i = 0; i < history.length; i++) {
+    var item = history[i];
+    if (!item) continue;
+    if (item.type === "compacting") {
+      if (item.active) compactions++;
+      compacting = !!item.active;
+      if (typeof item._ts === "number") lastCompactionAt = item._ts;
+    }
+    if (item.type !== "result") continue;
+    var usage = item.usage || {};
+    var input = firstNumber(usage.input_tokens, usage.inputTokens);
+    var output = firstNumber(usage.output_tokens, usage.outputTokens);
+    if (input !== null) { cumulativeInput += input; observedInput = true; }
+    if (output !== null) { cumulativeOutput += output; observedOutput = true; }
+    results++;
+    lastTask = { inputTokens: input, outputTokens: output, currentInputTokens: firstNumber(item.lastStreamInputTokens) };
+    var observedWindow = matchingWindow(item.modelUsage, session.model);
+    if (observedWindow !== null) window = observedWindow;
+  }
+  if (used === null && lastTask && lastTask.currentInputTokens !== null) {
+    used = lastTask.currentInputTokens;
+    source = "last_stream_input";
+  }
+  var ratio = used !== null && window !== null && window > 0 ? Math.min(1, Math.round((used / window) * 1000) / 1000) : null;
+  return {
+    current: { source: source, usedTokens: used, windowTokens: window, usedRatio: ratio,
+      scope: used === null && window === null ? "unknown" : (used !== null && window !== null ? "current_context" : "partial_current_context") },
+    cumulative: { inputTokens: observedInput ? cumulativeInput : null, outputTokens: observedOutput ? cumulativeOutput : null, tasksObserved: results, scope: "loaded_session_history", complete: false },
+    lastTask: lastTask,
+    compactions: { observedCount: compactions, active: compacting, lastObservedAt: lastCompactionAt, scope: "loaded_session_history", complete: false },
+  };
+}
+
+module.exports = { contextStatus: contextStatus, firstNumber: firstNumber };

package/lib/project-session-pair.js

@@ -1,69 +1,24 @@
-var pairMcp = require("./session-pair-mcp-server");
-var pairPrompts = require("./session-pair-prompts");
-var { attachPairFactory } = require("./session-pair-factory");
-var { attachPairLifecycle } = require("./project-pair-lifecycle");
-var { attachPairTurnControl } = require("./session-pair-turn-control");
+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");
-var { attachWorkerPermission } = require("./project-worker-permission");
-var { attachWorkerProposal } = require("./project-worker-proposal");
-var MAX_RESPONSE_CHARS = 30000;
+var { attachWorkerPermission } = require("./project-worker-permission"), { attachWorkerProposal } = require("./project-worker-proposal");
+var { attachPairMessage } = require("./project-pair-message"), { attachPairTaskControl } = require("./project-pair-task-control");
+var pairHistory = require("./session-pair-history"), responseText = pairHistory.responseText, errorSince = pairHistory.errorSince, recentTurns = pairHistory.recentTurns, operationFingerprint = require("./session-pair-operation").fingerprint;
 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 responseText(history, fromIndex) {
-  var text = "";
-  for (var i = Math.max(0, fromIndex || 0); i < history.length; i++) {
-    if (history[i] && history[i].type === "delta" && history[i].text) text += history[i].text;
-  }
-  if (text.length > MAX_RESPONSE_CHARS) text = text.slice(-MAX_RESPONSE_CHARS);
-  return text;
+  return Promise.resolve({ content: [{ type: "text", text: "Error: " + (err.message || err) }], isError: true });
 }
-
-function errorSince(history, fromIndex) {
-  for (var i = history.length - 1; i >= Math.max(0, fromIndex || 0); i--) {
-    if (history[i] && history[i].type === "error") return history[i].text || "partner turn failed";
-  }
-  return null;
-}
-
-function recentTurns(session, count) {
-  var history = session.history || [];
-  var starts = [];
-  for (var i = 0; i < history.length; i++) {
-    if (history[i] && history[i].type === "user_message") starts.push(i);
-  }
-  var from = starts.length > 0 ? starts[Math.max(0, starts.length - count)] : 0;
-  var turns = [];
-  var current = null;
-  for (var j = from; j < history.length; j++) {
-    var item = history[j];
-    if (!item) continue;
-    if (item.type === "user_message") {
-      current = { user: item.text || "", delegated: !!item.delegated, response: "" };
-      turns.push(current);
-    } else if (item.type === "delta" && item.text) {
-      if (!current) { current = { user: "", delegated: false, response: "" }; turns.push(current); }
-      current.response += item.text;
-      if (current.response.length > MAX_RESPONSE_CHARS) current.response = current.response.slice(-MAX_RESPONSE_CHARS);
-    }
-  }
-  return turns;
-}
-
 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 });
   function groupAndPartner(caller, missingPairMessage) {
     if (!caller) throw new Error("partner tools require a session-bound tool server");
-    // Captured handlers must remain bound to the exact live Session object.
     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");
     }
@@ -78,26 +33,42 @@ function attachSessionPair(ctx) {
     if (caller.ownerId !== partner.ownerId) throw new Error("split partner access denied");
     return { group: group, partner: partner };
   }
-
+  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 };
+  }
+  var pairMessage = attachPairMessage({
+    sm: sm,
+    getSdk: ctx.getSdk,
+    resolvePair: groupAndPartner,
+    turnControl: turnControl,
+  });
+  taskControl = attachPairTaskControl({
+    sm: sm, resolvePair: groupAndPartner, rolesFor: rolesFor, turnControl: turnControl,
+    sendFollowup: function (args, caller) { return sendToPartner(args, caller); },
+  });
   function broadcastDelegation(group, caller, partner, active) {
-    var message = {
-      type: "split_delegation",
-      groupId: group.id,
-      from: caller.localId,
-      to: partner.localId,
-      active: !!active,
-    };
+    var message = { type: "split_delegation", groupId: group.id, from: caller.localId,
+      to: partner.localId, active: !!active };
     if (typeof ctx.broadcastDelegation === "function") ctx.broadcastDelegation(group, message);
     else ctx.send(message);
   }
-
   function finishDelegation(group, caller, partner, token) {
     if (partner._pairDelegation !== token) return;
     delete partner._pairDelegation;
     delete partner._delegatedBy;
     broadcastDelegation(group, caller, partner, false);
   }
-
+  function completeInterruptedTask(partner, caller, token) {
+    if (!token) return null;
+    return taskControl.complete(partner, caller, token, "interrupted",
+      responseText(partner.history || [], token.startIndex), null);
+  }
   function resumeDriverWithMessage(caller, text, meta) {
     if (!caller || caller.destroying) return false;
     if (turnControl.blockedReason(caller)) return false;
@@ -134,7 +105,6 @@ function attachSessionPair(ctx) {
     sm.broadcastSessionList();
     return true;
   }
-
   function resumeDriverWithResult(caller, partner, token) {
     if (!token.detached || token.delivered || caller.destroying) return false;
     token.delivered = true;
@@ -154,14 +124,12 @@ function attachSessionPair(ctx) {
       partnerSessionId: partner.localId,
     });
   }
-
   function requestDetach(worker) {
     var token = worker && worker._pairDelegation;
     if (!token || token.detached || token.detachRequested) return false;
     token.detachRequested = true;
     return true;
   }
-
   function handleTurnDone(partner) {
     var token = partner && partner._pairDelegation;
     if (!token) return false;
@@ -176,10 +144,13 @@ function attachSessionPair(ctx) {
     token.response = responseText(partner.history || [], token.startIndex);
     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);
-    return resumeDriverWithResult(caller, partner, token);
+    var resumed = resumeDriverWithResult(caller, partner, token);
+    taskControl.drain(caller, partner);
+    return resumed;
   }
-
   function waitForPartner(group, caller, partner, token, timeoutSeconds) {
     return new Promise(function (resolve, reject) {
       var deadline = Date.now() + timeoutSeconds * 1000;
@@ -196,24 +167,29 @@ function attachSessionPair(ctx) {
           finishDelegation(group, caller, partner, token);
           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);
           resolve({
-            status: failure ? "error" : (interrupted ? "interrupted" : "complete"),
-            response: responseText(partner.history || [], token.startIndex),
+            status: 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;
         }
-        // Timeouts and permission requests both detach into the push-back path.
         if (Date.now() >= deadline || token.detachRequested) {
           clearInterval(timer);
           token.detached = true;
           monitorPartner(group, caller, partner, token);
-          resolve({ status: "running", 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 an interim status check." });
         }
       }, 500);
     });
   }
-
   function monitorPartner(group, caller, partner, token) {
     var timer = setInterval(function () {
       var currentGroup = store.groupForMember(caller.localId);
@@ -224,7 +200,6 @@ function attachSessionPair(ctx) {
       }
     }, 500);
   }
-
   async function sendToPartner(args, caller) {
     try {
       if (caller && caller._delegatedBy) throw new Error("delegated turns cannot delegate to another session");
@@ -238,7 +213,9 @@ function attachSessionPair(ctx) {
       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");
-      var token = { from: caller.localId, groupId: resolved.group.id, startIndex: partner.history.length, message: message };
+      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 });
       partner._pairDelegation = token;
       partner._delegatedBy = caller.localId;
       sm.sendAndRecord(partner, {
@@ -248,6 +225,8 @@ function attachSessionPair(ctx) {
         delegatedBy: caller.localId,
         delegatedByTitle: caller.title || "Driver",
         delegatedByVendor: caller.vendor || "claude",
+        delegatedTaskId: token.taskId,
+        delegatedGeneration: token.generation,
       });
       partner.lastActivity = Date.now();
       partner.sentToolResults = {};
@@ -259,9 +238,10 @@ function attachSessionPair(ctx) {
         ctx.onProcessingChanged();
         sm.sendToSession(partner, { type: "status", status: "processing" });
       }
-      if (!sdk.pushMessage(partner, message)) {
+      var runtimeMessage = "[Split Worker taskId=" + token.taskId + " generation=" + (token.generation === null ? "unknown" : token.generation) + "]\n" + message + "\n\nBefore finishing, call report_partner_outcome with this exact taskId and only Worker-observed evidence.";
+      if (!sdk.pushMessage(partner, runtimeMessage)) {
         partner._queryStartTs = Date.now();
-        Promise.resolve(sdk.startQuery(partner, message, undefined, ctx.getLinuxUserForSession(partner))).catch(function (err) {
+        Promise.resolve(sdk.startQuery(partner, runtimeMessage, undefined, ctx.getLinuxUserForSession(partner))).catch(function (err) {
           partner.isProcessing = false;
           sm.sendAndRecord(partner, { type: "error", text: err.message || String(err) });
         });
@@ -270,15 +250,21 @@ function attachSessionPair(ctx) {
       if (!wait) {
         token.detached = true;
         monitorPartner(resolved.group, caller, partner, token);
-        return toolResult({ status: "running", partnerId: partner.localId, 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 an interim status check." });
       }
       if (!partner.isProcessing && !partner._queryStarting) {
         finishDelegation(resolved.group, caller, partner, token);
         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);
         return toolResult({
-          status: immediateFailure ? "error" : "complete",
-          response: responseText(partner.history || [], token.startIndex),
+          status: immediateFailure ? "error" : (immediateOutcome.status === "completed" ? "complete" : immediateOutcome.status),
+          taskId: token.taskId,
+          generation: token.generation,
+          response: immediateResponse,
           error: immediateFailure || undefined,
+          outcome: immediateOutcome,
         });
       }
       var completed = await waitForPartner(resolved.group, caller, partner, token, timeout);
@@ -297,7 +283,6 @@ function attachSessionPair(ctx) {
       return toolError(e);
     }
   }
-
   function readPartner(args, caller) {
     try {
       var resolved = groupAndPartner(caller);
@@ -315,7 +300,6 @@ function attachSessionPair(ctx) {
       return toolError(e);
     }
   }
-
   function interruptPartner(args, caller) {
     try {
       var resolved = groupAndPartner(caller);
@@ -323,6 +307,7 @@ function attachSessionPair(ctx) {
       if (!partner.isProcessing && !partner._queryStarting) {
         return toolResult({ status: "idle", partnerId: partner.localId, title: partner.title || "New Session" });
       }
+      taskControl.markInterruption(partner, "driver", args.reason || "The Driver interrupted the active task.");
       partner.taskStopRequested = true;
       if (partner.abortController) partner.abortController.abort();
       return toolResult({ status: "interrupting", partnerId: partner.localId, title: partner.title || "New Session" });
@@ -330,17 +315,20 @@ function attachSessionPair(ctx) {
       return toolError(e);
     }
   }
-
   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) finishDelegation(resolved.group, caller, partner, partner._pairDelegation);
+      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 });
@@ -350,18 +338,24 @@ function attachSessionPair(ctx) {
       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;
   }
-
+  function beginHumanTurn(session) {
+    var resumed = turnControl.beginHumanTurn(session);
+    var roles = resumed && rolesFor(session);
+    if (roles) taskControl.drain(roles.driver, roles.worker);
+    return resumed;
+  }
   function getToolDefs(boundSession) {
     if (!boundSession) return pairMcp.getToolDefs({
       send: function () { return toolError(new Error("send_to_partner requires a session-bound tool server")); },
       read: function () { return toolError(new Error("read_partner requires a session-bound tool server")); },
+      message: function () { return toolError(new Error("message_partner requires a session-bound tool server")); },
       interrupt: function () { return toolError(new Error("interrupt_partner requires a session-bound tool server")); },
       close: function () { return toolError(new Error("close_partner requires a session-bound tool server")); },
       status: function () { return toolError(new Error("partner_status requires a session-bound tool server")); },
@@ -369,7 +363,7 @@ 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 [];
+    if (group && group.pair && group.pair.driverId !== boundSession.localId) return taskControl.workerToolDefs(boundSession);
     var adHocSplit = !!(group && !group.pair);
     if (!driverEligibility.isEligibleDriverSession(boundSession, sm)) return [];
     var persistentCatalog = boundSession.vendor === "codex" && (!group || !!group.pair);
@@ -382,34 +376,44 @@ 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);
       },
       read: function (args) { return readPartner(args, boundSession); },
+      message: function (args) {
+        return turnControl.runOperation(boundSession, "message", args && args.requestId, function () {
+          return pairMessage.send(args || {}, boundSession);
+        }, pairMessage.fingerprint(args || {})).catch(function (err) {
+          return toolResult({ status: "rejected", requestId: args && args.requestId || null, reason: err.message || String(err) });
+        });
+      },
       interrupt: function (args) { return interruptPartner(args, boundSession); },
       close: function (args) { return closePartner(args, boundSession); },
       status: lifecycleHandlers.status,
       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);
       },
       evaluate: lifecycleHandlers.evaluate,
     }, { lifecycle: persistentCatalog || !adHocSplit });
+    if (!adHocSplit) tools = tools.concat(taskControl.driverToolDefs({
+      queue: function (args) { return taskControl.queue(args || {}, boundSession); },
+      inspect: function (args) { return taskControl.inspect(args || {}, boundSession); },
+      cancel: function (args) { return taskControl.cancel(args || {}, boundSession); },
+      replace: function (args) { return taskControl.replaceTask(args || {}, boundSession); },
+      resume: function (args) { return taskControl.resumeTask(args || {}, boundSession); },
+    }));
     if (persistentCatalog) {
       return workerProposal.getToolDefs(boundSession, { persistent: true })
         .concat(tools)
         .concat(workerPermission.getToolDefs(boundSession, { dormantDriver: true }));
     }
-    return tools
+    return tools.concat(adHocSplit ? [] : workerProposal.getToolDefs(boundSession, { persistent: true, controlsOnly: true }))
       .concat(workerPermission.getToolDefs(boundSession, { dormantDriver: false }));
   }
-
-  var factory = attachPairFactory(ctx);
-  var createPairRecord = factory.createPairRecord;
-  var createWorkerForDriver = factory.createWorkerForDriver;
-  var createPair = factory.createPair;
-  var preflightWorkerForDriver = factory.preflightWorkerForDriver;
-
+  var factory = attachPairFactory(ctx), createPairRecord = factory.createPairRecord,
+    createWorkerForDriver = factory.createWorkerForDriver, createPair = factory.createPair,
+    preflightWorkerForDriver = factory.preflightWorkerForDriver;
   lifecycle = attachPairLifecycle({
     sm: sm,
     splitStore: store,
@@ -417,12 +421,13 @@ function attachSessionPair(ctx) {
     preflightWorkerForDriver: function (driver, args) { return preflightWorkerForDriver(driver, args); },
     sendToPartner: function (args, caller) { return sendToPartner(args, caller); },
     finishDelegation: finishDelegation,
-    cancelWorkerPermissions: function (worker, reason) {
-      return workerPermission.cancelForSession(worker, reason);
-    },
+    completeInterruptedTask: completeInterruptedTask,
+    cancelWorkerPermissions: function (worker, reason) { return workerPermission.cancelForSession(worker, reason); },
+    markInterruption: function (worker, by, reason) { return taskControl.markInterruption(worker, by, reason); },
+    taskStatus: function (worker) { return taskControl.status(worker); },
+    proposalStatus: function (driver) { return workerProposal ? workerProposal.proposalStatus(driver) : null; },
     turnControl: turnControl,
   });
-
   workerPermission = attachWorkerPermission({
     sm: sm,
     splitStore: store,
@@ -430,7 +435,6 @@ function attachSessionPair(ctx) {
     resumeDriverWithMessage: resumeDriverWithMessage,
     requestDetach: requestDetach,
   });
-
   workerProposal = attachWorkerProposal({
     sm: sm,
     isMate: ctx.isMate,
@@ -446,8 +450,8 @@ function attachSessionPair(ctx) {
     recordGenerationStart: function (driver, worker) { return lifecycle.recordGenerationStart(driver, worker); },
     sendToPartner: sendToPartner,
     replacePartner: function (args, session) { return lifecycle.replacePartner(args, session); },
+    preflightWorkerForDriver: preflightWorkerForDriver,
   });
-
   function handleMessage(ws, msg) {
     if (workerProposal.handleMessage(ws, msg)) return true;
     if (msg.type === "pair_session_options") {
@@ -467,8 +471,12 @@ 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) {
@@ -482,17 +490,8 @@ function attachSessionPair(ctx) {
     }
     return pairPrompt;
   }
-
-  return {
-    beginHumanTurn: turnControl.beginHumanTurn,
-    getToolDefs: getToolDefs,
-    handleHumanStop: handleHumanStop,
-    handleMessage: handleMessage,
-    handleTurnDone: handleTurnDone,
-    getSystemPrompt: getSystemPrompt,
-    respondToWorkerProposal: workerProposal.respondToProposal,
-    workerPermission: workerPermission,
-  };
+  return { beginHumanTurn: beginHumanTurn, getToolDefs: getToolDefs, handleHumanStop: handleHumanStop,
+    handleMessage: handleMessage, handleTurnDone: handleTurnDone, getSystemPrompt: getSystemPrompt,
+    respondToWorkerProposal: workerProposal.respondToProposal, workerPermission: workerPermission };
 }
-
 module.exports = { attachSessionPair: attachSessionPair, responseText: responseText, recentTurns: recentTurns };

package/lib/project-sessions.js

@@ -87,6 +87,13 @@ function attachSessions(ctx) {
   var getLinuxUserForSession = ctx.getLinuxUserForSession;
   var ensureProjectAccessForSession = ctx.ensureProjectAccessForSession;
   var getOsUserInfoForWs = ctx.getOsUserInfoForWs;
+  function stopSession(session) {
+    if (!session || (!session.isProcessing && !session._queryStarting)) return false;
+    if (typeof ctx.onHumanPairStop === "function") ctx.onHumanPairStop(session);
+    session.taskStopRequested = true;
+    if (session.abortController) session.abortController.abort();
+    return true;
+  }
   var hydrateImageRefs = ctx.hydrateImageRefs;
   var onProcessingChanged = ctx.onProcessingChanged;
   var broadcastPresence = ctx.broadcastPresence;
@@ -165,6 +172,14 @@ function attachSessions(ctx) {
   var setLatestVersion = ctx.setLatestVersion;
   var loadContextSources = ctx.loadContextSources;
 
+  function canAccessProjectSlug(ws, targetSlug) {
+    if (!targetSlug) return false;
+    if (!usersModule || typeof usersModule.isMultiUser !== "function" || !usersModule.isMultiUser()) return true;
+    var userId = ws && ws._clayUser ? ws._clayUser.id : null;
+    if (!userId || typeof opts.canAccessProjectSlug !== "function") return false;
+    return opts.canAccessProjectSlug(userId, targetSlug) === true;
+  }
+
   // Resolve the active user's Claude open-mode preference ('gui' or 'tui').
   // Multi-user mode reads per-user storage; single-user mode falls back to
   // the daemon-level default ('gui').
@@ -1004,11 +1019,7 @@ function attachSessions(ctx) {
 
     if (msg.type === "stop") {
       var session = getSessionForWs(ws);
-      if (session && (session.isProcessing || session._queryStarting)) {
-        if (typeof ctx.onHumanPairStop === "function") ctx.onHumanPairStop(session);
-        session.taskStopRequested = true;
-        if (session.abortController) session.abortController.abort();
-      }
+      stopSession(session);
       return true;
     }
 
@@ -1770,6 +1781,10 @@ function attachSessions(ctx) {
 
     // --- Create worktree from web UI ---
     if (msg.type === "create_worktree") {
+      if (slug.indexOf("--") !== -1) {
+        sendTo(ws, { type: "create_worktree_result", ok: false, error: "Cannot create a worktree from another worktree" });
+        return true;
+      }
       var wtBranch = (msg.branch || "").trim();
       var wtDirName = (msg.dirName || "").trim() || wtBranch.replace(/\//g, "-");
       var wtBase = (msg.baseBranch || "").trim() || null;
@@ -1793,7 +1808,7 @@ function attachSessions(ctx) {
     // --- Pre-check: does the project have tasks/schedules? ---
     if (msg.type === "remove_project_check") {
       var checkSlug = msg.slug;
-      if (!checkSlug) {
+      if (!checkSlug || !canAccessProjectSlug(ws, checkSlug)) {
         sendTo(ws, { type: "remove_project_check_result", slug: checkSlug, name: msg.name || checkSlug, count: 0 });
         return true;
       }
@@ -1816,8 +1831,16 @@ function attachSessions(ctx) {
         sendTo(ws, { type: "remove_project_result", ok: false, error: "Missing slug" });
         return true;
       }
+      if (!canAccessProjectSlug(ws, removeSlug)) {
+        sendTo(ws, { type: "remove_project_result", ok: false, error: "You do not have access to this project" });
+        return true;
+      }
       // If client chose to move tasks to another project before removing
       if (msg.moveTasksTo) {
+        if (!canAccessProjectSlug(ws, msg.moveTasksTo)) {
+          sendTo(ws, { type: "remove_project_result", ok: false, error: "You do not have access to the destination project" });
+          return true;
+        }
         moveAllSchedulesToProject(removeSlug, msg.moveTasksTo);
       }
       if (typeof opts.onRemoveProject === "function") {
@@ -1833,6 +1856,10 @@ function attachSessions(ctx) {
 
     // --- Move a single schedule to another project ---
     if (msg.type === "schedule_move") {
+      if (!canAccessProjectSlug(ws, msg.fromSlug) || !canAccessProjectSlug(ws, msg.toSlug)) {
+        sendTo(ws, { type: "schedule_move_result", ok: false, error: "You do not have access to one of these projects" });
+        return true;
+      }
       var moveResult = moveScheduleToProject(msg.recordId, msg.fromSlug, msg.toSlug);
       if (moveResult.ok) {
         // Re-broadcast updated records to this project's clients
@@ -2071,6 +2098,13 @@ function attachSessions(ctx) {
     handleSessionsMessage: handleSessionsMessage,
     resolveSessionForView: resolveSessionForView,
     respondToAskUser: respondToAskUser,
+    respondToHomePermission: function (ws, msg, session) {
+      if (!session || !msg || !session.pendingPermissions || !session.pendingPermissions[msg.requestId]) return false;
+      var indexedSessionId = sm.permissionRequestIndex[msg.requestId];
+      if (indexedSessionId !== session.localId || sm.sessions.get(indexedSessionId) !== session) return false;
+      return handleSessionsMessage(ws, { type: "permission_response", requestId: msg.requestId, decision: msg.decision });
+    },
+    stopHomeSession: stopSession,
   };
 }