clay-server 4.2.0 → 4.3.0-beta.1

package/lib/session-pair-turn-control.js

@@ -8,6 +8,7 @@
 
 var MAX_CREATIONS_PER_TURN = 2;
 var MAX_REPLACEMENTS_PER_TURN = 1;
+var MAX_FAILED_REPLACEMENT_ATTEMPTS_PER_TURN = 2;
 var MAX_OPERATION_ID_CHARS = 120;
 
 function attachPairTurnControl(ctx) {
@@ -23,9 +24,13 @@ function attachPairTurnControl(ctx) {
         stoppedWorkerId: null,
         creations: 0,
         replacements: 0,
+        failedReplacementAttempts: 0,
         operations: Object.create(null),
       };
     }
+    if (!Number.isFinite(driver._pairTurnControl.failedReplacementAttempts)) {
+      driver._pairTurnControl.failedReplacementAttempts = 0;
+    }
     return driver._pairTurnControl;
   }
 
@@ -56,6 +61,7 @@ function attachPairTurnControl(ctx) {
     state.stoppedWorkerId = null;
     state.creations = 0;
     state.replacements = 0;
+    state.failedReplacementAttempts = 0;
     state.operations = Object.create(null);
     return true;
   }
@@ -88,20 +94,28 @@ function attachPairTurnControl(ctx) {
     if (kind === "replace" && state.replacements >= MAX_REPLACEMENTS_PER_TURN) {
       throw new Error("the Split Worker replacement limit for this human turn has been reached; wait for a new human message before replacing it again");
     }
+    if (kind === "replace" && state.failedReplacementAttempts >= MAX_FAILED_REPLACEMENT_ATTEMPTS_PER_TURN) {
+      throw new Error("the Split Worker replacement failure limit for this human turn has been reached; wait for a new human message before retrying replacement");
+    }
     if (state.creations >= MAX_CREATIONS_PER_TURN) {
       throw new Error("the Split Worker creation limit for this human turn has been reached; wait for a new human message before creating another Worker");
     }
     state.creations += 1;
     if (kind === "replace") state.replacements += 1;
-    return { driver: driver, kind: kind, active: true };
+    return { driver: driver, kind: kind, turnSerial: state.serial, active: true };
   }
 
   function releaseCreation(ticket) {
-    if (!ticket || !ticket.active || !liveSession(ticket.driver)) return;
+    if (!ticket || !ticket.active) return;
     ticket.active = false;
+    if (!liveSession(ticket.driver)) return;
     var state = stateFor(ticket.driver);
+    if (state.serial !== ticket.turnSerial) return;
     state.creations = Math.max(0, state.creations - 1);
-    if (ticket.kind === "replace") state.replacements = Math.max(0, state.replacements - 1);
+    if (ticket.kind === "replace") {
+      state.replacements = Math.max(0, state.replacements - 1);
+      state.failedReplacementAttempts += 1;
+    }
   }
 
   function operationId(value) {
@@ -136,6 +150,7 @@ function attachPairTurnControl(ctx) {
       turnSerial: state.serial,
       creationsThisTurn: state.creations,
       replacementsThisTurn: state.replacements,
+      failedReplacementAttemptsThisTurn: state.failedReplacementAttempts,
     };
   }
 
