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

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

@@ -0,0 +1,225 @@
+var crypto = require("crypto");
+
+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);
+    if (!group || ctx.store.groupForMember(worker.localId) !== group || !group.pair ||
+        group.pair.driverId !== driver.localId || group.pair.workerId !== worker.localId) {
+      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,
+      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 (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-task-control.js

@@ -228,6 +228,12 @@ function attachPairTaskControl(ctx) {
     token.outcomeEnvelope = envelope;
     worker._lastPairOutcome = envelope;
     if (finalStatus === "interrupted" || finalStatus === "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;
   }

package/lib/project-session-pair.js

@@ -1,19 +1,12 @@
-var pairMcp = require("./session-pair-mcp-server"), pairPrompts = require("./session-pair-prompts"); var { attachPairFactory } = require("./session-pair-factory"), { attachPairLifecycle } = require("./project-pair-lifecycle"),
-  { attachPairTurnControl } = require("./session-pair-turn-control");
+var pairMcp = require("./session-pair-mcp-server"), pairPrompts = require("./session-pair-prompts"); var { attachPairFactory } = require("./session-pair-factory"), { attachPairLifecycle } = require("./project-pair-lifecycle"), { attachPairTurnControl } = require("./session-pair-turn-control");
 var driverEligibility = require("./session-driver-eligibility"), driverOrchestration = require("./session-driver-orchestration"), { attachWorkerPermission } = require("./project-worker-permission"), { attachWorkerProposal } = require("./project-worker-proposal");
 var { attachPairMessage } = require("./project-pair-message"), { attachPairTaskControl } = require("./project-pair-task-control"), stopAutonomous = require("./project-pair-autonomous-stop").stopAutonomousWork, stopOwned = require("./project-pair-owned-stop").stopOwnedPair;
 var pairHistory = require("./session-pair-history"), responseText = pairHistory.responseText, errorSince = pairHistory.errorSince, recentTurns = pairHistory.recentTurns, operationFingerprint = require("./session-pair-operation").fingerprint;
-var beginPairQuery = require("./session-pair-query-start").beginPairQuery;
-function toolResult(value) { return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] }); }
-function toolError(err) { return Promise.resolve({ content: [{ type: "text", text: "Error: " + (err.message || err) }], isError: true }); }
+var beginPairQuery = require("./session-pair-query-start").beginPairQuery, attachPairResultPipeline = require("./project-pair-result-pipeline").attachPairResultPipeline;
+function toolResult(value) { return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] }); } function toolError(err) { return Promise.resolve({ content: [{ type: "text", text: "Error: " + (err.message || err) }], isError: true }); }
 function attachSessionPair(ctx) {
-  var sm = ctx.sm;
-  var store = ctx.splitStore;
-  var workerProposal;
-  var workerPermission;
-  var lifecycle;
-  var taskControl;
-  var turnControl = attachPairTurnControl({ sm: sm, splitStore: store });
+  var sm = ctx.sm, store = ctx.splitStore, workerProposal, workerPermission, lifecycle, taskControl;
+  var turnControl = attachPairTurnControl({ sm: sm, splitStore: store }), resultCapture;
   function groupAndPartner(caller, missingPairMessage) {
     if (!caller) throw new Error("partner tools require a session-bound tool server");
     if (sm.sessions.get(caller.localId) !== caller) {
@@ -119,12 +112,14 @@ function attachSessionPair(ctx) {
   function requestDetach(worker) {
     var token = worker && worker._pairDelegation;
     if (!token || token.detached || token.detachRequested) return false;
-    token.detachRequested = true;
+    if (token.outboxKey && ctx.resultOutbox && !ctx.resultOutbox.setRoute(token.outboxKey, "callback").ok) return false;
+    token.wait = false; token.detachRequested = true;
     return true;
   }
   function handleTurnDone(partner) {
     var token = partner && partner._pairDelegation;
     if (!token) return false;
+    if (token._capturePending || token._captureComplete) return false;
     var group = store.groupForMember(partner.localId);
     if (!group || group.id !== token.groupId || group.members.indexOf(token.from) === -1) return false;
     var caller = sm.sessions.get(token.from);
@@ -137,12 +132,8 @@ function attachSessionPair(ctx) {
     token.failure = errorSince(partner.history || [], token.startIndex);
     token.interrupted = !token.failure && !!partner._lastTurnInterrupted;
     if (token.interrupted) taskControl.ensureSystemInterruption(partner, token);
-    taskControl.complete(partner, caller, token, token.failure ? "failed" : (token.interrupted ? "interrupted" : "completed"), token.response, token.failure);
-    finishDelegation(group, caller, partner, token);
-    if (typeof ctx.onPartnerResult === "function") ctx.onPartnerResult(caller, partner, token);
-    var resumed = resumeDriverWithResult(caller, partner, token);
-    taskControl.drain(caller, partner);
-    return resumed;
+    var outcome = taskControl.complete(partner, caller, token, token.failure ? "failed" : (token.interrupted ? "interrupted" : "completed"), token.response, token.failure);
+    return resultCapture.capture(caller, partner, token, outcome);
   }
   function waitForPartner(group, caller, partner, token, timeoutSeconds) {
     return new Promise(function (resolve, reject) {
@@ -157,28 +148,33 @@ function attachSessionPair(ctx) {
         }
         if (!partner.isProcessing && !partner._queryStarting) {
           clearInterval(timer);
-          finishDelegation(group, caller, partner, token);
           var failure = errorSince(partner.history || [], token.startIndex);
           var interrupted = !failure && !!partner._lastTurnInterrupted;
           var response = responseText(partner.history || [], token.startIndex);
           if (interrupted) taskControl.ensureSystemInterruption(partner, token);
           var outcome = taskControl.complete(partner, caller, token, failure ? "failed" : (interrupted ? "interrupted" : "completed"), response, failure);
+          resultCapture.capture(caller, partner, token, outcome);
           resolve({
-            status: failure ? "error" : (outcome.status === "completed" ? "complete" : outcome.status),
+            status: token._capturePending ? "capture_pending" : (failure ? "error" : (outcome.status === "completed" ? "complete" : outcome.status)),
             taskId: token.taskId,
             generation: token.generation,
             response: response,
             error: failure || undefined,
             outcome: outcome,
           });
-          taskControl.drain(caller, partner);
           return;
         }
         if (Date.now() >= deadline || token.detachRequested) {
           clearInterval(timer);
-          token.detached = true;
+          var routed = token.outboxKey && ctx.resultOutbox ? ctx.resultOutbox.setRoute(token.outboxKey, "callback") : { ok: true };
+          if (!routed.ok) {
+            monitorPartner(group, caller, partner, token);
+            resolve({ status: "capture_pending", taskId: token.taskId, generation: token.generation, response: responseText(partner.history || [], token.startIndex), error: routed.error });
+            return;
+          }
+          token.wait = false; token.detached = true;
           monitorPartner(group, caller, partner, token);
-          resolve({ status: "running", taskId: token.taskId, generation: token.generation, response: responseText(partner.history || [], token.startIndex), hint: "The completed result will be pushed back automatically. Use read_partner only for an interim status check." });
+          resolve({ status: "running", taskId: token.taskId, generation: token.generation, response: responseText(partner.history || [], token.startIndex), hint: "The completed result will be pushed back automatically. Use read_partner only for a requested status, concrete failure or stall diagnosis, or capacity/queue decision; do not poll routinely." });
         }
       }, 500);
     });
@@ -201,14 +197,20 @@ function attachSessionPair(ctx) {
       var message = typeof args.message === "string" ? args.message.trim() : "";
       if (!message) throw new Error("message is required");
       turnControl.assertWorkerAction(caller);
-      var wait = args.wait !== false;
+      var wait = args.wait === true;
       var timeout = Number.isFinite(args.timeoutSeconds) ? Math.floor(args.timeoutSeconds) : 300;
       timeout = Math.max(1, Math.min(900, timeout));
       var partner = resolved.partner;
       if (partner._pairDelegation) throw new Error("the partner is already handling a delegated task");
       delete partner._pairInterruption; delete partner._lastInterruptedPairTask;
       var task = taskControl.begin(partner, caller, message, args.taskId);
-      var token = Object.assign(task, { from: caller.localId, groupId: resolved.group.id, startIndex: partner.history.length });
+      var token = Object.assign(task, { from: caller.localId, groupId: resolved.group.id, startIndex: partner.history.length, wait: wait });
+      var started = resultCapture.begin(caller, partner, token, message, ctx.projectSlug);
+      if (!started.ok) {
+        token._retainOnError = true; partner._pairDelegation = token; partner._delegatedBy = caller.localId;
+        sm.sendAndRecord(caller, { type: "error", text: "The Split Worker task was not dispatched because its durable completion record could not be created: " + started.error });
+        return toolError(new Error(started.error));
+      }
       partner._pairDelegation = token;
       partner._delegatedBy = caller.localId;
       sm.sendAndRecord(partner, {
@@ -243,14 +245,14 @@ function attachSessionPair(ctx) {
       if (!wait) {
         token.detached = true;
         monitorPartner(resolved.group, caller, partner, token);
-        return toolResult({ status: "running", partnerId: partner.localId, taskId: token.taskId, generation: token.generation, hint: "The completed result will be pushed back automatically. Use read_partner only for an interim status check." });
+        return toolResult({ status: "running", partnerId: partner.localId, taskId: token.taskId, generation: token.generation, hint: "The completed result will be pushed back automatically. Use read_partner only for a requested status, concrete failure or stall diagnosis, or capacity/queue decision; do not poll routinely." });
       }
       if (!partner.isProcessing && !partner._queryStarting) {
-        finishDelegation(resolved.group, caller, partner, token);
         var immediateFailure = errorSince(partner.history || [], token.startIndex);
         var immediateResponse = responseText(partner.history || [], token.startIndex);
         var immediateOutcome = taskControl.complete(partner, caller, token, immediateFailure ? "failed" : "completed", immediateResponse, immediateFailure);
-        taskControl.drain(caller, partner);
+        var immediateCapture = resultCapture.capture(caller, partner, token, immediateOutcome);
+        if (!immediateCapture && token._capturePending) return toolError(new Error("The completed Split Worker result could not be durably captured yet."));
         return toolResult({
           status: immediateFailure ? "error" : (immediateOutcome.status === "completed" ? "complete" : immediateOutcome.status),
           taskId: token.taskId,
@@ -268,7 +270,7 @@ function attachSessionPair(ctx) {
         if (group) {
           var partnerId = group.members[0] === caller.localId ? group.members[1] : group.members[0];
           var partner = sm.sessions.get(partnerId);
-          if (partner && partner._pairDelegation && partner._pairDelegation.from === caller.localId && !partner.isProcessing) {
+          if (partner && partner._pairDelegation && partner._pairDelegation.from === caller.localId && !partner.isProcessing && !partner._pairDelegation._retainOnError) {
             finishDelegation(group, caller, partner, partner._pairDelegation);
           }
         }
@@ -334,6 +336,7 @@ function attachSessionPair(ctx) {
   function handleHumanStop(session) {
     var roles = turnControl.markHumanStop(session);
     if (!roles) return false;
+    if (roles.worker._pairDelegation && roles.worker._pairDelegation.outboxKey && ctx.resultOutbox) ctx.resultOutbox.markBlocked(roles.worker._pairDelegation.outboxKey, "The human stopped this Split Worker turn.", "human_stop");
     taskControl.markInterruption(roles.worker, "user", "The human stopped this Split Worker turn.");
     workerPermission.cancelForSession(roles.worker, "The human stopped this Split Worker turn.");
     return true;
@@ -487,8 +490,9 @@ function attachSessionPair(ctx) {
     }
     return pairPrompt;
   }
-  return { beginHumanTurn: beginHumanTurn, getToolDefs: getToolDefs, handleHumanStop: handleHumanStop, stopOwnedPair: stopOwnedPair, stopAutonomousWork: stopAutonomousWork, stopBarrier: stopBarrier,
-    handleMessage: handleMessage, handleTurnDone: handleTurnDone, getSystemPrompt: getSystemPrompt,
+  var resultPipeline = attachPairResultPipeline({ sm: sm, store: store, resultOutbox: ctx.resultOutbox, getSdk: ctx.getSdk, getLinuxUserForSession: ctx.getLinuxUserForSession, acceptanceTimeoutMs: ctx.acceptanceTimeoutMs, finishDelegation: finishDelegation, resumeDriverWithResult: resumeDriverWithResult, onPartnerResult: ctx.onPartnerResult, onStateChange: ctx.onResultStateChange, blockedReason: turnControl.blockedReason, drain: function (caller, partner) { return taskControl.drain(caller, partner); } });
+  resultCapture = resultPipeline.capture; var resultDelivery = resultPipeline.delivery;
+  return { beginHumanTurn: beginHumanTurn, getToolDefs: getToolDefs, handleHumanStop: handleHumanStop, stopOwnedPair: stopOwnedPair, stopAutonomousWork: stopAutonomousWork, stopBarrier: stopBarrier, handleMessage: handleMessage, handleTurnDone: handleTurnDone, getSystemPrompt: getSystemPrompt,
     respondToWorkerProposal: workerProposal.respondToProposal, workerPermission: workerPermission, createOwnedPair: createOwnedPair, removeOwnedPair: removeOwnedPair, preflightRuntime: preflightRuntime,
-    sendToPartner: sendToPartner, rolesFor: rolesFor };
+    sendToPartner: sendToPartner, rolesFor: rolesFor, resultCapture: resultCapture, resultOutbox: ctx.resultOutbox, wakePartnerResult: function (caller, partner, token) { return resultDelivery.wake(caller, partner, token); }, getResultOutboxStatus: function () { return ctx.resultOutbox ? ctx.resultOutbox.status() : { records: [], persistenceError: null }; } };
 } module.exports = { attachSessionPair: attachSessionPair, responseText: responseText, recentTurns: recentTurns };

package/lib/project.js

@@ -55,6 +55,8 @@ var { attachDelegatedFollowUp } = require("./project-delegated-follow-up");
 var { attachCapsuleTurn } = require("./project-capsule-turn");
 var workspaceSessionRef = require("./workspace-query-service").sessionRef;
 var { attachSessionPair } = require("./project-session-pair");
+var { attachPairResultOutbox } = require("./project-pair-result-outbox");
+var { attachPairResultRecovery } = require("./project-pair-result-recovery");
 var { attachSessionHandoff } = require("./project-session-handoff");
 var { attachDriverContinuation } = require("./project-driver-continuation");
 var driverContinuationAccess = require("./driver-continuation-access");
@@ -819,6 +821,9 @@ function createProjectContext(opts) {
 
   // The SDK bridge is created after local MCP servers. Session spawning uses
   // a getter so tool handlers see the initialized bridge when they run.
+  var _pairResultOutbox = attachPairResultOutbox({ storageDir: sm.sessionsDir, projectSlug: slug });
+  _pairResultOutbox.recoverPending(sm.sessions);
+  var _pairResultRecovery = null;
   var _sessionPair = attachSessionPair({
     sm: sm,
     isMate: isMate,
@@ -837,12 +842,21 @@ function createProjectContext(opts) {
     usersModule: usersModule,
     getLinuxUserForSession: getLinuxUserForSession,
     onProcessingChanged: onProcessingChanged,
+    projectSlug: slug,
+    resultOutbox: _pairResultOutbox,
+    onResultStateChange: function (driver, record) { if (_pairResultRecovery) _pairResultRecovery.stateChanged(driver, record); },
     adapters: adapters,
     onPartnerResult: function (driver, worker, token) {
       if (_scheduledTaskExecution) _scheduledTaskExecution.onPartnerResult(driver, worker, token);
       if (_autonomousRun) _autonomousRun.onPartnerResult(driver, worker, token);
     },
   });
+  _pairResultRecovery = attachPairResultRecovery({
+    sm: sm, store: _splitGroups.store, outbox: _pairResultOutbox, resultCapture: _sessionPair.resultCapture,
+    wake: _sessionPair.wakePartnerResult, projectSlug: slug, sendTo: sendTo,
+    blockedReason: _sessionPair.stopBarrier,
+    getClients: function () { return clients; }, isMultiUser: usersModule.isMultiUser,
+  });
   var _sessionSpawn = attachSessionSpawn({
     cwd: cwd,
     sm: sm,
@@ -1277,6 +1291,7 @@ function createProjectContext(opts) {
     },
     onProcessingChanged: onProcessingChanged,
     onSessionAvailable: function (session) {
+      if (_pairResultRecovery) _pairResultRecovery.available(session);
       if (_scheduledMessages) _scheduledMessages.notify();
       if (_userMessage && session) setImmediate(function () { _userMessage.consumePendingMessage(session); });
     },
@@ -1741,6 +1756,7 @@ function createProjectContext(opts) {
     if (msg.type === "memory_delete") { _memory.handleMemoryDelete(ws, msg); return; }
 
     // --- Sessions, config, project mgmt (delegated to project-sessions.js) ---
+    if (_pairResultRecovery.handleMessage(ws, msg)) return;
     if (_sessionPair.handleMessage(ws, msg)) return;
     if (_sessionHandoff.handleMessage(ws, msg)) return;
     if (_driverContinuation.handleMessage(ws, msg)) return;
@@ -2016,6 +2032,7 @@ function createProjectContext(opts) {
     serverAuthToken: serverAuthToken,
     resolveDefaultAi: opts.resolveDefaultAi,
   });
+  _pairResultRecovery.reconcile();
   var _toolLlmRuntime = attachProjectToolLlmRuntime({
     users: usersModule,
     osUsers: osUsers,
@@ -2066,7 +2083,11 @@ function createProjectContext(opts) {
       if (isMate || !_sessionPair.workerPermission) return false;
       return _sessionPair.workerPermission.isDriverOperated(session);
     },
-    beginHumanPairTurn: function (session) { return _sessionPair.beginHumanTurn(session); },
+    beginHumanPairTurn: function (session) {
+      var resumed = _sessionPair.beginHumanTurn(session);
+      if (resumed) _pairResultRecovery.beginHumanTurn(session);
+      return resumed;
+    },
     authorizePendingDispatch: function (session, actor, item) {
       if (!session || sm.sessions.get(session.localId) !== session || !item || item.projectSlug !== slug) return false;
       if (_scheduledMessages && !_scheduledMessages.authorizePending(item, session)) return false;
@@ -2499,6 +2520,7 @@ function createProjectContext(opts) {
     _email: _email,
     restoreDebateState: restoreDebateState,
     scheduledMessages: _scheduledMessages,
+    pairResultRecovery: _pairResultRecovery,
     sendCursorSharingState: opts.sendCursorSharingState,
     stopFileWatch: stopFileWatch,
     stopAllDirWatches: stopAllDirWatches,

package/lib/public/app.js

@@ -276,6 +276,7 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     splitPanes: null,
     splitGroups: [],
     splitDelegations: {},
+    pairResultStatus: [],
     notesTemporarilyHidden: false,
     dmMode: false,
     historyFrom: 0,

package/lib/public/css/messages.css

@@ -1387,6 +1387,18 @@ pre.mermaid-error {
 .plan-banner.plan-exit { color: var(--success); }
 .plan-banner.plan-exit .plan-banner-icon { color: var(--success); }
 
+.pair-result-status { display: grid; gap: 8px; padding: 10px 16px 0; }
+.pair-result-status-card { border: 1px solid var(--border); border-radius: 10px; background: var(--bg-alt); padding: 10px 12px; color: var(--text-secondary); font-size: 12px; }
+.pair-result-status-card > strong, .pair-result-status-card > span { display: block; }
+.pair-result-status-card > strong { color: var(--text); margin-bottom: 3px; }
+.pair-result-status-card details { margin-top: 7px; }
+.pair-result-status-card summary { cursor: pointer; color: var(--accent); }
+.pair-result-status-card pre { max-height: 180px; overflow: auto; white-space: pre-wrap; font: inherit; }
+.pair-result-status-card button { margin-top: 8px; }
+.pair-result-status-retry:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+.pair-result-status-retry:disabled { cursor: not-allowed; opacity: 0.55; }
+.pair-result-status-uncertain, .pair-result-status-blocked { border-color: color-mix(in srgb, var(--warning) 45%, var(--border)); }
+
 /* --- Plan card --- */
 .plan-card {
   max-width: var(--content-width);

package/lib/public/modules/app-messages.js

@@ -62,6 +62,7 @@ import { handleShellCommandResult } from './shell-command.js';
 import { handleLoopRegistryUpdated, handleScheduleRunStarted, handleScheduleRunFinished, handleLoopScheduled, isSchedulerOpen, enterCraftingMode, exitCraftingMode, handleLoopRegistryFiles } from './scheduler.js';
 import { handleScheduledTaskMessage, handleScheduledTaskSessionSwitched } from './scheduled-tasks.js';
 import { renderGeneratedImage, renderImageGenerationProgress, clearImageGenerationProgress, clearAllImageGenerationProgress } from './generated-images.js';
+import { clearPairResultStatus, handlePairResultStatus } from './pair-result-status.js';
 
 // --- App module imports ---
 import { scrollToBottom, addToMessages, addUserMessage, addSystemMessage, removeMatePreThinking, appendDelta, finalizeAssistantBlock, addConflictMessage, addContextOverflowMessage, showSuggestionChips, armStickyBottom, VENDOR_AVATARS, VENDOR_NAMES } from './app-rendering.js';
@@ -243,6 +244,7 @@ export function processMessage(msg) {
         // Restore cached rich context usage BEFORE updateContextPanel runs
         if (msg.contextUsage && !msg.contextUsage.unavailable) store.set({ richContextUsage: msg.contextUsage });
         else markContextUnavailable();
+
         // Restore accurate context data from the last result in full history
         if (msg.lastUsage || msg.lastModelUsage) {
           accumulateContext(msg.lastCost, msg.lastUsage, msg.lastModelUsage, msg.lastStreamInputTokens);
@@ -804,6 +806,10 @@ export function processMessage(msg) {
         handleRemoteSelection(msg);
         break;
 
+      case "pair_result_status":
+        handlePairResultStatus(msg);
+        break;
+
       case "session_io":
         blinkSessionDot(msg.id);
         break;
@@ -823,6 +829,7 @@ export function processMessage(msg) {
         break;
 
       case "session_switched":
+        clearPairResultStatus();
         syncAutonomousRunForSession(msg.autonomousRun || null);
         closeWhatsNewArticle();
         // Save draft from outgoing session

package/lib/public/modules/pair-result-status.js

@@ -0,0 +1,87 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { showConfirm } from './app-misc.js';
+
+var statusGeneration = 0;
+
+function retrySource(item) {
+  return { item: item, generation: statusGeneration, projectSlug: store.get("currentSlug") || store.get("activeProjectSlug") || null,
+    sessionId: store.get("activeSessionId"), userId: store.get("myUserId") || null, ws: getWs() };
+}
+
+function sendRetry(source, confirmed) {
+  var ws = getWs();
+  var projectSlug = store.get("currentSlug") || store.get("activeProjectSlug") || null;
+  var items = store.get("pairResultStatus") || [];
+  var stillVisible = items.some(function (item) { return item.id === source.item.id; });
+  if (!ws || ws !== source.ws || ws.readyState !== 1 || statusGeneration !== source.generation ||
+      store.get("activeSessionId") !== source.sessionId || projectSlug !== source.projectSlug ||
+      (store.get("myUserId") || null) !== source.userId || !stillVisible) return false;
+  ws.send(JSON.stringify({ type: "pair_result_retry", id: source.item.id, confirmDuplicate: confirmed === true,
+    sessionId: source.sessionId, projectSlug: source.projectSlug }));
+  return true;
+}
+
+function retry(item) {
+  var source = retrySource(item);
+  if (item.confirmDuplicate) {
+    showConfirm("The Driver may already have received this completed result. Retry delivery anyway? This can cause a duplicate result receipt.", function () {
+      sendRetry(source, true);
+    }, "Retry delivery", false);
+    return;
+  }
+  sendRetry(source, false);
+}
+
+function renderPairResultStatus() {
+  var existing = document.getElementById("pair-result-status");
+  if (existing) existing.remove();
+  var items = store.get("pairResultStatus") || [];
+  if (!items.length) return;
+  var messages = document.getElementById("messages");
+  if (!messages || !messages.parentElement) return;
+  var section = document.createElement("section");
+  section.id = "pair-result-status";
+  section.className = "pair-result-status";
+  section.setAttribute("role", "status");
+  for (var i = 0; i < items.length; i++) {
+    var item = items[i], card = document.createElement("div");
+    card.className = "pair-result-status-card pair-result-status-" + item.state;
+    var title = document.createElement("strong");
+    title.textContent = item.state === "blocked" ? "Split Worker result blocked" :
+      (item.state === "uncertain" ? (item.hasCompletedResult === false ? "Split Worker recovery uncertain" : "Split Worker result delivery uncertain") : "Split Worker result pending");
+    var message = document.createElement("span");
+    message.textContent = item.message || "The completed result is retained.";
+    card.appendChild(title); card.appendChild(message);
+    if (item.hasCompletedResult !== false) {
+      var details = document.createElement("details"), summary = document.createElement("summary"), body = document.createElement("pre");
+      summary.textContent = "View completed result";
+      body.textContent = item.error ? "Error: " + item.error : (item.response || "No text response was recorded.");
+      details.appendChild(summary); details.appendChild(body); card.appendChild(details);
+    }
+    if (item.canRetry) {
+      var button = document.createElement("button");
+      button.type = "button"; button.className = "confirm-btn confirm-ok pair-result-status-retry"; button.textContent = "Retry delivery";
+      button.addEventListener("click", retry.bind(null, item));
+      card.appendChild(button);
+    }
+    section.appendChild(card);
+  }
+  messages.parentElement.insertBefore(section, messages);
+}
+
+function handlePairResultStatus(msg) {
+  if (!msg || msg.sessionId !== store.get("activeSessionId")) return false;
+  statusGeneration++;
+  store.set({ pairResultStatus: Array.isArray(msg.items) ? msg.items : [] });
+  renderPairResultStatus();
+  return true;
+}
+
+function clearPairResultStatus() {
+  statusGeneration++;
+  store.set({ pairResultStatus: [] });
+  renderPairResultStatus();
+}
+
+export { clearPairResultStatus, handlePairResultStatus, renderPairResultStatus };