clay-server 4.3.0-beta.3 → 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/css/overlays.css

@@ -518,7 +518,7 @@ button.top-bar-pill.pill-accent:hover { background: color-mix(in srgb, var(--acc
 .popover-copy:hover { color: var(--text); border-color: var(--text-dimmer); }
 .popover-copy.copied { color: var(--success); border-color: var(--success); }
 
-/* Skip permissions pill */
+/* Quiet native toolbar control for session permission mode. */
 .session-permission-control {
   display: inline-flex;
   align-items: center;
@@ -535,35 +535,40 @@ button.top-bar-pill.pill-accent:hover { background: color-mix(in srgb, var(--acc
   flex: 0 0 auto;
   gap: 1px;
   padding: 2px;
-  border: 1px solid color-mix(in srgb, var(--border, #45484f) 88%, transparent);
-  border-radius: 10px;
-  background: color-mix(in srgb, var(--surface-raised, rgba(0,0,0,.18)) 86%, transparent);
-  box-shadow: inset 0 1px 0 rgba(255,255,255,.04), 0 2px 8px rgba(0,0,0,.12);
+  border: 1px solid color-mix(in srgb, var(--border) 82%, transparent);
+  border-radius: 8px;
+  background: color-mix(in srgb, var(--bg-alt) 72%, transparent);
 }
 .session-permission-segmented button {
   position: relative;
-  flex: 0 0 auto;
+  flex: 0 0 48px;
+  width: 48px;
+  height: 22px;
   border: 0;
   border-radius: 7px;
-  padding: 4px 9px;
-  color: var(--text-muted, inherit);
+  padding: 3px 4px;
+  color: var(--text-secondary);
   background: transparent;
   font: inherit;
+  font-weight: 500;
   font-size: 11px;
   line-height: 1;
   white-space: nowrap;
   cursor: pointer;
-  transition: color .15s ease, background .15s ease, box-shadow .15s ease;
-}
-.session-permission-segmented button:hover:not(:disabled) { color: var(--text, #fff); background: rgba(255,255,255,.07); }
-.session-permission-segmented button:focus-visible { outline: 2px solid var(--accent, #6f8cff); outline-offset: 1px; z-index: 1; }
-.session-permission-segmented button.active { background: var(--accent, #6f8cff); color: #fff; box-shadow: 0 1px 4px rgba(0,0,0,.2); }
-.session-permission-segmented button:disabled { cursor: not-allowed; opacity: .5; }
+  transition: color .15s ease, background .15s ease, box-shadow .15s ease, border-color .15s ease;
+}
+.session-permission-segmented button:hover:not(:disabled) { color: var(--text); background: color-mix(in srgb, var(--bg) 76%, transparent); }
+.session-permission-segmented button:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; z-index: 1; }
+.session-permission-segmented button.active { border: 1px solid var(--border); background: var(--input-bg); color: var(--text); font-weight: var(--font-weight-heading, 600); box-shadow: 0 1px 2px rgba(var(--shadow-rgb), .12); }
+:root.light-theme .session-permission-segmented button.active { background: var(--bg); }
+.session-permission-segmented button:disabled { cursor: not-allowed; }
+.session-permission-control:not(.permission-pending) .session-permission-segmented button:disabled { color: var(--text-muted); opacity: .65; }
 .session-permission-control.permission-pending .session-permission-segmented button:disabled { cursor: wait; }
-.session-permission-segmented button.pending { color: #fff; }
-.permission-spinner { display: inline-block; visibility: hidden; width: 10px; height: 10px; margin-left: 4px; vertical-align: -1px; border: 1.5px solid currentColor; border-right-color: transparent; border-radius: 50%; }
+.session-permission-segmented button.pending { color: var(--text); background: color-mix(in srgb, var(--bg) 42%, transparent); }
+.session-permission-segmented button.pending .permission-label { visibility: hidden; }
+.permission-spinner { position: absolute; inset: 50% auto auto 50%; display: block; visibility: hidden; width: 10px; height: 10px; transform: translate(-50%, -50%); border: 1.5px solid currentColor; border-right-color: transparent; border-radius: 50%; }
 .session-permission-segmented button.pending .permission-spinner { visibility: visible; animation: permission-spin .7s linear infinite; }
-@keyframes permission-spin { to { transform: rotate(360deg); } }
+@keyframes permission-spin { to { transform: translate(-50%, -50%) rotate(360deg); } }
 .session-permission-status {
   flex: 0 1 auto;
   min-width: 0;
@@ -592,12 +597,8 @@ button.top-bar-pill.pill-accent:hover { background: color-mix(in srgb, var(--acc
 }
 .permission-runtime-fallback .session-permission-status { color: var(--warning, #d49a55); }
 .permission-globally-forced .session-permission-status { color: var(--warning, #d49a55); }
-.permission-label-short { display: none; }
 @media (max-width: 760px) {
-  .permission-label-long { display: none; }
-  .permission-label-short { display: inline; }
   .session-permission-control { column-gap: 4px; }
-  .session-permission-segmented button { padding-inline: 7px; }
   .session-permission-status {
     max-width: 132px;
     font-size: 9px;