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

package/lib/driver-continuation-pair.js

@@ -1,4 +1,5 @@
 var sessionProvenance = require("./session-provenance");
+var splitRoles = require("./session-split-group-roles");
 
 var ACTIVE_RUN_STATES = ["armed", "running", "reviewing", "waiting-worker", "waiting-user", "paused"];
 
@@ -37,7 +38,10 @@ function inspect(source, ctx) {
   if (!group.pair || group.pair.driverId !== source.localId) {
     return { ok: false, error: "Only the configured Driver can continue an attached split pair." };
   }
-  var worker = ctx.sm && ctx.sm.sessions.get(group.pair.workerId);
+  var roles = splitRoles.normalizePair(group.pair, group.members);
+  if (!roles.ok || roles.kind === "adhoc") return { ok: false, error: "The attached split pair roles are invalid." };
+  if (roles.kind === "versioned") return { ok: false, error: "Driver continuation does not yet support a multi-Worker group." };
+  var worker = ctx.sm && ctx.sm.sessions.get(roles.workerIds[0]);
   if (!worker || group.members.indexOf(worker.localId) === -1) return { ok: false, error: "The attached Split Worker is unavailable." };
   if ((source.ownerId || null) !== (worker.ownerId || null)) return { ok: false, error: "The attached Split Worker owner changed." };
   if (!sessionProvenance.isWorker(worker)) return { ok: false, error: "The attached split partner is not a verified Worker." };

package/lib/multi-worker-feature.js

@@ -0,0 +1,11 @@
+var ENABLED_GATE = Object.freeze({ feature: "multi-worker-runtime" });
+
+function fromServerConfig(config) {
+  return config && config.multiWorkerRuntimeEnabled === true ? ENABLED_GATE : null;
+}
+
+function isEnabled(gate) {
+  return gate === ENABLED_GATE;
+}
+
+module.exports = { fromServerConfig: fromServerConfig, isEnabled: isEnabled };

package/lib/project-pair-autonomous-stop.js

@@ -1,15 +1,21 @@
 function stopAutonomousWork(session, roles, turnControl, taskControl, workerPermission) {
   if (!roles) return false;
   var runId = session.autonomousRun && session.autonomousRun.id;
-  var cancelled = taskControl.cancelAll(roles.worker, runId);
-  var owned = roles.worker._pairDelegation && roles.worker._pairDelegation.autonomousRunId === runId;
-  if (!owned && !cancelled) return true;
+  var workers = roles.workers || [roles.worker];
+  var cancelled = 0, owned = [];
+  for (var wi = 0; wi < workers.length; wi++) {
+    cancelled += taskControl.cancelAll(workers[wi], runId);
+    if (workers[wi]._pairDelegation && workers[wi]._pairDelegation.autonomousRunId === runId) owned.push(workers[wi]);
+  }
+  if (!owned.length && !cancelled) return true;
   turnControl.markHumanStop(session);
-  if (!owned) return true;
-  taskControl.markInterruption(roles.worker, "user", "The Until complete run was stopped.");
-  workerPermission.cancelForSession(roles.worker, "The Until complete run was stopped.");
-  roles.worker.taskStopRequested = true;
-  if (roles.worker.abortController) roles.worker.abortController.abort();
+  if (!owned.length) return true;
+  for (var oi = 0; oi < owned.length; oi++) {
+    taskControl.markInterruption(owned[oi], "user", "The Until complete run was stopped.");
+    workerPermission.cancelForSession(owned[oi], "The Until complete run was stopped.");
+    owned[oi].taskStopRequested = true;
+    if (owned[oi].abortController) owned[oi].abortController.abort();
+  }
   return true;
 }
 

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

@@ -0,0 +1,59 @@
+var structuralClose = require("./project-pair-structural-close");
+
+function attachPairCloseTransaction(ctx) {
+  function close(args, caller) {
+    var resolved = ctx.resolvePair(caller, args);
+    var partner = resolved.partner;
+    var token = partner._pairDelegation || null;
+    var interrupted = !!(partner.isProcessing || partner._queryStarting);
+    var interruption = token && interrupted ? {
+      source: "driver",
+      reason: "The Driver closed the Split Worker pair.",
+      targetTaskId: token.taskId,
+      requestedAt: Date.now(),
+    } : null;
+    var response = token ? ctx.responseText(partner.history || [], token.startIndex) : "";
+    var failure = token ? ctx.errorSince(partner.history || [], token.startIndex) : null;
+    var outcome = token ? ctx.taskControl.prepareCompletion(partner, caller, token,
+      interrupted ? "interrupted" : "completed", response, failure, interruption) : null;
+    var prepared = token ? ctx.resultCapture.prepare(caller, partner, token, outcome) : { ok: true, prepared: false };
+    if (!prepared.ok) throw new Error(prepared.error || "could not durably capture the Worker outcome");
+    var postCommitError = null;
+    var result = structuralClose.removeSelectedWorker(ctx.store, resolved.group, caller, partner,
+      ctx.multiWorkerFeature, { afterPersist: function () {
+        try {
+          if (token) {
+            var finalized = ctx.resultCapture.finalizePrepared(token, outcome);
+            if (!finalized.ok) throw new Error(finalized.error || "prepared close outcome could not be committed");
+            partner._pairClosing = true;
+            token.response = response;
+            token.failure = failure;
+            token.interrupted = interrupted && !failure;
+            ctx.taskControl.commitCompletion(partner, caller, token, outcome);
+            ctx.resultCapture.acceptPrepared(caller, partner, token);
+          }
+        } catch (error) { postCommitError = error; }
+        finally { delete partner._pairClosing; }
+        return { ok: true };
+      } });
+    if (!result.ok) {
+      if (token && prepared.prepared && !prepared.duplicate) {
+        var rolledBack = ctx.resultCapture.rollbackPrepared(token, outcome);
+        if (!rolledBack.ok) throw new Error((result.error || "could not close the Worker pair") +
+          "; prepared result rollback failed: " + (rolledBack.error || "unknown error"));
+      }
+      throw new Error(result.error || "could not close the Worker pair");
+    }
+    if (interrupted) {
+      partner.taskStopRequested = true;
+      if (partner.abortController) partner.abortController.abort();
+    }
+    ctx.workerPermission.cancelForSession(partner, "The Driver closed the Split Worker pair.");
+    if (postCommitError) partner._pairCloseFinalizationError = postCommitError.message || String(postCommitError);
+    return { status: "closed", partnerId: partner.localId, interrupted: interrupted,
+      historyPreserved: true };
+  }
+  return { close: close };
+}
+
+module.exports = { attachPairCloseTransaction: attachPairCloseTransaction };

package/lib/project-pair-global-stop.js

@@ -0,0 +1,18 @@
+function stopAllWorkers(session, roles, ctx) {
+  if (!roles) return false;
+  for (var i = 0; i < roles.workers.length; i++) {
+    var worker = roles.workers[i];
+    if (worker._pairDelegation && worker._pairDelegation.outboxKey && ctx.resultOutbox) {
+      ctx.resultOutbox.markBlocked(worker._pairDelegation.outboxKey, "The human stopped this Split Worker turn.", "human_stop");
+    }
+    ctx.taskControl.markInterruption(worker, "user", "The human stopped this Split Worker turn.");
+    ctx.workerPermission.cancelForSession(worker, "The human stopped this Split Worker turn.");
+    worker.taskStopRequested = true;
+    if (worker.abortController) {
+      try { worker.abortController.abort(); } catch (e) {}
+    }
+  }
+  return true;
+}
+
+module.exports = { stopAllWorkers: stopAllWorkers };

package/lib/project-pair-lifecycle-status.js

@@ -0,0 +1,34 @@
+var pairUsage = require("./project-pair-usage");
+
+var MAX_TASK_PREVIEW_CHARS = 200;
+
+function clampText(value, max) {
+  var text = typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+  if (text.length > max) text = text.slice(0, max - 1) + "…";
+  return text;
+}
+
+function continuityStatus(session) {
+  var history = session.history || [];
+  var userTurns = 0;
+  var errors = 0;
+  for (var i = 0; i < history.length; i++) {
+    if (!history[i]) continue;
+    if (history[i].type === "user_message") userTurns++;
+    else if (history[i].type === "error") errors++;
+  }
+  var lastActivity = typeof session.lastActivity === "number" ? session.lastActivity : null;
+  return { historyEntries: history.length, userTurns: userTurns, errorEntries: errors,
+    idleSeconds: lastActivity ? Math.max(0, Math.round((Date.now() - lastActivity) / 1000)) : null };
+}
+
+function activityStatus(session) {
+  var token = session._pairDelegation || null;
+  return { isProcessing: !!(session.isProcessing || session._queryStarting), delegated: !!token,
+    currentTask: token ? clampText(token.message, MAX_TASK_PREVIEW_CHARS) : "",
+    currentTaskId: token && token.taskId || null, interruption: session._pairInterruption || null,
+    lastTurnInterrupted: !!session._lastTurnInterrupted };
+}
+
+module.exports = { activityStatus: activityStatus, clampText: clampText, continuityStatus: continuityStatus,
+  contextStatus: pairUsage.contextStatus, firstNumber: pairUsage.firstNumber };

package/lib/project-pair-lifecycle.js

@@ -1,12 +1,16 @@
 var eligibility = require("./session-driver-eligibility");
 var replacementState = require("./project-pair-replacement-state");
-var pairUsage = require("./project-pair-usage");
-var contextStatus = pairUsage.contextStatus;
-var firstNumber = pairUsage.firstNumber;
+var lifecycleStatus = require("./project-pair-lifecycle-status");
+var contextStatus = lifecycleStatus.contextStatus;
+var firstNumber = lifecycleStatus.firstNumber;
+var continuityStatus = lifecycleStatus.continuityStatus;
+var activityStatus = lifecycleStatus.activityStatus;
+var clampText = lifecycleStatus.clampText;
+var pairTarget = require("./session-pair-target");
+var splitRoles = require("./session-split-group-roles");
 
 var MAX_GENERATIONS = 5;
 var MAX_NOTE_CHARS = 400;
-var MAX_TASK_PREVIEW_CHARS = 200;
 
 var EVALUATION_OUTCOMES = ["succeeded", "partial", "failed", "abandoned"];
 
@@ -21,57 +25,23 @@ function toolError(message) {
   });
 }
 
