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

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

@@ -0,0 +1,229 @@
+var crypto = require("crypto");
+var splitRoles = require("./session-split-group-roles");
+
+function attachPairResultRecovery(ctx) {
+  var scheduled = Object.create(null);
+  var runtimeStatus = Object.create(null);
+
+  function opaqueId(key) {
+    return crypto.createHash("sha256").update(String(key)).digest("hex").slice(0, 24);
+  }
+  function ownerId(session) { return session && session.ownerId || null; }
+  function findOrigin(originId) {
+    var found = null, duplicate = false;
+    ctx.sm.sessions.forEach(function (session) {
+      if (!session || session.sessionOriginId !== originId) return;
+      if (found) duplicate = true;
+      else found = session;
+    });
+    return duplicate ? null : found;
+  }
+  function resolve(record) {
+    if (!record || record.projectSlug !== ctx.projectSlug) return { ok: false, code: "project", reason: "This completed result belongs to a different project." };
+    var driver = findOrigin(record.driverOriginId), worker = findOrigin(record.workerOriginId);
+    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);
+    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;
+    if (!provenance || provenance.kind !== "worker" || provenance.parentSessionOriginId !== record.driverOriginId || provenance.generation !== record.generation) {
+      return { ok: false, code: "generation", reason: "The Split Worker generation no longer matches this completed result." };
+    }
+    if (worker._pairDelegation && (worker._pairDelegation.outboxKey !== record.key || worker._pairDelegation.taskId !== record.taskId)) {
+      return { ok: false, code: "active_task", reason: "A newer Split Worker task is active, so this result cannot be restored automatically." };
+    }
+    return { ok: true, driver: driver, worker: worker, group: group };
+  }
+  function tokenFor(record, resolved) {
+    var token = resolved.worker._pairDelegation;
+    if (token && token.outboxKey === record.key) {
+      if (Number(record.manualRetryEpoch || 0) > Number(token._manualRetryEpochApplied || 0)) {
+        if (token._deliveryTimer && token._deliveryTimer.timer) clearTimeout(token._deliveryTimer.timer);
+        delete token._deliveryTimer; delete token._deliveryUncertain; delete token._deliveryAccepted;
+        delete token._deliveryStartupAttemptId;
+        token._manualRetryEpochApplied = Number(record.manualRetryEpoch || 0);
+      }
+      return token;
+    }
+    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",
+      detached: record.deliveryRoute === "callback", detachRequested: record.deliveryRoute === "callback",
+      response: record.outcome && record.outcome.response || "",
+      failure: record.outcome && record.outcome.error || null,
+      interrupted: !!(record.outcome && record.outcome.status === "interrupted"),
+      _captureComplete: true,
+      _manualRetryEpochApplied: Number(record.manualRetryEpoch || 0),
+    };
+    resolved.worker._pairDelegation = token;
+    resolved.worker._delegatedBy = resolved.driver.localId;
+    return token;
+  }
+  function block(record, reason, code) {
+    if (record.deliveryState === "accepted" && record.finalized) return;
+    var saved = ctx.outbox.markBlocked(record.key, reason, code);
+    if (saved.ok) changed();
+  }
+  function process(key, allowDelivery) {
+    delete scheduled[key];
+    var record = ctx.outbox.get(key);
+    if (!record || !record.outcome) return { ok: false, deferred: true };
+    if (record.finalized) return { ok: true, finalized: true };
+    if (record.blockedCode === "human_stop") return { ok: false, blocked: true };
+    var resolved = resolve(record);
+    if (!resolved.ok) {
+      block(record, resolved.reason, resolved.code);
+      return { ok: false, blocked: true };
+    }
+    var stopReason = typeof ctx.blockedReason === "function" ? ctx.blockedReason(resolved.driver) : null;
+    if (stopReason) {
+      block(record, stopReason, "human_stop");
+      return { ok: false, blocked: true };
+    }
+    if (record.finalizationState === "failed") return { ok: false, blocked: true };
+    var token = tokenFor(record, resolved);
+    if (record.deliveryRoute === "blocking" || record.deliveryState === "accepted") {
+      var finished = ctx.resultCapture.finish(resolved.driver, resolved.worker, token, record.deliveryState === "accepted");
+      changed(resolved.driver);
+      return { ok: finished !== false, finalized: finished !== false };
+    }
+    if (record.deliveryState === "uncertain") return { ok: false, uncertain: true };
+    if (!allowDelivery) return { ok: false, deferred: true };
+    var result = ctx.wake(resolved.driver, resolved.worker, token);
+    changed(resolved.driver);
+    return result;
+  }
+  function schedule(key) {
+    if (scheduled[key]) return;
+    scheduled[key] = true;
+    setImmediate(function () { process(key, true); });
+  }
+  function healthyLiveDispatch(record) {
+    if (!record || record.outcome || record.state === "blocked") return false;
+    var resolved = resolve(record);
+    if (!resolved.ok) return false;
+    var token = resolved.worker._pairDelegation;
+    return !!(token && token.outboxKey === record.key && token.taskId === record.taskId && token.generation === record.generation &&
+      token.from === resolved.driver.localId && token.groupId === resolved.group.id && !token._capturePending && !token._captureHookError &&
+      (resolved.worker.isProcessing || resolved.worker._queryStarting));
+  }
+  function recordsFor(session) {
+    if (!session) return [];
+    var originId = session.sessionOriginId, currentOwner = ownerId(session);
+    return ctx.outbox.list().map(function (record) {
+      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";
+      return true;
+    });
+  }
+  function publicItem(record) {
+    var completed = !!record.outcome;
+    var finalizationFailed = record.finalizationState === "failed";
+    var state = record.state === "blocked" || finalizationFailed ? "blocked" : record.deliveryState;
+    if (state === "attempting") state = "uncertain";
+    if (!completed && state !== "blocked") state = "uncertain";
+    var exhausted = state === "pending" && Number(record.deliveryAttemptCount || 0) >= ctx.outbox.maxDeliveryAttempts;
+    return {
+      id: opaqueId(record.key), state: exhausted ? "pending" : state,
+      message: record.blockedReason || record.finalizationError || (!completed ? "The Split Worker task was retained, but no durable completed result is available yet." :
+        (state === "uncertain" ? "Delivery could not be confirmed. The Driver may already have received this result." :
+        (exhausted ? "Automatic delivery could not complete. The finished result is retained." : "The finished Split Worker result is waiting to be delivered."))),
+      response: completed ? record.outcome.response || "" : "", error: completed ? record.outcome.error || null : null,
+      hasCompletedResult: completed,
+      canRetry: completed && !finalizationFailed && record.blockedCode !== "human_stop" && Number(record.manualRetryCount || 0) < 1 && (state === "uncertain" || exhausted),
+      confirmDuplicate: completed && state === "uncertain",
+    };
+  }
+  function canRead(ws, session) {
+    if (!ws || !session || ws._clayActiveSession !== session.localId) return false;
+    if (ownerId(session)) return !!(ws._clayUser && String(ws._clayUser.id) === String(ownerId(session)));
+    return !ws._clayUser || !ctx.isMultiUser();
+  }
+  function sendState(session, ws, sendFn) {
+    if (!canRead(ws, session)) return false;
+    var items = recordsFor(session).map(publicItem);
+    (sendFn || ctx.sendTo.bind(null, ws))({ type: "pair_result_status", sessionId: session.localId, items: items });
+    return true;
+  }
+  function changed(driver) {
+    var targets = typeof ctx.getClients === "function" ? ctx.getClients() : [];
+    for (var ws of targets) {
+      var session = driver || ctx.sm.sessions.get(ws._clayActiveSession);
+      if (session) sendState(session, ws);
+    }
+  }
+  function stateChanged(driver, record) {
+    if (record && record.key && record.persistenceError) runtimeStatus[record.key] = {
+      finalizationState: record.finalizationState, finalizationError: record.finalizationError,
+    };
+    if (record && record.key && record.finalized) delete runtimeStatus[record.key];
+    changed(driver);
+    if (record && !record.finalized && record.finalizationState !== "failed" && (record.deliveryState === "accepted" || record.deliveryRoute === "blocking")) schedule(record.key);
+  }
+  function available(session) {
+    if (!session) return;
+    var origin = session.sessionOriginId;
+    var records = ctx.outbox.list();
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].driverOriginId === origin && records[i].outcome && records[i].deliveryState === "pending" && records[i].state !== "blocked") schedule(records[i].key);
+    }
+  }
+  function reconcile() {
+    var records = ctx.outbox.list();
+    for (var i = 0; i < records.length; i++) {
+      var record = records[i];
+      if (!record.outcome) continue;
+      if (record.deliveryState === "attempting") {
+        var uncertain = ctx.outbox.markRestartUncertain(record.key);
+        if (uncertain.ok && uncertain.record) record = uncertain.record;
+      }
+      process(record.key, false);
+      record = ctx.outbox.get(record.key);
+      if (record && record.deliveryState === "pending" && record.state !== "blocked" && record.finalizationState !== "failed") schedule(record.key);
+    }
+  }
+  function beginHumanTurn(session) {
+    var records = recordsFor(session);
+    for (var i = 0; i < records.length; i++) {
+      if (records[i].blockedCode !== "human_stop") continue;
+      var saved = ctx.outbox.authorizeHumanTurn(records[i].key);
+      if (saved.ok && saved.record.outcome && (saved.record.deliveryState === "pending" || saved.record.deliveryState === "accepted")) schedule(records[i].key);
+    }
+    changed(session);
+  }
+  function handleMessage(ws, msg) {
+    if (!msg || (msg.type !== "pair_result_state_request" && msg.type !== "pair_result_retry")) return false;
+    var session = ctx.sm.sessions.get(ws._clayActiveSession);
+    if (!canRead(ws, session)) return true;
+    if (msg.sessionId != null && msg.sessionId !== session.localId) return true;
+    if (msg.projectSlug && msg.projectSlug !== ctx.projectSlug) return true;
+    if (msg.type === "pair_result_state_request") { sendState(session, ws); return true; }
+    var records = recordsFor(session), record = null;
+    for (var i = 0; i < records.length; i++) if (opaqueId(records[i].key) === msg.id) record = records[i];
+    if (!record) { sendState(session, ws); return true; }
+    if (record.deliveryState === "uncertain" && msg.confirmDuplicate !== true) { sendState(session, ws); return true; }
+    var granted = ctx.outbox.grantManualRetry(record.key);
+    if (granted.ok) schedule(record.key);
+    changed(session);
+    return true;
+  }
+  if (ctx.sm && typeof ctx.sm.addOnSessionViewed === "function") {
+    ctx.sm.addOnSessionViewed(function (session, ws, sendFn) { available(session); sendState(session, ws, sendFn); });
+  }
+  return { available: available, beginHumanTurn: beginHumanTurn, changed: changed, stateChanged: stateChanged, handleMessage: handleMessage,
+    reconcile: reconcile, sendState: sendState, process: process };
+}
+
+module.exports = { attachPairResultRecovery: attachPairResultRecovery };

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,13 +230,29 @@ 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,
+        workerOriginId: worker.sessionOriginId || null, taskId: token.taskId, generation: token.generation,
+        outcome: envelope }); } catch (evidenceError) { token._completionEvidenceError = evidenceError.message || String(evidenceError); }
+    }
     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);
@@ -255,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 };