@@ -154,5 +169,6 @@ function attachPairTurnControl(ctx) {
 module.exports = {
   MAX_CREATIONS_PER_TURN: MAX_CREATIONS_PER_TURN,
   MAX_REPLACEMENTS_PER_TURN: MAX_REPLACEMENTS_PER_TURN,
+  MAX_FAILED_REPLACEMENT_ATTEMPTS_PER_TURN: MAX_FAILED_REPLACEMENT_ATTEMPTS_PER_TURN,
   attachPairTurnControl: attachPairTurnControl,
 };

package/lib/session-split-group-anchors.js

@@ -0,0 +1,44 @@
+function value(input) {
+  return typeof input === "string" && input ? input : null;
+}
+
+function pairFor(session, previousCli, previousOrigin) {
+  return {
+    cli: value(session && session.cliSessionId) || value(previousCli),
+    origin: value(session && session.sessionOriginId) || value(previousOrigin),
+  };
+}
+
+function memberAnchors(group, sessions) {
+  var previousCli = Array.isArray(group.memberCliIds) ? group.memberCliIds : [null, null];
+  var previousOrigin = Array.isArray(group.memberOriginIds) ? group.memberOriginIds : [null, null];
+  var left = pairFor(sessions.get(group.members[0]), previousCli[0], previousOrigin[0]);
+  var right = pairFor(sessions.get(group.members[1]), previousCli[1], previousOrigin[1]);
+  return { cli: [left.cli, right.cli], origin: [left.origin, right.origin] };
+}
+
+function pairAnchors(group, sessions) {
+  if (!group.pair) return null;
+  var previousCli = Array.isArray(group.pairCliIds) ? group.pairCliIds : [null, null];
+  var previousOrigin = Array.isArray(group.pairOriginIds) ? group.pairOriginIds : [null, null];
+  var driver = pairFor(sessions.get(group.pair.driverId), previousCli[0], previousOrigin[0]);
+  var worker = pairFor(sessions.get(group.pair.workerId), previousCli[1], previousOrigin[1]);
+  return { cli: [driver.cli, worker.cli], origin: [driver.origin, worker.origin] };
+}
+
+function findSession(sessions, cliId, originId) {
+  var cli = value(cliId);
+  var origin = value(originId);
+  if (!cli && !origin) return null;
+  var found = null;
+  var ambiguous = false;
+  sessions.forEach(function (session) {
+    if (cli && session.cliSessionId !== cli) return;
+    if (origin && session.sessionOriginId !== origin) return;
+    if (found && found !== session) ambiguous = true;
+    else found = session;
+  });
+  return ambiguous ? null : found;
+}
+
+module.exports = { findSession: findSession, memberAnchors: memberAnchors, pairAnchors: pairAnchors };

package/lib/session-split-groups.js

@@ -1,16 +1,14 @@
 var crypto = require("crypto");
 var fs = require("fs");
 var path = require("path");
-
+var durableAnchors = require("./session-split-group-anchors");
 function truncateTitle(title) {
   var value = String(title || "New Session");
   return value.length > 20 ? value.slice(0, 19) + "…" : value;
 }
-
 function autoGroupName(leftTitle, rightTitle) {
   return truncateTitle(leftTitle) + " | " + truncateTitle(rightTitle);
 }
-
 function createSplitGroupStore(opts) {
   var sessions = opts.sessions;
   var groupsFile = path.join(opts.sessionsDir, "split-groups.json");
@@ -18,61 +16,39 @@ function createSplitGroupStore(opts) {
   var broadcast = opts.broadcast || function () {};
   var onPairChanged = opts.onPairChanged || function () {};
   var groups = [];
-
-  // localIds are reassigned on every daemon restart (loadSessions renumbers
-  // by createdAt), so persisted member localIds go stale as soon as the
-  // session set changes. cliSessionIds are the durable anchor: keep them on
-  // every record and remap members from them at load.
-  function currentCliIds(group) {
-    var left = sessions.get(group.members[0]);
-    var right = sessions.get(group.members[1]);
-    var prev = Array.isArray(group.memberCliIds) ? group.memberCliIds : [null, null];
-    return [
-      (left && left.cliSessionId) || prev[0] || null,
-      (right && right.cliSessionId) || prev[1] || null,
-    ];
-  }
-
+  var stagedTransfers = [];
   function refreshPairAnchors(group) {
     if (!group.pair) return;
-    var driver = sessions.get(group.pair.driverId);
-    var worker = sessions.get(group.pair.workerId);
-    group.pairCliIds = [
-      (driver && driver.cliSessionId) || (group.pairCliIds && group.pairCliIds[0]) || null,
-      (worker && worker.cliSessionId) || (group.pairCliIds && group.pairCliIds[1]) || null,
-    ];
+    var anchors = durableAnchors.pairAnchors(group, sessions);
+    group.pairCliIds = anchors.cli;
+    group.pairOriginIds = anchors.origin;
   }
-
-  function sessionByCliId(cliId) {
-    if (!cliId) return null;
-    var found = null;
-    sessions.forEach(function (s) {
-      if (s.cliSessionId === cliId) found = s;
-    });
-    return found;
-  }
-
   function save() {
     for (var gi = 0; gi < groups.length; gi++) {
-      groups[gi].memberCliIds = currentCliIds(groups[gi]);
+      var anchors = durableAnchors.memberAnchors(groups[gi], sessions);
+      groups[gi].memberCliIds = anchors.cli;
+      groups[gi].memberOriginIds = anchors.origin;
       refreshPairAnchors(groups[gi]);
     }
+    var serialized = JSON.stringify(groups, null, 2) + "\n";
+    if (typeof opts.persistGroups === "function") {
+      if (opts.persistGroups(groupsFile, serialized) === false) throw new Error("Split group persistence returned false");
+      return;
+    }
     var tmp = groupsFile + ".tmp." + process.pid;
     fs.mkdirSync(opts.sessionsDir, { recursive: true });
-    fs.writeFileSync(tmp, JSON.stringify(groups, null, 2) + "\n");
+    fs.writeFileSync(tmp, serialized);
     if (process.platform !== "win32") {
       try { fs.chmodSync(tmp, 0o600); } catch (e) {}
     }
     fs.renameSync(tmp, groupsFile);
   }
-
   function validRecord(group) {
     return group && typeof group.id === "string" && Array.isArray(group.members) &&
       group.members.length === 2 && group.members[0] !== group.members[1] &&
       Number.isInteger(group.members[0]) && Number.isInteger(group.members[1]) &&
       sessions.has(group.members[0]) && sessions.has(group.members[1]);
   }
-
   function load() {
     var loaded = [];
     var shouldRewrite = false;
@@ -86,18 +62,22 @@ function createSplitGroupStore(opts) {
     groups = loaded.filter(function (group) {
       // Remap members from the durable cliSessionIds; the stored localIds
       // are only trusted for legacy records that predate memberCliIds.
-      if (group && Array.isArray(group.memberCliIds)) {
-        var left = sessionByCliId(group.memberCliIds[0]);
-        var right = sessionByCliId(group.memberCliIds[1]);
+      if (group && (Array.isArray(group.memberCliIds) || Array.isArray(group.memberOriginIds))) {
+        var memberCliIds = Array.isArray(group.memberCliIds) ? group.memberCliIds : [null, null];
+        var memberOriginIds = Array.isArray(group.memberOriginIds) ? group.memberOriginIds : [null, null];
+        var left = durableAnchors.findSession(sessions, memberCliIds[0], memberOriginIds[0]);
+        var right = durableAnchors.findSession(sessions, memberCliIds[1], memberOriginIds[1]);
         if (!left || !right || left === right) return false;
         if (group.members[0] !== left.localId || group.members[1] !== right.localId) {
           group.members = [left.localId, right.localId];
           shouldRewrite = true;
         }
       }
-      if (group && group.pair && Array.isArray(group.pairCliIds)) {
-        var driver = sessionByCliId(group.pairCliIds[0]);
-        var worker = sessionByCliId(group.pairCliIds[1]);
+      if (group && group.pair && (Array.isArray(group.pairCliIds) || Array.isArray(group.pairOriginIds))) {
+        var pairCliIds = Array.isArray(group.pairCliIds) ? group.pairCliIds : [null, null];
+        var pairOriginIds = Array.isArray(group.pairOriginIds) ? group.pairOriginIds : [null, null];
+        var driver = durableAnchors.findSession(sessions, pairCliIds[0], pairOriginIds[0]);
+        var worker = durableAnchors.findSession(sessions, pairCliIds[1], pairOriginIds[1]);
         if (driver && worker) {
           group.pair.driverId = driver.localId;
           group.pair.workerId = worker.localId;
@@ -117,35 +97,51 @@ function createSplitGroupStore(opts) {
     if (groups.length !== loaded.length) shouldRewrite = true;
     if (shouldRewrite) save();
   }
-
   function isMultiUser() {
     return !!(usersModule && usersModule.isMultiUser && usersModule.isMultiUser());
   }
-
   function listFor(ws) {
     if (!isMultiUser()) return groups.slice();
     if (!ws || !ws._clayUser) return [];
     return groups.filter(function (group) { return group.ownerId === ws._clayUser.id; });
   }
-
   function groupForMember(localId) {
+    for (var si = 0; si < stagedTransfers.length; si++) {
+      var transfer = stagedTransfers[si];
+      if (!exactTransfer(transfer)) continue;
+      if (transfer.source.localId === localId) return null;
+      if (transfer.target.localId === localId || transfer.worker.localId === localId) return transfer.runtimeGroup;
+    }
     for (var i = 0; i < groups.length; i++) {
       if (groups[i].members.indexOf(localId) !== -1) return groups[i];
     }
     return null;
   }
-
+  function membershipGroup(localId) {
+    for (var si = 0; si < stagedTransfers.length; si++) {
+      var transfer = stagedTransfers[si];
+      if (transfer.source.localId === localId || transfer.target.localId === localId ||
+          transfer.worker.localId === localId) return transfer.group;
+    }
+    for (var i = 0; i < groups.length; i++) if (groups[i].members.indexOf(localId) !== -1) return groups[i];
+    return null;
+  }
+  function groupCountForMember(localId) {
+    var count = 0;
+    for (var i = 0; i < groups.length; i++) {
+      if (groups[i].members.indexOf(localId) !== -1) count++;
+    }
+    return count;
+  }
   function canAccess(ws, session) {
     if (!isMultiUser()) return true;
     return !!(ws && ws._clayUser && usersModule.canAccessSession(
       ws._clayUser.id, session, { visibility: "public" }
     ));
   }
-
   function canOwn(ws, group) {
     return !isMultiUser() || !!(ws && ws._clayUser && group.ownerId === ws._clayUser.id);
   }
-
   function create(ws, msg) {
     var members = msg && msg.members;
     if (!Array.isArray(members) || members.length !== 2) return { ok: false, error: "A split group requires exactly two sessions" };
@@ -156,7 +152,7 @@ function createSplitGroupStore(opts) {
     var right = sessions.get(members[1]);
     if (!left || !right) return { ok: false, error: "Session not found" };
     if (!canAccess(ws, left) || !canAccess(ws, right)) return { ok: false, error: "Session access denied" };
-    if (groupForMember(members[0]) || groupForMember(members[1])) return { ok: false, error: "A session can belong to only one split group" };
+    if (membershipGroup(members[0]) || membershipGroup(members[1])) return { ok: false, error: "A session can belong to only one split group" };
     var requestedName = typeof msg.name === "string" ? msg.name.trim().slice(0, 80) : "";
     var group = {
       id: "sg_" + Date.now().toString(36) + "_" + crypto.randomBytes(3).toString("hex"),
@@ -178,7 +174,6 @@ function createSplitGroupStore(opts) {
     if (group.pair) onPairChanged(group);
     return { ok: true, group: group };
   }
-
   function createOwned(ownerId, msg) {
     var members = msg && msg.members;
     if (!Array.isArray(members) || members.length !== 2) return { ok: false, error: "A split group requires exactly two sessions" };
@@ -186,7 +181,7 @@ function createSplitGroupStore(opts) {
     var right = sessions.get(members[1]);
     if (!left || !right || left === right) return { ok: false, error: "Session not found" };
     if ((left.ownerId || null) !== (ownerId || null) || (right.ownerId || null) !== (ownerId || null)) return { ok: false, error: "Session owner does not match the scheduled task owner" };
-    if (groupForMember(left.localId) || groupForMember(right.localId)) return { ok: false, error: "A session can belong to only one split group" };
+    if (membershipGroup(left.localId) || membershipGroup(right.localId)) return { ok: false, error: "A session can belong to only one split group" };
     var pair = msg && msg.pair;
     if (!pair || pair.driverId !== left.localId || pair.workerId !== right.localId) return { ok: false, error: "Pair roles must reference both split group members" };
     var requestedName = typeof msg.name === "string" ? msg.name.trim().slice(0, 80) : "";
@@ -202,7 +197,6 @@ function createSplitGroupStore(opts) {
     onPairChanged(group);
     return { ok: true, group: group };
   }
-
   function dissolveOwned(ownerId, id) {
     var index = groups.findIndex(function (item) { return item.id === id && (item.ownerId || null) === (ownerId || null); });
     if (index === -1) return false;
@@ -212,7 +206,157 @@ function createSplitGroupStore(opts) {
     onPairChanged(removed);
     return true;
   }
-
+  // Runtime pair lookup sees this isolated projection while ordinary list,
+  // save, anchor refresh, broadcast, and unrelated mutations keep using the
+  // durable source-owned record until commit.
+  function beginOwnedDriverTransfer(ownerId, msg) {
+    var group = groups.find(function (item) { return item.id === (msg && msg.id); });
+    if (!group || (group.ownerId || null) !== (ownerId || null)) return { ok: false, error: "Split group not found" };
+    if (!group.pair || group.pair.driverId !== msg.sourceDriverId || group.pair.workerId !== msg.workerId) {
+      return { ok: false, error: "The split pair changed before Driver transfer" };
+    }
+    var source = sessions.get(msg.sourceDriverId);
+    var target = sessions.get(msg.targetDriverId);
+    var worker = sessions.get(msg.workerId);
+    if (!source || !target || !worker || source === target || target === worker) return { ok: false, error: "Session not found" };
+    if ((source.ownerId || null) !== (ownerId || null) || (target.ownerId || null) !== (ownerId || null) ||
+        (worker.ownerId || null) !== (ownerId || null)) return { ok: false, error: "Split pair owner changed" };
+    if (membershipGroup(target.localId)) return { ok: false, error: "The successor already belongs to a split group" };
+    var sourceIndex = group.members.indexOf(source.localId);
+    if (sourceIndex === -1 || group.members.indexOf(worker.localId) === -1) return { ok: false, error: "Split group members changed" };
+    var before = {
+      members: group.members.slice(),
+      memberCliIds: Array.isArray(group.memberCliIds) ? group.memberCliIds.slice() : null,
+      memberOriginIds: Array.isArray(group.memberOriginIds) ? group.memberOriginIds.slice() : null,
+      pair: Object.assign({}, group.pair),
+      pairCliIds: Array.isArray(group.pairCliIds) ? group.pairCliIds.slice() : null,
+      pairOriginIds: Array.isArray(group.pairOriginIds) ? group.pairOriginIds.slice() : null,
+    };
+    var runtimeMembers = group.members.slice();
+    runtimeMembers[sourceIndex] = target.localId;
+    var runtimeGroup = Object.assign({}, group, { members: runtimeMembers,
+      pair: { driverId: target.localId, workerId: worker.localId } });
+    var transaction = { group: group, before: before, source: source, target: target, worker: worker,
+      runtimeGroup: runtimeGroup,
+      ownerId: ownerId || null, sourceOriginId: source.sessionOriginId || null,
+      targetOriginId: target.sessionOriginId || null, workerOriginId: worker.sessionOriginId || null,
+      workerCliSessionId: worker.cliSessionId || null, staged: true, committed: false };
+    stagedTransfers.push(transaction);
+    return { ok: true, group: runtimeGroup, transaction: transaction };
+  }
+  function removeStaged(transaction) {
+    var index = stagedTransfers.indexOf(transaction);
+    if (index !== -1) stagedTransfers.splice(index, 1);
+  }
+  function restoreTransfer(transaction) {
+    var group = transaction.group;
+    group.members = transaction.before.members.slice();
+    group.pair = Object.assign({}, transaction.before.pair);
+    if (transaction.before.memberCliIds) group.memberCliIds = transaction.before.memberCliIds.slice();
+    else delete group.memberCliIds;
+    if (transaction.before.memberOriginIds) group.memberOriginIds = transaction.before.memberOriginIds.slice();
+    else delete group.memberOriginIds;
+    if (transaction.before.pairCliIds) group.pairCliIds = transaction.before.pairCliIds.slice();
+    else delete group.pairCliIds;
+    if (transaction.before.pairOriginIds) group.pairOriginIds = transaction.before.pairOriginIds.slice();
+    else delete group.pairOriginIds;
+  }
+  function stagedTransfer(transaction) {
+    return transaction && transaction.staged && !transaction.committed &&
+      stagedTransfers.indexOf(transaction) !== -1 && groups.indexOf(transaction.group) !== -1 &&
+      transaction.runtimeGroup.pair && transaction.runtimeGroup.pair.driverId === transaction.target.localId &&
+      transaction.runtimeGroup.pair.workerId === transaction.worker.localId &&
+      transaction.runtimeGroup.members.length === 2 && transaction.runtimeGroup.members.indexOf(transaction.target.localId) !== -1 &&
+      transaction.runtimeGroup.members.indexOf(transaction.worker.localId) !== -1;
+  }
+  function exactTransfer(transaction) {
+    return stagedTransfer(transaction) &&
+      sessions.get(transaction.source.localId) === transaction.source &&
+      sessions.get(transaction.target.localId) === transaction.target &&
+      sessions.get(transaction.worker.localId) === transaction.worker &&
+      (transaction.group.ownerId || null) === transaction.ownerId &&
+      (transaction.source.ownerId || null) === transaction.ownerId &&
+      (transaction.target.ownerId || null) === transaction.ownerId &&
+      (transaction.worker.ownerId || null) === transaction.ownerId &&
+      (transaction.source.sessionOriginId || null) === transaction.sourceOriginId &&
+      (transaction.target.sessionOriginId || null) === transaction.targetOriginId &&
+      (transaction.worker.sessionOriginId || null) === transaction.workerOriginId &&
+      (transaction.worker.cliSessionId || null) === transaction.workerCliSessionId &&
+      transaction.group.pair && transaction.group.pair.driverId === transaction.source.localId &&
+      transaction.group.pair.workerId === transaction.worker.localId &&
+      transaction.group.members.length === 2 && transaction.group.members.indexOf(transaction.source.localId) !== -1 &&
+      transaction.group.members.indexOf(transaction.worker.localId) !== -1 &&
+      groupCountForMember(transaction.target.localId) === 0 && groupCountForMember(transaction.worker.localId) === 1 &&
+      groupCountForMember(transaction.source.localId) === 1;
+  }
+  function commitOwnedDriverTransfer(transaction) {
+    if (!exactTransfer(transaction)) {
+      removeStaged(transaction);
+      transaction.staged = false;
+      return { ok: false, error: "The staged Driver transfer is no longer exact" };
+    }
+    if (!transaction.target.cliSessionId ||
+        (!transaction.worker.cliSessionId && !transaction.worker.sessionOriginId)) {
+      return { ok: false, error: "The transferred pair does not have durable session anchors" };
+    }
+    transaction.group.members = transaction.runtimeGroup.members.slice();
+    transaction.group.pair = Object.assign({}, transaction.runtimeGroup.pair);
+    try { save(); }
+    catch (error) {
+      restoreTransfer(transaction);
+      removeStaged(transaction);
+      transaction.staged = false;
+      return { ok: false, error: error.message || String(error) };
+    }
+    removeStaged(transaction);
+    transaction.committed = true;
+    broadcast();
+    onPairChanged(transaction.group);
+    return { ok: true, group: transaction.group };
+  }
+  function rollbackOwnedDriverTransfer(transaction) {
+    if (stagedTransfer(transaction)) {
+      removeStaged(transaction);
+      transaction.staged = false;
+      return { ok: true, group: transaction.group };
+    }
+    if (!transaction || !transaction.committed || groups.indexOf(transaction.group) === -1 ||
+        transaction.group.pair.driverId !== transaction.target.localId ||
+        transaction.group.pair.workerId !== transaction.worker.localId) {
+      return { ok: false, error: "The staged Driver transfer is no longer exact" };
+    }
+    var wasCommitted = transaction.committed;
+    var committedState = {
+      members: transaction.group.members.slice(),
+      memberCliIds: Array.isArray(transaction.group.memberCliIds) ? transaction.group.memberCliIds.slice() : null,
+      memberOriginIds: Array.isArray(transaction.group.memberOriginIds) ? transaction.group.memberOriginIds.slice() : null,
+      pair: Object.assign({}, transaction.group.pair),
+      pairCliIds: Array.isArray(transaction.group.pairCliIds) ? transaction.group.pairCliIds.slice() : null,
+      pairOriginIds: Array.isArray(transaction.group.pairOriginIds) ? transaction.group.pairOriginIds.slice() : null,
+    };
+    restoreTransfer(transaction);
+    if (wasCommitted) {
+      try { save(); }
+      catch (error) {
+        transaction.group.members = committedState.members;
+        transaction.group.pair = committedState.pair;
+        if (committedState.memberCliIds) transaction.group.memberCliIds = committedState.memberCliIds;
+        else delete transaction.group.memberCliIds;
+        if (committedState.memberOriginIds) transaction.group.memberOriginIds = committedState.memberOriginIds;
+        else delete transaction.group.memberOriginIds;
+        if (committedState.pairCliIds) transaction.group.pairCliIds = committedState.pairCliIds;
+        else delete transaction.group.pairCliIds;
+        if (committedState.pairOriginIds) transaction.group.pairOriginIds = committedState.pairOriginIds;
+        else delete transaction.group.pairOriginIds;
+        return { ok: false, error: error.message || String(error) };
+      }
+      broadcast();
+      onPairChanged(transaction.group);
+    }
+    transaction.staged = false;
+    transaction.committed = false;
+    return { ok: true, group: transaction.group };
+  }
   function rename(ws, msg) {
     var group = groups.find(function (item) { return item.id === (msg && msg.id); });
     if (!group) return { ok: false, error: "Split group not found" };
@@ -237,6 +381,7 @@ function createSplitGroupStore(opts) {
     if (msg.driverId == null) {
       delete group.pair;
       delete group.pairCliIds;
+      delete group.pairOriginIds;
       save();
       broadcast();
       onPairChanged(group);
@@ -275,9 +420,11 @@ function createSplitGroupStore(opts) {
   function refreshAnchors(localId) {
     var group = groupForMember(localId);
     if (!group) return false;
-    var fresh = currentCliIds(group);
-    var prev = Array.isArray(group.memberCliIds) ? group.memberCliIds : [null, null];
-    if (fresh[0] === prev[0] && fresh[1] === prev[1]) return false;
+    var fresh = durableAnchors.memberAnchors(group, sessions);
+    var prevCli = Array.isArray(group.memberCliIds) ? group.memberCliIds : [null, null];
+    var prevOrigin = Array.isArray(group.memberOriginIds) ? group.memberOriginIds : [null, null];
+    if (fresh.cli[0] === prevCli[0] && fresh.cli[1] === prevCli[1] &&
+        fresh.origin[0] === prevOrigin[0] && fresh.origin[1] === prevOrigin[1]) return false;
     save();
     return true;
   }
@@ -299,7 +446,10 @@ function createSplitGroupStore(opts) {
   }
 
   load();
-  return { create: create, createOwned: createOwned, dissolveOwned: dissolveOwned, rename: rename, setPair: setPair, dissolve: dissolve, dissolveBySession: dissolveBySession,
+  return { create: create, createOwned: createOwned, dissolveOwned: dissolveOwned,
+    beginOwnedDriverTransfer: beginOwnedDriverTransfer, commitOwnedDriverTransfer: commitOwnedDriverTransfer,
+    rollbackOwnedDriverTransfer: rollbackOwnedDriverTransfer,
+    rename: rename, setPair: setPair, dissolve: dissolve, dissolveBySession: dissolveBySession,
     refreshAutoName: refreshAutoName, refreshAnchors: refreshAnchors,
     listFor: listFor, groupForMember: groupForMember, get groups() { return groups; } };
 }

package/lib/sessions.js

@@ -24,6 +24,7 @@ function createSessionManager(opts) {
   var sessionViewedListeners = [];
   var onSessionRenamed = opts.onSessionRenamed || function () {};
   var onSessionIdentityAssigned = opts.onSessionIdentityAssigned || function () {};
+  var sessionIdentityAssignedListeners = [];
   var onSessionHydrate = opts.onSessionHydrate || null;
 
   // --- Multi-session state ---
@@ -148,7 +149,7 @@ function createSessionManager(opts) {
   }
 
   function saveSessionFile(session) {
-    if (!session.cliSessionId) return;
+    if (!session.cliSessionId) return false;
     try {
       var metaObj = {
         type: "meta",
@@ -194,6 +195,8 @@ function createSessionManager(opts) {
       if (session.spawn) metaObj.spawn = session.spawn;
       if (session.assignment) metaObj.assignment = session.assignment;
       if (session.handoff) metaObj.handoff = session.handoff;
+      if (session.driverContinuation) metaObj.driverContinuation = session.driverContinuation;
+      if (session.driverContinuationDecline) metaObj.driverContinuationDecline = session.driverContinuationDecline;
       if (session.debateState) metaObj.debateState = session.debateState;
       if (session.debateSetupMode) metaObj.debateSetupMode = true;
       if (session.homeDebatePlanning) metaObj.homeDebatePlanning = true;
@@ -219,8 +222,10 @@ function createSessionManager(opts) {
         try { fs.chmodSync(tmpPath, 0o600); } catch (chmodErr) {}
       }
       fs.renameSync(tmpPath, sfPath);
+      return true;
     } catch(e) {
       console.error("[session] Failed to save session file:", e.message);
+      return false;
     }
   }
 
@@ -327,6 +332,8 @@ function createSessionManager(opts) {
       if (m.spawn) session.spawn = m.spawn;
       if (m.assignment) session.assignment = m.assignment;
       if (m.handoff) session.handoff = m.handoff;
+      if (m.driverContinuation) session.driverContinuation = m.driverContinuation;
+      if (m.driverContinuationDecline) session.driverContinuationDecline = m.driverContinuationDecline;
       if (m.debateState) session.debateState = m.debateState;
       if (m.debateSetupMode) session.debateSetupMode = true;
       if (m.homeDebatePlanning) session.homeDebatePlanning = true;
@@ -1340,8 +1347,19 @@ function createSessionManager(opts) {
     addOnSessionViewed: function (fn) { if (typeof fn === "function") sessionViewedListeners.push(fn); },
     setOnSessionRenamed: function (fn) { onSessionRenamed = fn || function () {}; },
     setOnSessionIdentityAssigned: function (fn) { onSessionIdentityAssigned = fn || function () {}; },
+    addOnSessionIdentityAssigned: function (fn) {
+      if (typeof fn !== "function") return function () {};
+      sessionIdentityAssignedListeners.push(fn);
+      return function () {
+        sessionIdentityAssignedListeners = sessionIdentityAssignedListeners.filter(function (listener) { return listener !== fn; });
+      };
+    },
     notifySessionRenamed: function (localId) { onSessionRenamed(localId); },
-    notifySessionIdentityAssigned: function (localId) { onSessionIdentityAssigned(localId); },
+    notifySessionIdentityAssigned: function (localId) {
+      onSessionIdentityAssigned(localId);
+      var listeners = sessionIdentityAssignedListeners.slice();
+      for (var i = 0; i < listeners.length; i++) listeners[i](localId);
+    },
     HISTORY_PAGE_SIZE: HISTORY_PAGE_SIZE,
     getActiveSession: getActiveSession,
     createSession: createSession,

package/lib/ws-schema.js

@@ -44,6 +44,8 @@ var schema = {
   "pair_session_options":     { direction: "c2s", handler: "lib/project-session-pair.js", description: "Request vendors/models for the pair-session dialog (response reuses the same type)" },
   "pair_session_create":      { direction: "c2s", handler: "lib/project-session-pair.js", description: "Create a Driver/Split Worker session pair as a split group" },
   "worker_proposal_response": { direction: "c2s", handler: "lib/project-worker-proposal.js", description: "Accept or decline an exact Driver Split Worker configuration with the selected runtime" },
+  "driver_continuation_response": { direction: "c2s", handler: "lib/project-driver-continuation.js", description: "Accept or decline an exact source-bound Driver continuation proposal" },
+  "driver_continuation_open_source": { direction: "c2s", handler: "lib/project-driver-continuation.js", description: "Resolve a successor's stable origin link to its authorized original Driver" },
   "project_assignment_response": { direction: "c2s", handler: "lib/workspace-assignment-service.js", description: "Approve or cancel an exact-session cross-project assignment proposal" },
   "home_clay_session_resolve": { direction: "c2s", handler: "lib/server-home-chat.js", description: "Resolve an opaque Mate session reference through the exact bound source session" },
   "home_clay_session_target": { direction: "s2c", handler: "lib/public/modules/command-palette.js", description: "Return an owner-validated navigation target for a rendered Mate session reference" },
@@ -101,6 +103,10 @@ var schema = {
   "pair_session_created":     { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Result of pair_session_create; carries the new group" },
   "worker_proposal":          { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Recorded Split Worker creation/replacement runtime card with Driver rationale" },
   "worker_proposal_update":   { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Worker card lifecycle and manual/auto decision audit update" },
+  "driver_continuation_proposal": { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Recorded review card for a compact Driver continuation" },
+  "driver_continuation_update": { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Durable exact-proposal continuation lifecycle update" },
+  "driver_continuation_result": { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Correlated response to a continuation decision" },
+  "driver_continuation_context": { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Compact inherited context and original-session link in a successor" },
   "project_assignment_proposal": { direction: "s2c", handler: "lib/public/modules/app-message-router.js", description: "Approval card for a new owner-bound project assignment" },
   "project_assignment_status": { direction: "s2c", handler: "lib/public/modules/app-message-router.js", description: "Durable project assignment lifecycle update" },
   "project_assignment_error": { direction: "s2c", handler: "lib/public/modules/app-message-router.js", description: "Rejected or stale project assignment response" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "4.2.0",
+  "version": "4.3.0-beta.1",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js"