-function clampText(value, max) {
-  var text = typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
-  if (text.length > max) text = text.slice(0, max - 1) + "…";
-  return text;
-}
-
 function replacementFingerprint(args, worker) {
   return JSON.stringify({ sourceWorkerId: worker.localId, interrupt: args.interrupt === true,
     vendor: args.workerVendor || "", model: args.workerModel || "", effort: args.workerEffort || "",
     message: args.message || "", evaluation: args.evaluation || null });
 }
 
-function continuityStatus(session) {
-  var history = session.history || [];
-  var userTurns = 0;
-  var errors = 0;
-  for (var i = 0; i < history.length; i++) {
-    if (!history[i]) continue;
-    if (history[i].type === "user_message") userTurns++;
-    else if (history[i].type === "error") errors++;
-  }
-  var lastActivity = typeof session.lastActivity === "number" ? session.lastActivity : null;
-  return {
-    historyEntries: history.length,
-    userTurns: userTurns,
-    errorEntries: errors,
-    idleSeconds: lastActivity ? Math.max(0, Math.round((Date.now() - lastActivity) / 1000)) : null,
-  };
-}
-
-function activityStatus(session) {
-  var token = session._pairDelegation || null;
-  return {
-    isProcessing: !!(session.isProcessing || session._queryStarting),
-    delegated: !!token,
-    currentTask: token ? clampText(token.message, MAX_TASK_PREVIEW_CHARS) : "",
-    currentTaskId: token && token.taskId || null,
-    interruption: session._pairInterruption || null,
-    lastTurnInterrupted: !!session._lastTurnInterrupted,
-  };
-}
-
 function attachPairLifecycle(ctx) {
   var sm = ctx.sm;
   var store = ctx.splitStore;
   var turnControl = ctx.turnControl;
 
-  function ledgerFor(driver) {
+  function ledgerFor(driver, selectedWorker) {
     if (!Array.isArray(driver._workerGenerations)) driver._workerGenerations = [];
     var group = store.groupForMember(driver.localId);
-    var worker = group && group.pair && sm.sessions.get(group.pair.workerId);
+    var normalized = splitRoles.normalizePair(group && group.pair, group && group.members);
+    var fallbackId = normalized.ok && normalized.kind !== "adhoc" && normalized.workerIds.length === 1 ? normalized.workerIds[0] : null;
+    var worker = selectedWorker || fallbackId != null && sm.sessions.get(fallbackId);
     var generation = worker && (worker._pairGeneration || worker.sessionProvenance && worker.sessionProvenance.generation);
     if (worker && Number.isInteger(generation) && generation > 0 && !findGeneration(driver, worker)) {
       driver._workerGenerations.push({
@@ -91,7 +61,7 @@ function attachPairLifecycle(ctx) {
     return driver._workerGenerations;
   }
   function recordGenerationStart(driver, worker) {
-    var ledger = ledgerFor(driver);
+    var ledger = ledgerFor(driver, worker);
     var existing = findGeneration(driver, worker);
     if (existing && !existing.endedAt) {
       worker._pairGeneration = existing.generation;
@@ -166,6 +136,8 @@ function attachPairLifecycle(ctx) {
     return record;
   }
   function resolveDriverPair(caller) {
+    var args = arguments[1];
+    var options = arguments[2];
     if (!caller) throw new Error("pair lifecycle tools require a session-bound tool server");
     if (sm.sessions.get(caller.localId) !== caller) {
       throw new Error("this session is no longer live; the pair tools are bound to an exact session");
@@ -176,24 +148,25 @@ function attachPairLifecycle(ctx) {
     if (!group) throw new Error("this session is not in a split group");
     if (!group.pair) throw new Error("this split group has no Driver/Split Worker roles");
     if (group.pair.driverId !== caller.localId) throw new Error("only the configured Driver can direct this pair");
-    var worker = sm.sessions.get(group.pair.workerId);
-    if (!worker) throw new Error("split partner session was not found");
+    var targetOptions = Object.assign({}, options || { mutation: true }, {
+      multiWorkerFeature: ctx.multiWorkerFeature,
+    });
+    var resolved = pairTarget.resolveGroupTarget(sm, group, caller, args, targetOptions);
+    var worker = resolved.partner;
     if ((caller.ownerId || null) !== (worker.ownerId || null)) throw new Error("split partner access denied");
-    return { group: group, worker: worker };
+    return { group: resolved.group, worker: resolved.partner, role: resolved.role, workerId: resolved.workerId };
   }
-
   function replaceBlockedReason(worker) {
     if (worker.isProcessing || worker._queryStarting) return "the Split Worker is mid-turn";
     if (worker._pairDelegation) return "a delegated task is still open";
     return null;
   }
-
-  function partnerStatus(caller) {
-    var resolved = resolveDriverPair(caller);
+  function partnerStatus(caller, args) {
+    var resolved = resolveDriverPair(caller, args, { readOnly: true });
     var worker = resolved.worker;
     var blocked = turnControl.blockedReason(caller) || replaceBlockedReason(worker);
     var resumeBlocked = turnControl.blockedReason(caller) || (worker.isProcessing || worker._queryStarting ? "the Split Worker is mid-turn" : (!worker._pairInterruption ? "the Split Worker has no interrupted task" : null));
-    var ledger = ledgerFor(caller).map(function (record) {
+    var ledger = ledgerFor(caller, worker).map(function (record) {
       return {
         generation: record.generation,
         vendor: record.vendor,
@@ -245,18 +218,16 @@ function attachPairLifecycle(ctx) {
       generations: ledger,
     };
   }
-
   function sourcePairRegistered(caller, worker) {
     try {
       if (sm.sessions.get(caller.localId) !== caller || sm.sessions.get(worker.localId) !== worker) return false;
       if ((caller.ownerId || null) !== (worker.ownerId || null)) return false;
       var group = store.groupForMember(caller.localId);
-      return !!(group && group.pair && group.pair.driverId === caller.localId &&
-        group.pair.workerId === worker.localId && group.members.indexOf(caller.localId) !== -1 &&
-        group.members.indexOf(worker.localId) !== -1);
+      var normalized = splitRoles.normalizePair(group && group.pair, group && group.members);
+      return !!(normalized.ok && normalized.kind !== "adhoc" && normalized.driverId === caller.localId &&
+        normalized.workerIds.indexOf(worker.localId) !== -1);
     } catch (e) { return false; }
   }
-
   function restoreSourcePair(ws, caller, worker) {
     try {
       return store.create(ws, {
@@ -265,23 +236,25 @@ function attachPairLifecycle(ctx) {
       });
     } catch (e) { return { ok: false, error: e.message || String(e) }; }
   }
-
-  function replacementTargetRegistered(caller, oldWorker) {
+  function replacementTargetRegistered(caller, oldWorker, sourceWorkerIds) {
     try {
       if (sm.sessions.get(caller.localId) !== caller || sm.sessions.get(oldWorker.localId) !== oldWorker) return null;
       var group = store.groupForMember(caller.localId);
-      if (!group || !group.pair || group.pair.driverId !== caller.localId ||
-          group.pair.workerId === oldWorker.localId) return null;
-      var target = sm.sessions.get(group.pair.workerId);
+      var normalized = splitRoles.normalizePair(group && group.pair, group && group.members);
+      if (!normalized.ok || normalized.kind === "adhoc" || normalized.driverId !== caller.localId) return null;
+      var candidates = normalized.workerIds.filter(function (id) { return sourceWorkerIds.indexOf(id) === -1; });
+      if (candidates.length !== 1) return null;
+      var target = sm.sessions.get(candidates[0]);
       if (!target || sm.sessions.get(target.localId) !== target) return null;
       return (caller.ownerId || null) === (target.ownerId || null) ? target : null;
     } catch (e) { return null; }
   }
-
   function replacePartner(args, caller) {
-    var resolved = resolveDriverPair(caller);
+    var resolved = resolveDriverPair(caller, args, { mutation: true });
     var group = resolved.group;
     var oldWorker = resolved.worker;
+    var versioned = resolved.role.kind === "versioned";
+    var sourceWorkerIds = resolved.role.workerIds.slice();
     ledgerFor(caller);
     turnControl.assertWorkerAction(caller);
     var replacementEntry = replacementState.begin(caller, args.transactionId, oldWorker, replacementFingerprint(args, oldWorker));
@@ -336,9 +309,11 @@ function attachPairLifecycle(ctx) {
         ctx.cancelWorkerPermissions(oldWorker, "The Driver replaced this Split Worker.");
       }
 
-      replacementState.stage(replacementEntry.transaction, "dissolving_source_pair");
-      var dissolved = store.dissolve(ws, { id: group.id });
-      if (!dissolved.ok) throw new Error(dissolved.error || "could not dissolve the existing pair");
+      if (!versioned) {
+        replacementState.stage(replacementEntry.transaction, "dissolving_source_pair");
+        var dissolved = store.dissolve(ws, { id: group.id });
+        if (!dissolved.ok) throw new Error(dissolved.error || "could not dissolve the existing pair");
+      }
     } catch (precreateError) {
       var sourceIntact = sourcePairRegistered(caller, oldWorker);
       var precreateRestored = sourceIntact ? { ok: true } : restoreSourcePair(ws, caller, oldWorker);
@@ -351,13 +326,20 @@ function attachPairLifecycle(ctx) {
     var created;
     try {
       replacementState.stage(replacementEntry.transaction, "creating_target");
-      created = ctx.createWorkerForDriver(caller, {
+      var createReplacement = versioned ? ctx.replaceWorkerForDriver : ctx.createWorkerForDriver;
+      created = createReplacement(caller, versioned ? oldWorker : {
         workerVendor: typeof args.workerVendor === "string" ? args.workerVendor : "",
         workerModel: typeof args.workerModel === "string" ? args.workerModel : "",
         workerEffort: typeof args.workerEffort === "string" ? args.workerEffort : "",
-      });
+      }, versioned ? {
+        workerVendor: typeof args.workerVendor === "string" ? args.workerVendor : "",
+        workerModel: typeof args.workerModel === "string" ? args.workerModel : "",
+        workerEffort: typeof args.workerEffort === "string" ? args.workerEffort : "",
+        expectedGroup: group,
+        expectedWorkerIds: sourceWorkerIds,
+      } : undefined);
     } catch (e) {
-      var target = replacementTargetRegistered(caller, oldWorker);
+      var target = replacementTargetRegistered(caller, oldWorker, sourceWorkerIds);
       if (target) {
         var targetClosed = closeGeneration(caller, oldWorker);
         var targetGeneration = recordGenerationStart(caller, target);
@@ -404,7 +386,7 @@ function attachPairLifecycle(ctx) {
 
     var message = typeof args.message === "string" ? args.message.trim() : "";
     if (!message) return Promise.resolve(result);
-    return Promise.resolve(ctx.sendToPartner({ message: message, wait: args.wait, timeoutSeconds: args.timeoutSeconds }, caller))
+    return Promise.resolve(ctx.sendToPartner({ message: message, wait: args.wait, timeoutSeconds: args.timeoutSeconds, workerId: created.worker.localId }, caller))
       .then(function (delivered) {
         result.delivery = delivered;
         return result;
@@ -430,8 +412,8 @@ function attachPairLifecycle(ctx) {
   }
 
   function recordEvaluation(args, caller) {
-    var resolved = resolveDriverPair(caller);
-    var ledger = ledgerFor(caller);
+    var resolved = resolveDriverPair(caller, args, { mutation: true });
+    var ledger = ledgerFor(caller, resolved.worker);
     var target = Number.isInteger(args.generation)
       ? (function () {
         for (var i = 0; i < ledger.length; i++) {
@@ -453,14 +435,14 @@ function attachPairLifecycle(ctx) {
     };
   }
 
-  function optionalStatus(boundSession) {
-    try { return partnerStatus(boundSession); } catch (e) { return null; }
+  function optionalStatus(boundSession, args) {
+    try { return partnerStatus(boundSession, args); } catch (e) { return null; }
   }
 
   function toolHandlers(boundSession) {
     return {
-      status: function () {
-        try { return toolResult(partnerStatus(boundSession)); }
+      status: function (args) {
+        try { return toolResult(partnerStatus(boundSession, args || {})); }
         catch (e) { return toolError(e.message || String(e)); }
       },
       replace: function (args) {

package/lib/project-pair-message.js

@@ -17,7 +17,7 @@ function attachPairMessage(ctx) {
     if (!id) return toolResult({ status: "rejected", requestId: null, reason: "requestId is invalid" });
     try {
       ctx.turnControl.assertWorkerAction(caller);
-      var resolved = ctx.resolvePair(caller);
+      var resolved = ctx.resolvePair(caller, args, { mutation: true });
       var worker = resolved.partner;
       var message = typeof args.message === "string" ? args.message.trim() : "";
       if (!message) return toolResult({ status: "rejected", requestId: id, partnerId: worker.localId, reason: "message is required" });

package/lib/project-pair-owned-stop.js

@@ -1,10 +1,13 @@
 function stopOwnedPair(session, roles, turnControl, taskControl, workerPermission, reason) {
   if (!roles) return false;
   turnControl.markHumanStop(session);
-  taskControl.cancelAll(roles.worker);
-  taskControl.markInterruption(roles.worker, "user", reason || "The human stopped this scheduled run.");
-  workerPermission.cancelForSession(roles.worker, reason || "The human stopped this scheduled run.");
-  var members = [roles.driver, roles.worker];
+  var workers = roles.workers || [roles.worker];
+  for (var wi = 0; wi < workers.length; wi++) {
+    taskControl.cancelAll(workers[wi]);
+    taskControl.markInterruption(workers[wi], "user", reason || "The human stopped this scheduled run.");
+    workerPermission.cancelForSession(workers[wi], reason || "The human stopped this scheduled run.");
+  }
+  var members = [roles.driver].concat(workers);
   for (var i = 0; i < members.length; i++) {
     members[i].taskStopRequested = true;
     if (members[i].queryInstance && typeof members[i].queryInstance.close === "function") {

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

@@ -1,4 +1,10 @@
 function attachPairResultCapture(ctx) {
+  var splitRoles = require("./session-split-group-roles");
+  function current(caller, partner, token) {
+    var group = ctx.store.groupForMember(partner.localId);
+    return !!(group && group.id === token.groupId && partner._pairDelegation === token &&
+      splitRoles.matchesLiveTarget(ctx.sm, group, caller, partner) && splitRoles.tokenMatchesWorker(partner, token));
+  }
   function begin(caller, partner, token, message, projectSlug) {
     if (!ctx.resultOutbox) return { ok: true };
     var driverOriginId = ctx.resultOutbox.stableOrigin(caller), workerOriginId = ctx.resultOutbox.stableOrigin(partner);
@@ -6,14 +12,15 @@ function attachPairResultCapture(ctx) {
     var started = ctx.resultOutbox.begin({ ownerId: caller.ownerId, projectSlug: projectSlug,
       driverOriginId: driverOriginId, workerOriginId: workerOriginId,
       taskId: token.taskId, generation: token.generation, driverSessionId: caller.localId,
-      workerSessionId: partner.localId, historyStartIndex: token.startIndex, message: message,
+      workerSessionId: partner.localId, groupId: token.groupId,
+      historyStartIndex: token.startIndex, message: message,
       deliveryRoute: token.wait === true ? "blocking" : "callback" });
     if (started.ok) token.outboxKey = started.key;
     return started;
   }
   function finish(caller, partner, token, delivered) {
     var group = ctx.store.groupForMember(partner.localId);
-    if (token._captureFinished || partner._pairDelegation !== token || !group || group.id !== token.groupId || group.members.indexOf(caller.localId) === -1 || group.members.indexOf(partner.localId) === -1 || (group.pair && (group.pair.driverId !== caller.localId || group.pair.workerId !== partner.localId)) || ctx.sm.sessions.get(caller.localId) !== caller || ctx.sm.sessions.get(partner.localId) !== partner || caller.ownerId !== partner.ownerId) return false;
+    if (token._captureFinished || !current(caller, partner, token)) return false;
     token._captureFinished = true;
     try {
       if (typeof ctx.onPartnerResult === "function") ctx.onPartnerResult(caller, partner, token);
@@ -37,7 +44,7 @@ function attachPairResultCapture(ctx) {
     }
     delete token._capturePending;
     var resumed = delivered ? true : ctx.resumeDriverWithResult(caller, partner, token);
-    ctx.drain(caller, partner);
+    if (!partner._pairClosing) ctx.drain(caller, partner);
     return resumed;
   }
   function capture(caller, partner, token, outcome) {
@@ -50,12 +57,12 @@ function attachPairResultCapture(ctx) {
         token._captureInProgress = false;
         if (retryResult && retryResult.ok) {
           token._captureComplete = true;
-          var record = ctx.resultOutbox.get(token.outboxKey);
-          if (typeof ctx.onStateChange === "function") ctx.onStateChange(caller, record);
-          if (record && record.deliveryRoute === "callback") deliver(caller, partner, token);
+          var capturedRecord = ctx.resultOutbox.get(token.outboxKey);
+          if (typeof ctx.onStateChange === "function") ctx.onStateChange(caller, capturedRecord);
+          if (capturedRecord && capturedRecord.deliveryRoute === "callback") deliver(caller, partner, token);
           else finish(caller, partner, token);
         }
-      });
+      }, function () { return current(caller, partner, token); });
     } catch (error) {
       token._captureInProgress = false;
       token._capturePending = true;
@@ -64,9 +71,9 @@ function attachPairResultCapture(ctx) {
     }
     if (saved.ok) { token._captureInProgress = false; token._captureComplete = true; }
     if (saved.ok) {
-      var current = ctx.resultOutbox.get(token.outboxKey);
-      if (typeof ctx.onStateChange === "function") ctx.onStateChange(caller, current);
-      var delivered = current && current.deliveryRoute === "callback" ? deliver(caller, partner, token) : finish(caller, partner, token);
+      var capturedRecord = ctx.resultOutbox.get(token.outboxKey);
+      if (typeof ctx.onStateChange === "function") ctx.onStateChange(caller, capturedRecord);
+      var delivered = capturedRecord && capturedRecord.deliveryRoute === "callback" ? deliver(caller, partner, token) : finish(caller, partner, token);
       return delivered === false && token._capturePending ? false : delivered;
     }
     token._capturePending = true;
@@ -76,11 +83,34 @@ function attachPairResultCapture(ctx) {
     }
     return false;
   }
+  function prepare(caller, partner, token, outcome) {
+    if (!ctx.resultOutbox || !token.outboxKey) return { ok: true, prepared: false };
+    var saved = ctx.resultOutbox.prepareCapture(token.outboxKey, outcome);
+    return saved.ok ? { ok: true, prepared: true, duplicate: !!saved.duplicate } : saved;
+  }
+  function rollbackPrepared(token, outcome) {
+    if (!ctx.resultOutbox || !token.outboxKey) return { ok: true };
+    return ctx.resultOutbox.rollbackPreparedCapture(token.outboxKey, outcome);
+  }
+  function finalizePrepared(token, outcome) {
+    if (!ctx.resultOutbox || !token.outboxKey) return { ok: true, record: null };
+    return ctx.resultOutbox.finalizePreparedCapture(token.outboxKey, outcome);
+  }
+  function acceptPrepared(caller, partner, token) {
+    if (ctx.resultOutbox && token.outboxKey) {
+      token._captureComplete = true;
+      var record = ctx.resultOutbox.get(token.outboxKey);
+      if (typeof ctx.onStateChange === "function") ctx.onStateChange(caller, record);
+      return record && record.deliveryRoute === "callback" ? deliver(caller, partner, token) : finish(caller, partner, token);
+    }
+    return finish(caller, partner, token);
+  }
   function deliver(caller, partner, token) {
     if (!ctx.delivery) return finish(caller, partner, token);
     return ctx.delivery.wake(caller, partner, token);
   }
-  return { begin: begin, capture: capture, deliver: deliver, finish: finish };
+  return { begin: begin, capture: capture, prepare: prepare, finalizePrepared: finalizePrepared, rollbackPrepared: rollbackPrepared,
+    acceptPrepared: acceptPrepared, deliver: deliver, finish: finish };
 }
 
 module.exports = { attachPairResultCapture: attachPairResultCapture };

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

@@ -1,5 +1,6 @@
 var RETRY_DELAY_MS = 50;
 var DEFAULT_ACCEPTANCE_TIMEOUT_MS = 15000;
+var splitRoles = require("./session-split-group-roles");
 
 function attachPairResultDelivery(ctx) {
   function recordMatches(caller, partner, token, record) {
@@ -9,9 +10,9 @@ function attachPairResultDelivery(ctx) {
   }
   function valid(caller, partner, token) {
     var group = ctx.store.groupForMember(partner.localId), record = ctx.outbox.get(token.outboxKey);
-    return !!(group && group.id === token.groupId && group.members.indexOf(caller.localId) !== -1 &&
-      group.members.indexOf(partner.localId) !== -1 && group.pair && group.pair.driverId === caller.localId &&
-      group.pair.workerId === partner.localId && ctx.sm.sessions.get(caller.localId) === caller &&
+    return !!(group && group.id === token.groupId && splitRoles.matchesLiveTarget(ctx.sm, group, caller, partner) &&
+      splitRoles.tokenMatchesWorker(partner, token) &&
+      ctx.sm.sessions.get(caller.localId) === caller &&
       ctx.sm.sessions.get(partner.localId) === partner && caller.ownerId === partner.ownerId &&
       !caller.destroying && !partner.destroying && !ctx.blockedReason(caller) && partner._pairDelegation === token &&
       recordMatches(caller, partner, token, record));