clay-server 4.3.0-beta.5 → 4.3.0-beta.6

package/lib/project-pair-result-outbox.js

@@ -70,6 +70,8 @@ function attachPairResultOutbox(options) {
     }
     var nextRecords = Object.assign({}, records), next = Object.assign({}, record, {
       outcome: copy(outcome), state: record.state === "blocked" ? "blocked" : "captured", capturedAt: Date.now(),
+      preparedCloseOutcome: null,
+      closePreparationState: record.preparedCloseOutcome ? "superseded_by_terminal_evidence" : record.closePreparationState || null,
     });
     nextRecords[record.key] = next;
     var saved = persist(nextRecords);
@@ -87,6 +89,15 @@ function attachPairResultOutbox(options) {
   function retryCapture(key, operation, attempt) {
     attempt = attempt || 1;
     if (captureOperations[key] !== operation || !operation.active) return { ok: false, stale: true };
+    var isCurrent = true;
+    try { if (operation.isCurrent) isCurrent = operation.isCurrent() === true; } catch (error) { isCurrent = false; }
+    if (!isCurrent) {
+      operation.active = false;
+      var stale = { ok: false, stale: true, error: "pair result capture no longer matches the live Worker task" };
+      operation.lastResult = stale;
+      notifyCapture(operation, stale);
+      return stale;
+    }
     var result = captureRecord(key, operation.outcome);
     operation.lastResult = result;
     if (result.ok) {
@@ -118,6 +129,7 @@ function attachPairResultOutbox(options) {
       generation: args.generation == null ? null : args.generation,
       driverSessionId: args.driverSessionId == null ? null : args.driverSessionId,
       workerSessionId: args.workerSessionId == null ? null : args.workerSessionId,
+      groupId: typeof args.groupId === "string" ? args.groupId : null,
       workerSessionOriginId: args.workerOriginId,
       historyStartIndex: args.historyStartIndex == null ? null : args.historyStartIndex,
       message: args.message || "",
@@ -143,7 +155,7 @@ function attachPairResultOutbox(options) {
     records = nextRecords;
     return { ok: true, key: key, record: copy(record), duplicate: false };
   }
-  function capture(args, outcome, callback) {
+  function capture(args, outcome, callback, isCurrent) {
     var key = typeof args === "string" ? args : resultKey(args);
     var record = records[key];
     if (!record) return { ok: false, error: "pair result outbox record was not found" };
@@ -158,11 +170,65 @@ function attachPairResultOutbox(options) {
       addCaptureCallback(operation, callback);
       return retryCapture(key, operation, 1);
     }
-    operation = { outcome: copy(outcome), callbacks: [], active: true, complete: false, lastResult: null, timer: null };
+    operation = { outcome: copy(outcome), callbacks: [], active: true, complete: false, lastResult: null, timer: null,
+      isCurrent: typeof isCurrent === "function" ? isCurrent : null };
     captureOperations[key] = operation;
     addCaptureCallback(operation, callback);
     return retryCapture(key, operation, 1);
   }
+  function prepareCapture(key, outcome) {
+    var record = records[key];
+    if (!record) return { ok: false, error: "pair result outbox record was not found" };
+    if (record.outcome) {
+      if (!sameOutcome(record.outcome, outcome)) return { ok: false, conflict: true, error: "pair result outcome is immutable", record: copy(record) };
+      return { ok: true, record: copy(record), duplicate: true, committed: true };
+    }
+    if (record.preparedCloseOutcome) {
+      if (!sameOutcome(record.preparedCloseOutcome, outcome)) return { ok: false, conflict: true, error: "prepared close outcome changed", record: copy(record) };
+      return { ok: true, record: copy(record), duplicate: true, prepared: true };
+    }
+    var nextRecords = Object.assign({}, records), next = Object.assign({}, record, {
+      state: "close_prepared", preparedCloseOutcome: copy(outcome),
+      closePreparationState: "prepared", closePreparedAt: Date.now(),
+    });
+    nextRecords[key] = next;
+    var saved = persist(nextRecords);
+    if (!saved.ok) return { ok: false, error: saved.error, record: copy(record) };
+    records = nextRecords;
+    return { ok: true, record: copy(next), duplicate: false, prepared: true };
+  }
+  function finalizePreparedCapture(key, outcome) {
+    var record = records[key];
+    if (!record) return { ok: false, error: "pair result outbox record was not found" };
+    if (record.outcome) return captureRecord(key, outcome);
+    if (!record.preparedCloseOutcome || !sameOutcome(record.preparedCloseOutcome, outcome)) {
+      return { ok: false, error: "prepared close outcome is unavailable or changed", record: copy(record) };
+    }
+    var nextRecords = Object.assign({}, records), next = Object.assign({}, record, {
+      outcome: copy(outcome), state: "captured", capturedAt: Date.now(),
+      preparedCloseOutcome: null, closePreparationState: "committed", closeCommittedAt: Date.now(),
+    });
+    nextRecords[key] = next;
+    var saved = persist(nextRecords);
+    if (!saved.ok) return { ok: false, error: saved.error, record: copy(record) };
+    records = nextRecords;
+    return { ok: true, record: copy(next), duplicate: false };
+  }
+  function rollbackPreparedCapture(key, outcome) {
+    var record = records[key];
+    if (!record || !sameOutcome(record.preparedCloseOutcome, outcome) || record.outcome || record.finalized || record.transcriptPersisted ||
+        record.deliveryAttemptCount !== 0 || record.deliveryState !== "pending") {
+      return { ok: false, error: "prepared pair result can no longer be rolled back" };
+    }
+    var nextRecords = Object.assign({}, records), next = Object.assign({}, record, {
+      state: "dispatching", preparedCloseOutcome: null, closePreparationState: null, closePreparedAt: null,
+    });
+    nextRecords[key] = next;
+    var saved = persist(nextRecords);
+    if (!saved.ok) return { ok: false, error: saved.error, record: copy(record) };
+    records = nextRecords;
+    return { ok: true, record: copy(next) };
+  }
   function transition(key, changes) {
     var record = records[key];
     if (!record) return { ok: false, error: "pair result outbox record was not found" };
@@ -229,7 +295,7 @@ function attachPairResultOutbox(options) {
   function recoverPending(sessionMap) {
     var results = [], sessionsList = sessionMap && typeof sessionMap.values === "function" ? Array.from(sessionMap.values()) : [], keys = Object.keys(records);
     for (var i = 0; i < keys.length; i++) {
-      if (records[keys[i]].state !== "dispatching") continue;
+      if (records[keys[i]].state !== "dispatching" && records[keys[i]].state !== "close_prepared") continue;
       var session = sessionsList.find(function (candidate) { return stableOrigin(candidate) === records[keys[i]].workerOriginId && candidate.ownerId === records[keys[i]].ownerId; });
       if (session) results.push({ key: keys[i], result: recover(keys[i], session) });
     }
@@ -294,7 +360,7 @@ function attachPairResultOutbox(options) {
     return Object.keys(source).map(function (key) {
       var record = copy(source[key]);
       record.deliveryState = record.deliveryState || "pending";
-      record.recoveryState = record.state === "dispatching" || record.deliveryState === "attempting" || record.deliveryState === "uncertain" ? "uncertain" : "known";
+      record.recoveryState = record.state === "dispatching" || record.state === "close_prepared" || record.deliveryState === "attempting" || record.deliveryState === "uncertain" ? "uncertain" : "known";
       record.blockedReason = record.blockedReason || null;
       return record;
     });
@@ -306,6 +372,9 @@ function attachPairResultOutbox(options) {
   return {
     begin: begin,
     capture: capture,
+    prepareCapture: prepareCapture,
+    finalizePreparedCapture: finalizePreparedCapture,
+    rollbackPreparedCapture: rollbackPreparedCapture,
     beginDelivery: beginDelivery,
     markTranscript: markTranscript,
     markDelivery: markDelivery,

package/lib/project-pair-result-recovery.js

@@ -1,4 +1,5 @@
 var crypto = require("crypto");
+var splitRoles = require("./session-split-group-roles");
 
 function attachPairResultRecovery(ctx) {
   var scheduled = Object.create(null);
@@ -23,8 +24,9 @@ function attachPairResultRecovery(ctx) {
     if (!driver || !worker) return { ok: false, code: "session", reason: "The original Driver or Split Worker session is unavailable." };
     if (ownerId(driver) !== (record.ownerId || null) || ownerId(worker) !== (record.ownerId || null)) return { ok: false, code: "owner", reason: "The original session owner no longer matches." };
     var group = ctx.store.groupForMember(driver.localId);
-    if (!group || ctx.store.groupForMember(worker.localId) !== group || !group.pair ||
-        group.pair.driverId !== driver.localId || group.pair.workerId !== worker.localId) {
+    var roles = splitRoles.resolveLiveRoles(ctx.sm, group);
+    if (!group || ctx.store.groupForMember(worker.localId) !== group || !roles ||
+        roles.driver !== driver || roles.workers.indexOf(worker) === -1) {
       return { ok: false, code: "pair", reason: "The original Driver and Split Worker pair is no longer active." };
     }
     var provenance = worker.sessionProvenance;
@@ -49,6 +51,7 @@ function attachPairResultRecovery(ctx) {
     }
     token = {
       outboxKey: record.key, taskId: record.taskId, generation: record.generation,
+      workerSessionId: resolved.worker.localId, workerId: resolved.worker.localId,
       from: resolved.driver.localId, groupId: resolved.group.id,
       startIndex: Number.isInteger(record.historyStartIndex) ? record.historyStartIndex : resolved.worker.history.length,
       message: record.message || "", wait: record.deliveryRoute === "blocking",
@@ -118,6 +121,7 @@ function attachPairResultRecovery(ctx) {
       return runtimeStatus[record.key] ? Object.assign({}, record, runtimeStatus[record.key]) : record;
     }).filter(function (record) {
       if (record.projectSlug !== ctx.projectSlug || record.driverOriginId !== originId || (record.ownerId || null) !== currentOwner) return false;
+      if (record.state === "close_prepared") return false;
       if (healthyLiveDispatch(record)) return false;
       if (record.finalized) return false;
       if (record.deliveryState === "accepted") return record.state === "blocked" || record.finalizationState === "failed";

package/lib/project-pair-structural-close.js

@@ -0,0 +1,20 @@
+var splitRoles = require("./session-split-group-roles");
+
+function removeSelectedWorker(store, group, driver, worker, capability, hooks) {
+  var normalized = splitRoles.normalizePair(group.pair, group.members);
+  if (!normalized.ok || normalized.kind !== "versioned") {
+    var ws = { _clayUser: driver.ownerId ? { id: driver.ownerId } : null };
+    return store.dissolve(ws, { id: group.id }, hooks);
+  }
+  return store.removeWorker(driver.ownerId || null, {
+    groupId: group.id,
+    driverId: driver.localId,
+    driverOriginId: driver.sessionOriginId || null,
+    workerId: worker.localId,
+    workerOriginId: worker.sessionOriginId || null,
+    generation: worker._pairGeneration ||
+      worker.sessionProvenance && worker.sessionProvenance.generation || null,
+  }, capability, hooks);
+}
+
+module.exports = { removeSelectedWorker: removeSelectedWorker };

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

@@ -43,6 +43,9 @@ function attachPairTaskControl(ctx) {
   function taskGeneration(worker) {
     return worker._pairGeneration || worker.sessionProvenance && worker.sessionProvenance.generation || null;
   }
+  function matchesGeneration(worker, task) {
+    return !!(worker && task && task.workerSessionId === worker.localId && task.generation === taskGeneration(worker));
+  }
   function findTask(worker, taskId) {
     var active = current(worker);
     if (active && active.taskId === taskId) return active;
@@ -65,6 +68,7 @@ function attachPairTaskControl(ctx) {
       taskId: taskId,
       generation: taskGeneration(worker),
       workerSessionId: worker.localId,
+      workerId: worker.localId,
       driverSessionId: caller.localId,
       message: message,
       autonomousRunId: caller.autonomousRun && caller.autonomousRun.id || null,
@@ -89,7 +93,7 @@ function attachPairTaskControl(ctx) {
   function queue(args, caller) {
     try {
       ctx.turnControl.assertWorkerAction(caller);
-      var resolved = ctx.resolvePair(caller);
+      var resolved = ctx.resolvePair(caller, args, { mutation: true });
       var worker = resolved.partner;
       var message = cleanText(args.message, 30000);
       if (!message) throw new Error("message is required");
@@ -104,14 +108,14 @@ function attachPairTaskControl(ctx) {
   }
   function inspect(args, caller) {
     try {
-      var worker = ctx.resolvePair(caller).partner;
+      var worker = ctx.resolvePair(caller, args, { readOnly: true }).partner;
       return result(status(worker));
     } catch (err) { return result({ status: "rejected", reason: err.message || String(err) }); }
   }
   function cancel(args, caller) {
     try {
       ctx.turnControl.assertWorkerAction(caller);
-      var worker = ctx.resolvePair(caller).partner;
+      var worker = ctx.resolvePair(caller, args, { mutation: true }).partner;
       var task = findTask(worker, args.taskId);
       if (!task || (task.status !== "queued" && task.status !== "waiting_for_interrupt")) throw new Error("the exact queued task is not cancellable");
       task.status = "cancelled";
@@ -150,7 +154,7 @@ function attachPairTaskControl(ctx) {
   function replaceTask(args, caller) {
     try {
       ctx.turnControl.assertWorkerAction(caller);
-      var resolved = ctx.resolvePair(caller);
+      var resolved = ctx.resolvePair(caller, args, { mutation: true });
       var worker = resolved.partner;
       var active = current(worker);
       if (!active || !worker.isProcessing) throw new Error("there is no active delegated task to replace");
@@ -170,12 +174,12 @@ function attachPairTaskControl(ctx) {
   function resumeTask(args, caller) {
     try {
       ctx.turnControl.assertWorkerAction(caller);
-      var worker = ctx.resolvePair(caller).partner;
+      var worker = ctx.resolvePair(caller, args, { mutation: true }).partner;
       if (worker.isProcessing || worker._queryStarting || current(worker)) throw new Error("the Split Worker is not idle");
       var prior = worker._lastInterruptedPairTask;
       if (!prior) throw new Error("the Split Worker has no resumable interrupted task");
       var message = cleanText(args.message, 30000) || prior.message;
-      return ctx.sendFollowup({ message: message, wait: args.wait, timeoutSeconds: args.timeoutSeconds, taskId: args.taskId }, caller);
+      return ctx.sendFollowup({ message: message, wait: args.wait, timeoutSeconds: args.timeoutSeconds, taskId: args.taskId, workerId: worker.localId }, caller);
     } catch (err) { return result({ status: "rejected", reason: err.message || String(err) }); }
   }
   function report(args, worker) {
@@ -185,6 +189,7 @@ function attachPairTaskControl(ctx) {
       if (!resolved || resolved.worker !== worker) throw new Error("only the exact configured Split Worker can report an outcome");
       var active = current(worker);
       if (!active || args.taskId !== active.taskId) throw new Error("taskId must match the exact active delegated task");
+      if (!matchesGeneration(worker, active)) throw new Error("the active task no longer matches this Worker generation");
       var outcome = typeof args.outcome === "string" ? args.outcome.trim().toLowerCase() : "";
       if (OUTCOMES.indexOf(outcome) === -1) throw new Error("outcome must be completed, partial, failed, or interrupted");
       active.reportedOutcome = {
@@ -200,11 +205,12 @@ function attachPairTaskControl(ctx) {
       return result({ status: "recorded", taskId: active.taskId });
     } catch (err) { return result({ status: "rejected", reason: err.message || String(err) }); }
   }
-  function complete(worker, caller, token, observedStatus, response, error) {
+  function prepareCompletion(worker, caller, token, observedStatus, response, error, forcedInterruption) {
     if (!token) return null;
     if (token.outcomeEnvelope) return token.outcomeEnvelope;
-    var interruption = worker._pairInterruption && worker._pairInterruption.targetTaskId === token.taskId ? worker._pairInterruption : null;
-    if (interruption) interruption.completedAt = Date.now();
+    var currentInterruption = forcedInterruption ||
+      (worker._pairInterruption && worker._pairInterruption.targetTaskId === token.taskId ? worker._pairInterruption : null);
+    var interruption = currentInterruption ? Object.assign({}, currentInterruption, { completedAt: Date.now() }) : null;
     var report = token.reportedOutcome || null;
     var finalStatus = error ? "failed" : (interruption ? "interrupted" : (report ? report.outcome : observedStatus));
     var envelope = {
@@ -224,10 +230,16 @@ function attachPairTaskControl(ctx) {
       response: response || "",
       error: error || null,
     };
-    token.status = finalStatus;
+    return envelope;
+  }
+  function commitCompletion(worker, caller, token, envelope) {
+    if (!token || !envelope) return envelope || null;
+    if (token.outcomeEnvelope) return token.outcomeEnvelope;
+    token.status = envelope.status;
     token.outcomeEnvelope = envelope;
     worker._lastPairOutcome = envelope;
-    if (finalStatus === "interrupted" || finalStatus === "partial") worker._lastInterruptedPairTask = { taskId: token.taskId, message: token.message, generation: token.generation };
+    if (envelope.interruption) worker._pairInterruption = envelope.interruption;
+    if (envelope.status === "interrupted" || envelope.status === "partial") worker._lastInterruptedPairTask = { taskId: token.taskId, message: token.message, generation: token.generation };
     if (ctx.sm.sendAndRecord) {
       try { ctx.sm.sendAndRecord(worker, { type: "pair_task_completed", _internal: true,
         ownerId: caller.ownerId || null, driverOriginId: caller.sessionOriginId || null,
@@ -237,6 +249,10 @@ function attachPairTaskControl(ctx) {
     if (ctx.sm.sendToSession) ctx.sm.sendToSession(caller, { type: "partner_task_completed", outcome: envelope });
     return envelope;
   }
+  function complete(worker, caller, token, observedStatus, response, error) {
+    return commitCompletion(worker, caller, token,
+      prepareCompletion(worker, caller, token, observedStatus, response, error));
+  }
   function status(worker) {
     var active = current(worker);
     var registry = registryFor(worker);
@@ -261,23 +277,28 @@ function attachPairTaskControl(ctx) {
     next.status = "starting";
     next.startedAt = Date.now();
     queue.splice(queue.indexOf(next), 1);
-    Promise.resolve(ctx.sendFollowup({ message: next.message, wait: false, taskId: next.taskId }, caller)).then(function (delivery) {
+    Promise.resolve(ctx.sendFollowup({ message: next.message, wait: false, taskId: next.taskId, workerId: next.workerId }, caller)).then(function (delivery) {
       next.status = delivery && delivery.isError ? "failed" : "running";
       if (delivery && delivery.isError) next.error = delivery.content && delivery.content[0] && delivery.content[0].text || "Follow-up rejected";
     }, function (err) { next.status = "failed"; next.error = err.message || String(err); });
     return true;
   }
   function driverToolDefs(handlers) {
-    return [{ name: "queue_partner_followup", description: "Queue a distinct follow-up task behind the active Split Worker task.", inputSchema: buildShape({ message: { type: "string" }, taskId: { type: "string" } }, ["message"]), handler: handlers.queue },
-      { name: "inspect_partner_followups", description: "Inspect current, queued, interrupted, and last completed Split Worker task state.", inputSchema: buildShape({}), handler: handlers.inspect },
-      { name: "cancel_partner_followup", description: "Cancel one exact queued follow-up without interrupting active work.", inputSchema: buildShape({ taskId: { type: "string" } }, ["taskId"]), handler: handlers.cancel },
-      { name: "replace_partner_task", description: "Interrupt one exact active delegated task and queue a replacement task in the same Worker generation.", inputSchema: buildShape({ targetTaskId: { type: "string" }, message: { type: "string" }, taskId: { type: "string" }, reason: { type: "string" } }, ["targetTaskId", "message"]), handler: handlers.replace },
-      { name: "resume_partner_task", description: "Resume the last interrupted task as a new correlated task. A human Stop blocks this until a new user turn.", inputSchema: buildShape({ message: { type: "string" }, taskId: { type: "string" }, wait: { type: "boolean" }, timeoutSeconds: { type: "number" } }), handler: handlers.resume }];
+    var workerId = { type: "number", description: "Optional exact Worker session id; required when multiple Workers are configured." };
+    return [{ name: "queue_partner_followup", description: "Queue a distinct follow-up task behind the active Split Worker task.", inputSchema: buildShape({ message: { type: "string" }, taskId: { type: "string" }, workerId: workerId }, ["message"]), handler: handlers.queue },
+      { name: "inspect_partner_followups", description: "Inspect current, queued, interrupted, and last completed Split Worker task state.", inputSchema: buildShape({ workerId: workerId }), handler: handlers.inspect },
+      { name: "cancel_partner_followup", description: "Cancel one exact queued follow-up without interrupting active work.", inputSchema: buildShape({ taskId: { type: "string" }, workerId: workerId }, ["taskId"]), handler: handlers.cancel },
+      { name: "replace_partner_task", description: "Interrupt one exact active delegated task and queue a replacement task in the same Worker generation.", inputSchema: buildShape({ targetTaskId: { type: "string" }, message: { type: "string" }, taskId: { type: "string" }, reason: { type: "string" }, workerId: workerId }, ["targetTaskId", "message"]), handler: handlers.replace },
+      { name: "resume_partner_task", description: "Resume the last interrupted task as a new correlated task. A human Stop blocks this until a new user turn.", inputSchema: buildShape({ message: { type: "string" }, taskId: { type: "string" }, wait: { type: "boolean" }, timeoutSeconds: { type: "number" }, workerId: workerId }), handler: handlers.resume }];
   }
   function workerToolDefs(worker) {
     return [{ name: "report_partner_outcome", description: "Report structured, Worker-observed task outcome data. This does not claim Driver verification.", inputSchema: buildShape({ taskId: { type: "string" }, outcome: { type: "string" }, summary: { type: "string" }, changedFiles: { type: "array", items: { type: "string" } }, verifications: { type: "array", items: { type: "object" } }, unverified: { type: "array", items: { type: "string" } }, processes: { type: "array", items: { type: "string" } }, nextAction: { type: "string" } }, ["taskId", "outcome"]), handler: function (args) { return report(args || {}, worker); } }];
   }
-  return { begin: begin, cancel: cancel, cancelAll: cancelAll, complete: complete, drain: drain, driverToolDefs: driverToolDefs, ensureSystemInterruption: ensureSystemInterruption, inspect: inspect, markInterruption: markInterruption, queue: queue, replaceTask: replaceTask, resumeTask: resumeTask, status: status, workerToolDefs: workerToolDefs };
+  return { begin: begin, cancel: cancel, cancelAll: cancelAll, commitCompletion: commitCompletion, complete: complete,
+    prepareCompletion: prepareCompletion, drain: drain, driverToolDefs: driverToolDefs,
+    ensureSystemInterruption: ensureSystemInterruption, inspect: inspect, markInterruption: markInterruption,
+    matchesGeneration: matchesGeneration, queue: queue, replaceTask: replaceTask,
+    resumeTask: resumeTask, status: status, workerToolDefs: workerToolDefs };
 }
 
 module.exports = { attachPairTaskControl: attachPairTaskControl };

package/lib/project-pair-worker-close.js

@@ -0,0 +1,68 @@
+var multiWorkerFeature = require("./multi-worker-feature");
+var splitRoles = require("./session-split-group-roles");
+var generationOf = require("./session-split-group-v2-store").generationOf;
+
+function attachPairWorkerClose(ctx) {
+  function result(ws, msg, ok, error) {
+    ctx.sendTo(ws, {
+      type: "split_worker_close_result",
+      requestId: typeof msg.requestId === "string" ? msg.requestId : null,
+      ok: ok,
+      error: error || null,
+      groupId: typeof msg.groupId === "string" ? msg.groupId : null,
+      workerId: Number.isInteger(msg.workerId) ? msg.workerId : null,
+    });
+  }
+
+  function validate(ws, msg) {
+    if (ctx.isMate || !multiWorkerFeature.isEnabled(ctx.multiWorkerFeature)) {
+      throw new Error("Multi-Worker close is unavailable in this project");
+    }
+    if (!ctx.hasSocket(ws) || ws.readyState !== 1) throw new Error("The project socket is no longer active");
+    if (msg.projectSlug !== ctx.projectSlug) throw new Error("The project changed before the Worker was closed");
+    if (!Number.isInteger(msg.driverId) || ws._clayActiveSession !== msg.driverId) {
+      throw new Error("The active session must be the configured Driver");
+    }
+    var driver = ctx.sm.sessions.get(msg.driverId);
+    if (!driver || ctx.sm.sessions.get(driver.localId) !== driver) throw new Error("The exact Driver session is no longer live");
+    var actorId = ws._clayUser && ws._clayUser.id || null;
+    if ((driver.ownerId || null) !== actorId) throw new Error("The Driver owner does not match this socket");
+    if ((msg.driverOriginId || null) !== (driver.sessionOriginId || null)) throw new Error("The exact Driver identity changed");
+    var group = ctx.splitStore.groupForMember(driver.localId);
+    if (!group || group.id !== msg.groupId || (group.ownerId || null) !== actorId) throw new Error("The exact split group changed");
+    var roles = splitRoles.normalizePair(group.pair, group.members);
+    if (!roles.ok || roles.kind !== "versioned" || roles.driverId !== driver.localId) {
+      throw new Error("The configured Driver or Worker roles changed");
+    }
+    if (!Array.isArray(msg.expectedWorkerIds) || msg.expectedWorkerIds.join(",") !== roles.workerIds.join(",")) {
+      throw new Error("The configured Worker membership changed");
+    }
+    if (!Number.isInteger(msg.workerId) || roles.workerIds.indexOf(msg.workerId) === -1) {
+      throw new Error("The selected Worker changed");
+    }
+    var worker = ctx.sm.sessions.get(msg.workerId);
+    if (!worker || ctx.sm.sessions.get(worker.localId) !== worker || (worker.ownerId || null) !== actorId) {
+      throw new Error("The exact Worker session is no longer live");
+    }
+    if ((msg.workerOriginId || null) !== (worker.sessionOriginId || null) || msg.generation !== generationOf(worker)) {
+      throw new Error("The exact Worker identity or generation changed");
+    }
+    return { driver: driver, worker: worker };
+  }
+
+  function handleMessage(ws, msg) {
+    if (!msg || msg.type !== "split_worker_close") return false;
+    try {
+      var exact = validate(ws, msg);
+      ctx.closeWorker({ workerId: exact.worker.localId }, exact.driver);
+      result(ws, msg, true, null);
+    } catch (error) {
+      result(ws, msg, false, error.message || String(error));
+    }
+    return true;
+  }
+
+  return { handleMessage: handleMessage, validate: validate };
+}
+
+module.exports = { attachPairWorkerClose: attachPairWorkerClose };

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 };