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

package/lib/project-worker-proposal.js

@@ -3,8 +3,12 @@ var yoke = require("./yoke");
 var buildShape = require("./session-spawn-mcp-server").buildShape;
 var driverEligibility = require("./session-driver-eligibility");
 var driverOrchestration = require("./session-driver-orchestration");
+var pairTarget = require("./session-pair-target");
+var splitRoles = require("./session-split-group-roles");
 var proposalControl = require("./worker-proposal-control");
 var runtimeCatalog = require("./worker-runtime-catalog");
+var proposalRunner = require("./project-worker-proposal-runner");
+var creationProposalModule = require("./project-worker-creation-proposal");
 var MAX_SUMMARY_CHARS = 600, MAX_PLAN_CHARS = 6000, MAX_TASK_CHARS = 30000, MAX_RATIONALE_CHARS = 1000;
 var EVALUATION_OUTCOMES = ["succeeded", "partial", "failed", "abandoned"];
 function normalizeEvaluation(raw) {
@@ -161,66 +165,18 @@ function attachWorkerProposal(ctx) {
       proposalId: proposal.proposalId,
     }, patch));
   }
-  async function propose(args, session) {
-    if (!isEligible(session)) return toolResult({ error: "Split Worker proposals are only available in an eligible unpaired Driver session." });
-    var superseded = proposalControl.pendingProposal(session);
-    var supersedeId = typeof args.supersedeProposalId === "string" ? args.supersedeProposalId.trim() : "";
-    if (superseded && superseded.proposalId !== supersedeId) return toolResult({ error: "A Split Worker suggestion is already awaiting a decision. Inspect it or supply its exact id to supersede it." });
-    if (!superseded && supersedeId) return toolResult({ error: "The Split Worker suggestion to supersede is no longer pending." });
-    if (superseded && superseded.status !== "pending") return toolResult({ error: "The Split Worker suggestion is already starting and cannot be superseded." });
-    var summary = typeof args.summary === "string" ? args.summary.trim() : "";
-    var plan = typeof args.plan === "string" ? args.plan.trim() : "";
-    var task = typeof args.message === "string" ? args.message.trim() : "";
-    var rationale = typeof args.recommendationRationale === "string" ? args.recommendationRationale.trim() : "";
-    if (!summary || !plan || !task || !rationale) {
-      return toolResult({ error: "summary, plan, message, and recommendationRationale are required." });
-    }
-    if (task.length > MAX_TASK_CHARS) return toolResult({ error: "The Split Worker task is too long." });
-    await ensureModelCatalogs();
-    if (!isEligible(session)) {
-      return toolResult({ error: "The Driver session changed while Split Worker runtimes were loading." });
-    }
-    var currentPending = proposalControl.pendingProposal(session);
-    if (currentPending !== superseded) return toolResult({ error: "The pending Split Worker suggestion changed while runtimes were loading." });
-    var options = proposalOptions();
-    if (options.installedVendors.length === 0) return toolResult({ error: "No coding agent is installed for a Split Worker session." });
-    var recommendation = chooseRecommendation(args, session, options);
-    var proposal = {
-      type: "worker_proposal",
-      proposalId: "worker_" + crypto.randomUUID(),
-      summary: summary.slice(0, MAX_SUMMARY_CHARS),
-      plan: plan.slice(0, MAX_PLAN_CHARS),
-      message: task,
-      status: "pending",
-      createdAt: Date.now(),
-      recommendedVendor: recommendation.vendor,
-      recommendedModel: recommendation.model,
-      recommendedEffort: recommendation.effort,
-      recommendationRationale: rationale.slice(0, MAX_RATIONALE_CHARS),
-      options: options,
-    };
-    if (superseded) updateProposal(session, superseded, { status: "superseded", supersededBy: proposal.proposalId });
-    sm.sendAndRecord(session, proposal);
-    if (skipPermissionsEnabled(session) && recommendationCanAutoAccept(args, recommendation, options)) {
-      var accepted = await acceptProposal(session, proposal, {
-        vendor: recommendation.vendor,
-        model: recommendation.model,
-        effort: recommendation.effort,
-      }, autoAcceptanceWs(session), true);
-      return toolResult({
-        status: accepted.ok ? "auto_accepted" : "posted",
-        proposalId: proposal.proposalId,
-        instruction: accepted.ok
-          ? "The recorded Split Worker configuration was auto-accepted under the Driver session's full-access mode. End this turn now while the exact paired Worker runs."
-          : "The automatic decision failed closed. The configuration card remains pending for the user; end this turn and wait for their decision.",
-      });
-    }
-    return toolResult({
-      status: "posted",
-      proposalId: proposal.proposalId,
-      instruction: "The Split Worker suggestion is visible in the chat. End this turn now and wait for the user's decision.",
-    });
-  }
+  var runner = proposalRunner.attachProposalRunner(Object.assign({}, ctx, { updateProposal: updateProposal }));
+  var resumeDriver = runner.resumeDriver;
+  var runWorker = runner.runWorker;
+  var creationProposal = creationProposalModule.attachWorkerCreationProposal({
+    sm: sm, splitStore: store, multiWorkerFeature: ctx.multiWorkerFeature,
+    canOffer: canOffer, isEligible: isEligible, ensureModelCatalogs: ensureModelCatalogs,
+    proposalOptions: proposalOptions, chooseRecommendation: chooseRecommendation,
+    skipPermissionsEnabled: skipPermissionsEnabled, recommendationCanAutoAccept: recommendationCanAutoAccept,
+    autoAcceptanceWs: autoAcceptanceWs, acceptProposal: acceptProposal, updateProposal: updateProposal,
+    toolResult: toolResult, maxSummaryChars: MAX_SUMMARY_CHARS, maxPlanChars: MAX_PLAN_CHARS,
+    maxTaskChars: MAX_TASK_CHARS, maxRationaleChars: MAX_RATIONALE_CHARS,
+  });
   async function proposeReplacement(args, session) {
     var group = session && store.groupForMember(session.localId);
     if (ctx.isMate || !isLiveSession(session) || !driverEligibility.isEligibleDriverSession(session, sm) || !group ||
@@ -228,7 +184,17 @@ function attachWorkerProposal(ctx) {
       return toolResult({ error: "Split Worker replacement proposals require the exact paired Driver session." });
     }
     var sourceGroupId = group.id;
-    var sourceWorkerId = group.pair.workerId;
+    var addressed;
+    try { addressed = pairTarget.resolveGroupTarget(sm, group, session, args, {
+      mutation: true, multiWorkerFeature: ctx.multiWorkerFeature,
+    }); }
+    catch (e) { return toolResult({ error: e.message || String(e) }); }
+    var sourceWorkerId = addressed.workerId;
+    var sourceWorkerOriginId = addressed.partner.sessionOriginId || null;
+    var sourceGeneration = addressed.partner._pairGeneration ||
+      addressed.partner.sessionProvenance && addressed.partner.sessionProvenance.generation || null;
+    var sourceMembership = creationProposalModule.captureMembership(sm, session, group);
+    if (!sourceMembership) return toolResult({ error: "The exact Driver/Split Worker identities are not durable enough to replace a Worker." });
     var superseded = proposalControl.pendingProposal(session);
     var supersedeId = typeof args.supersedeProposalId === "string" ? args.supersedeProposalId.trim() : "";
     if (superseded && superseded.proposalId !== supersedeId) return toolResult({ error: "A Split Worker proposal is already awaiting a decision. Inspect it or supply its exact id to supersede it." });
@@ -245,9 +211,17 @@ function attachWorkerProposal(ctx) {
     var liveGroup = store.groupForMember(session.localId);
     if (!isLiveSession(session) || !driverEligibility.isEligibleDriverSession(session, sm) ||
         !liveGroup || liveGroup.id !== sourceGroupId || !liveGroup.pair ||
-        liveGroup.pair.driverId !== session.localId || liveGroup.pair.workerId !== sourceWorkerId) {
+        liveGroup.pair.driverId !== session.localId || liveGroup.members.indexOf(sourceWorkerId) === -1 ||
+        sm.sessions.get(sourceWorkerId) !== addressed.partner ||
+        (addressed.partner.sessionOriginId || null) !== sourceWorkerOriginId ||
+        (addressed.partner._pairGeneration || addressed.partner.sessionProvenance && addressed.partner.sessionProvenance.generation || null) !== sourceGeneration ||
+        !creationProposalModule.matchesMembership(sm, session, liveGroup, sourceMembership)) {
       return toolResult({ error: "The Driver/Split Worker pair changed while replacement runtimes were loading." });
     }
+    try { pairTarget.resolveGroupTarget(sm, liveGroup, session, args, {
+      mutation: true, multiWorkerFeature: ctx.multiWorkerFeature,
+    }); }
+    catch (e) { return toolResult({ error: e.message || String(e) }); }
     var currentPending = proposalControl.pendingProposal(session);
     if (currentPending !== superseded) return toolResult({ error: "The pending Split Worker proposal changed while runtimes were loading." });
     var options = proposalOptions();
@@ -274,6 +248,10 @@ function attachWorkerProposal(ctx) {
       options: options,
       sourceGroupId: sourceGroupId,
       sourceWorkerId: sourceWorkerId,
+      sourceWorkerOriginId: sourceWorkerOriginId,
+      sourceGeneration: sourceGeneration,
+      sourceMembership: sourceMembership,
+      workerId: sourceWorkerId,
       interrupt: args.interrupt === true,
       evaluation: normalizedEvaluation ? normalizedEvaluation.value : null,
       transactionId: "replace_" + crypto.randomUUID(),
@@ -300,50 +278,6 @@ function attachWorkerProposal(ctx) {
       instruction: "The replacement configuration is visible in the chat. End this turn now and wait for the user's decision.",
     });
   }
-  function resumeDriver(session, text) {
-    var sdk = ctx.getSdk();
-    if (!sdk) return Promise.reject(new Error("SDK bridge is not ready"));
-    var message = { type: "user_message", text: text, _internal: true };
-    sm.sendAndRecord(session, message);
-    session.sentToolResults = {};
-    if (!session.isProcessing) {
-      session.isProcessing = true;
-      ctx.onProcessingChanged();
-      sm.sendToSession(session, { type: "status", status: "processing" });
-    }
-    if (sdk.pushMessage(session, text)) return Promise.resolve();
-    return Promise.resolve(sdk.startQuery(session, text, undefined, ctx.getLinuxUserForSession(session)));
-  }
-
-  function parsePartnerResult(result) {
-    if (!result || result.isError || !result.content || !result.content[0]) {
-      return { status: "error", error: "Split Worker execution failed." };
-    }
-    try { return JSON.parse(result.content[0].text); }
-    catch (e) { return { status: "error", error: result.content[0].text || "Split Worker execution failed." }; }
-  }
-
-  async function runWorker(session, proposal) {
-    var result = parsePartnerResult(await ctx.sendToPartner({ message: proposal.message, wait: true, timeoutSeconds: 900 }, session));
-    var status = result.status === "complete" ? "completed" : result.status;
-    updateProposal(session, proposal, {
-      status: status || "error",
-      resultPreview: result.response ? result.response.slice(0, 1200) : "",
-      error: result.error || null,
-    });
-    var followup;
-    if (result.status === "complete") {
-      followup = "[Split Worker execution completed]\nReview and verify the Split Worker's result. The Split Worker session remains available: if the implementation needs corrections or additional edits, send a follow-up with send_to_partner instead of taking over the Split Worker-owned files yourself. If that Split Worker is no longer available, keep the work in the visible Split Worker flow and use send_to_partner again after the stale pair is removed; never substitute a background Sub-agent.\n\n" + (result.response || "The Split Worker completed without a text summary.");
-    } else if (result.status === "interrupted") {
-      followup = "[Split Worker execution interrupted]\nThe Split Worker stopped mid-turn. Its work is PARTIAL and unverified — do not treat it as finished. Check partner_status before deciding next steps; this result alone does not identify who interrupted it. If the human stopped it, do not retry until a new human Driver message. Otherwise continue within the user's authorized task.";
-    } else if (result.status === "running") {
-      followup = "[Split Worker execution is still running]\nUse read_partner to inspect progress before completing the task.";
-    } else {
-      followup = "[Split Worker execution failed]\nThe existing Split Worker may still be reusable. Inspect partner_status and send a narrower follow-up with send_to_partner when the Worker and pair still exist; do not replace it merely because its task or transport failed. Retry replacement only when the replacement transaction reports that no new Worker was created and the failure is explicitly safe to retry.\n\n" + (result.error || result.response || "Unknown Split Worker error.");
-    }
-    await resumeDriver(session, followup);
-  }
-
   function sessionForResponse(ws) {
     var session = sm.sessions.get(ws._clayActiveSession);
     if (!session) throw new Error("active Driver session not found");
@@ -356,19 +290,28 @@ function attachWorkerProposal(ctx) {
 
   async function acceptProposal(session, proposal, msg, ws, trustedAutoAcceptance) {
     if (!isLiveSession(session)) throw new Error("The Driver session is no longer live");
-    if (proposal.action !== "replace" && !isEligible(session)) {
+    if (!proposal.action && !isEligible(session)) {
       throw new Error("The Driver is no longer eligible to create this Split Worker");
     }
     var approvedGroup = null;
-    if (proposal.action === "replace") {
+    if (proposal.action === "add") {
+      var addition = creationProposal.validateAcceptance(session, proposal);
+      if (!addition.ok) throw new Error("The Driver/Split Worker membership changed before the addition was approved");
+      approvedGroup = addition.group;
+    } else if (proposal.action === "replace") {
       approvedGroup = store.groupForMember(session.localId);
+      var approvedRoles = splitRoles.normalizePair(approvedGroup && approvedGroup.pair, approvedGroup && approvedGroup.members);
+      var approvedWorker = sm.sessions.get(proposal.sourceWorkerId);
       if (!driverEligibility.isEligibleDriverSession(session, sm) || !approvedGroup ||
-          approvedGroup.id !== proposal.sourceGroupId || !approvedGroup.pair ||
-          approvedGroup.pair.driverId !== session.localId || approvedGroup.pair.workerId !== proposal.sourceWorkerId) {
+          approvedGroup.id !== proposal.sourceGroupId || !approvedRoles.ok || approvedRoles.kind === "adhoc" ||
+          approvedRoles.driverId !== session.localId || approvedRoles.workerIds.indexOf(proposal.sourceWorkerId) === -1 ||
+          !approvedWorker || (approvedWorker.sessionOriginId || null) !== (proposal.sourceWorkerOriginId || null) ||
+          (approvedWorker._pairGeneration || approvedWorker.sessionProvenance && approvedWorker.sessionProvenance.generation || null) !== proposal.sourceGeneration ||
+          !creationProposalModule.matchesMembership(sm, session, approvedGroup, proposal.sourceMembership)) {
         throw new Error("The Driver/Split Worker pair changed before the replacement was approved");
       }
     }
-    var options = proposalOptions();
+    var options = proposal.options || proposalOptions();
     var vendor = msg.vendor || proposal.recommendedVendor;
     var model = msg.model || "";
     if (options.installedVendors.indexOf(vendor) === -1) throw new Error("Selected Split Worker vendor is not installed");
@@ -390,6 +333,19 @@ function attachWorkerProposal(ctx) {
     };
     updateProposal(session, proposal, startingPatch);
     try {
+      if (proposal.action === "add") {
+        var added = ctx.addWorkerForDriver(session, {
+          workerVendor: vendor, workerModel: model, workerEffort: effort,
+          expectedGroup: approvedGroup, expectedWorkerIds: proposal.sourceWorkerIds,
+        });
+        ctx.recordGenerationStart(session, added.worker);
+        updateProposal(session, proposal, { status: "running", groupId: added.group.id, workerId: added.worker.localId });
+        runWorker(session, proposal).catch(function (err) {
+          updateProposal(session, proposal, { status: "error", error: err.message || String(err) });
+          resumeDriver(session, "[Split Worker execution failed]\n" + (err.message || String(err))).catch(function () {});
+        });
+        return { ok: true, status: "running", group: added.group, addition: added };
+      }
       if (proposal.action === "replace") {
         var liveGroup = approvedGroup;
         var replaced = await ctx.replacePartner({
@@ -399,6 +355,7 @@ function attachWorkerProposal(ctx) {
           workerEffort: effort,
           evaluation: proposal.evaluation || undefined,
           transactionId: proposal.transactionId,
+          workerId: proposal.workerId,
         }, session);
         liveGroup = store.groupForMember(session.localId);
         updateProposal(session, proposal, { status: "running", groupId: liveGroup.id, workerId: replaced.workerSessionId });
@@ -423,9 +380,11 @@ function attachWorkerProposal(ctx) {
     } catch (err) {
       if (proposal.action === "replace") {
         var restoredGroup = store.groupForMember(session.localId);
-        if (restoredGroup && restoredGroup.pair && restoredGroup.pair.driverId === session.localId &&
-            restoredGroup.pair.workerId === proposal.sourceWorkerId) {
+        var restoredRoles = splitRoles.normalizePair(restoredGroup && restoredGroup.pair, restoredGroup && restoredGroup.members);
+        if (restoredGroup && restoredRoles.ok && restoredRoles.kind !== "adhoc" &&
+            restoredRoles.driverId === session.localId && restoredRoles.workerIds.indexOf(proposal.sourceWorkerId) !== -1) {
           proposal.sourceGroupId = restoredGroup.id;
+          proposal.sourceMembership = creationProposalModule.captureMembership(sm, session, restoredGroup);
         }
         proposal.transactionId = "replace_" + crypto.randomUUID();
       }
@@ -449,6 +408,8 @@ function attachWorkerProposal(ctx) {
       updateProposal(session, proposal, { status: "declined" });
       var declinedText = proposal.action === "replace"
         ? "[Split Worker replacement declined]\nContinue with the existing Split Worker and the current task."
+        : proposal.action === "add"
+          ? "[Additional Split Worker declined]\nContinue with the existing Split Worker and current plan."
         : "[Split Worker proposal declined]\nContinue this task in the current Driver session using the plan you already prepared.";
       await resumeDriver(session, declinedText);
       return { ok: true, status: "declined" };
@@ -468,7 +429,7 @@ function attachWorkerProposal(ctx) {
     var persistent = !!(options && options.persistent);
     var controlsOnly = !!(options && options.controlsOnly);
     if (!isEligible(session) && !(persistent && canOffer(session))) return [];
-    var proposalTools = controlsOnly ? [] : [{
+    var proposalTools = controlsOnly && !creationProposal.canMountProposal(session) ? [] : [{
       name: "propose_worker",
       description: "Propose a visible Split Worker for implementation-heavy execution. This non-mutating tool only shows the user a card where they choose vendor, model, and effort. It never creates a session or delegates work until the user accepts.",
       inputSchema: buildShape({
@@ -481,7 +442,7 @@ function attachWorkerProposal(ctx) {
         recommendationRationale: { type: "string", description: "Concise Driver-authored explanation of why the recommended vendor, model, and effort fit this exact task." },
         supersedeProposalId: { type: "string", description: "Exact pending proposal id to resolve as superseded when posting this replacement suggestion." },
       }, ["summary", "plan", "message", "recommendationRationale"]),
-      handler: function (args) { return propose(args || {}, session); },
+      handler: function (args) { return creationProposal.propose(args || {}, session); },
     }];
     return proposalTools.concat(proposalControl.getToolDefs({
       inspect: function () { return toolResult(isLiveSession(session) ? proposalControl.projection(proposalControl.pendingProposal(session)) : { status: "rejected", reason: "The Driver session is no longer live." }); },
@@ -501,6 +462,9 @@ function attachWorkerProposal(ctx) {
   }
 
   function getSystemPrompt(session) {
+    if (creationProposal.canMountProposal(session) && !isEligible(session)) {
+      return "This Driver may configure one additional Split Worker through propose_worker. With two Workers, pass workerId to every targeted partner, queue, interrupt, replacement, close, permission, and status operation. Give each Worker independent file ownership and bounded work. Do not assign simultaneous overlapping file edits unless the work is explicitly separated, such as by distinct paths or worktrees.";
+    }
     if (!isEligible(session) || !driverOrchestration.isHighTierDriverSession(session, sm)) return "";
     return "For implementation-heavy work, use propose_worker before substantial execution. Work is implementation-heavy when it spans multiple modules, crosses client/server/data boundaries, requires a migration, or contains independent investigation and execution. Do not skip delegation merely because you can implement it yourself; preserve the Driver for decomposition, runtime selection, judgment, review, and integration. The user's explicit request to work directly takes precedence, and work that must remain sequential in this session stays here. Recommend an exact available vendor, model, and effort, and give a concise recommendationRationale explaining why all three fit the task. Clay always records and shows the runtime configuration card. In full-access mode Clay may auto-accept that exact validated recommendation; otherwise it waits for the user's explicit choice. After posting, end the turn. If accepted, Clay creates the exact Driver/Split Worker pair and delegates the proposed task once. If declined, continue in this Driver session. Do not call send_to_partner while unpaired.";
   }

package/lib/project.js

@@ -68,6 +68,7 @@ var { attachProjectLogs } = require("./project-logs");
 var { attachProjectLogFeedbackDelivery } = require("./project-log-feedback-delivery");
 var { attachProjectMateKnowledge } = require("./project-mate-knowledge");
 var { attachSplitGroups } = require("./session-split-groups");
+var multiWorkerFeature = require("./multi-worker-feature");
 var toolControlMcp = require("./tool-control-mcp-server");
 var capsuleFloor = require("./capsule-display-floor");
 var toolLlm = require("./tool-llm");
@@ -207,6 +208,7 @@ function safeAbsPath(requested) {
  * opts: { cwd, slug, title, pushModule, debug, dangerouslySkipPermissions, currentVersion }
  */
 function createProjectContext(opts) {
+  var multiWorkerGate = multiWorkerFeature.fromServerConfig(opts);
   var cwd = opts.cwd;
   var slug = opts.slug;
   var project = path.basename(cwd);
@@ -661,6 +663,7 @@ function createProjectContext(opts) {
     clients: clients,
     sendTo: sendTo,
     usersModule: usersModule,
+    multiWorkerFeature: multiWorkerGate,
     onPairChanged: function (group) {
       if (!sdk || !group || !Array.isArray(group.members)) return;
       for (var i = 0; i < group.members.length; i++) {
@@ -828,6 +831,7 @@ function createProjectContext(opts) {
     sm: sm,
     isMate: isMate,
     splitStore: _splitGroups.store,
+    multiWorkerFeature: multiWorkerGate,
     getSdk: function () { return sdk; },
     send: send,
     sendTo: sendTo,
@@ -851,6 +855,16 @@ function createProjectContext(opts) {
       if (_autonomousRun) _autonomousRun.onPartnerResult(driver, worker, token);
     },
   });
+  var _pairWorkerClose = require("./project-pair-worker-close").attachPairWorkerClose({
+    sm: sm,
+    splitStore: _splitGroups.store,
+    multiWorkerFeature: multiWorkerGate,
+    isMate: isMate,
+    projectSlug: slug,
+    hasSocket: function (ws) { return clients.has(ws); },
+    sendTo: sendTo,
+    closeWorker: _sessionPair.closeWorker,
+  });
   _pairResultRecovery = attachPairResultRecovery({
     sm: sm, store: _splitGroups.store, outbox: _pairResultOutbox, resultCapture: _sessionPair.resultCapture,
     wake: _sessionPair.wakePartnerResult, projectSlug: slug, sendTo: sendTo,
@@ -1757,6 +1771,7 @@ function createProjectContext(opts) {
 
     // --- Sessions, config, project mgmt (delegated to project-sessions.js) ---
     if (_pairResultRecovery.handleMessage(ws, msg)) return;
+    if (_pairWorkerClose.handleMessage(ws, msg)) return;
     if (_sessionPair.handleMessage(ws, msg)) return;
     if (_sessionHandoff.handleMessage(ws, msg)) return;
     if (_driverContinuation.handleMessage(ws, msg)) return;

package/lib/public/css/pane.css

@@ -73,6 +73,28 @@ body.pane-mode #input-area {
   display: flex;
 }
 
+/* A configured two-Worker group is a deliberate workspace hierarchy: the
+   Driver gets the broad working canvas, while both Workers remain visible as
+   equal-height execution surfaces on the right. Legacy/ad-hoc two-pane
+   splits keep the ordinary equal columns below. */
+#split-host:has(.split-pane-role-worker:nth-of-type(3)) {
+  display: grid;
+  grid-template-columns: minmax(0, 3fr) minmax(260px, 2fr);
+  grid-template-rows: repeat(2, minmax(0, 1fr));
+  gap: 1px;
+  background: var(--border-subtle);
+}
+
+#split-host:has(.split-pane-role-worker:nth-of-type(3)) .split-pane-role-driver {
+  grid-row: 1 / span 2;
+  grid-column: 1;
+}
+
+#split-host:has(.split-pane-role-worker:nth-of-type(3)) .split-pane-role-worker {
+  grid-column: 2;
+  grid-row: var(--split-worker-row, auto);
+}
+
 .split-pane {
   flex: 1;
   display: flex;
@@ -441,6 +463,11 @@ body.pane-mode #input-area {
   color: var(--text);
 }
 
+.split-pane-close:disabled {
+  opacity: 0.42;
+  cursor: not-allowed;
+}
+
 .split-pane-close svg {
   width: 12px;
   height: 12px;
@@ -478,6 +505,25 @@ body.pane-mode #input-area {
     --split-worker-height: calc(30% - 4.8px);
   }
 
+  #split-host:has(.split-pane-role-worker:nth-of-type(3)) {
+    display: flex;
+    flex-direction: column;
+    gap: var(--split-pane-gap);
+    background: transparent;
+  }
+
+  #split-host:has(.split-pane-role-worker:nth-of-type(3)) .split-pane-role-driver,
+  #split-host:has(.split-pane-role-worker:nth-of-type(3)) .split-pane-role-worker {
+    grid-row: auto;
+    grid-column: auto;
+  }
+
+  #split-host:has(.split-pane-role-worker:nth-of-type(3)) .split-pane-role-worker {
+    flex: 0 1 24%;
+    min-height: 104px;
+    order: -1;
+  }
+
   #split-host.visible {
     flex-direction: column;
     gap: var(--split-pane-gap);
@@ -495,11 +541,11 @@ body.pane-mode #input-area {
   }
 
   .split-pane-role-worker {
-    order: -1;
+    order: var(--split-pane-order, -1);
   }
 
   .split-pane-role-driver {
-    order: 0;
+    order: var(--split-pane-order, 0);
   }
 
   /* A configured Worker is an execution summary; the Driver keeps the

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

@@ -23,6 +23,7 @@ import { clearProjectSplitState } from './split-session-boundary.js';
 import { clearPermissionModePending } from './permission-control.js';
 import { clearMcpPermissionModePending } from './mcp-ui.js';
 import { createWebSocketLifecycle } from './websocket-lifecycle.js';
+import { createWebSocketWatchdog } from './websocket-watchdog.js';
 
 var connectOverlay = null;
 var hasConnectedOnce = false;
@@ -42,16 +43,9 @@ var overlayGraceTimer = null;
 // server-global-ws.js. Well under the common 60s proxy read timeout, and one
 // timer per live socket.
 var HEARTBEAT_MS = 25000;
-var heartbeatTimer = null;
-var heartbeatDeadlineTimer = null;
-var heartbeatAwaitingSocket = null;
 var disconnectedAt = 0;
 var attemptStartedAt = 0;
 var attemptSocket = null;
-var probeTimer = null;
-var probeSocket = null;
-var probeEpoch = 0;
-var probeStartedAt = 0;
 var lifecycle = createWebSocketLifecycle({
   handshakeTimeoutMs: 12000,
   onHandshakeTimeout: function (epoch) {
@@ -60,6 +54,21 @@ var lifecycle = createWebSocketLifecycle({
     }
   }
 });
+var watchdog = createWebSocketWatchdog({
+  heartbeatIntervalMs: HEARTBEAT_MS,
+  heartbeatDeadlineMs: 10000,
+  probeTimeoutMs: 4000,
+  now: function () { return Date.now(); },
+  isCurrent: function (socket, epoch) {
+    return getWs() === socket && socket.readyState === 1 && lifecycle.current(epoch);
+  },
+  sendPing: function (socket) {
+    socket.send(JSON.stringify({ type: "ping" }));
+  },
+  onFailure: function (reason, epoch, latency) {
+    forceReplaceSocket(reason, 0, epoch, latency);
+  }
+});
 
 function clearOverlayGrace() {
   if (overlayGraceTimer) {
@@ -88,19 +97,10 @@ function recordConnectionDiagnostic(reason, code, latency) {
   });
 }
 
-function clearProbe() {
-  if (probeTimer) clearTimeout(probeTimer);
-  probeTimer = null;
-  probeSocket = null;
-  probeEpoch = 0;
-  probeStartedAt = 0;
-}
-
-function forceReplaceSocket(reason, code, epoch) {
+function forceReplaceSocket(reason, code, epoch, latency) {
   if (!lifecycle.current(epoch)) return;
   var socket = getWs();
-  var latency = probeStartedAt ? Date.now() - probeStartedAt : null;
-  clearProbe();
+  watchdog.clearProbe();
   stopHeartbeat();
   if (socket) {
     socket.onopen = null;
@@ -117,19 +117,11 @@ function forceReplaceSocket(reason, code, epoch) {
 }
 
 export function stopHeartbeat() {
-  if (heartbeatTimer) {
-    clearInterval(heartbeatTimer);
-    heartbeatTimer = null;
-  }
-  if (heartbeatDeadlineTimer) {
-    clearTimeout(heartbeatDeadlineTimer);
-    heartbeatDeadlineTimer = null;
-  }
-  heartbeatAwaitingSocket = null;
+  watchdog.stopHeartbeat();
 }
 
 function suspendSocketForOffline() {
-  clearProbe();
+  watchdog.clearProbe();
   stopHeartbeat();
   var socket = getWs();
   attemptSocket = null;
@@ -150,31 +142,26 @@ function suspendSocketForOffline() {
 // timeout from expiring. A missing pong also identifies a half-open socket,
 // which browsers can otherwise leave OPEN while silently losing sends.
 export function startHeartbeat(socket, attemptEpoch) {
-  stopHeartbeat();
-  if (!socket) return;
-  heartbeatTimer = setInterval(function () {
-    if (!socket || socket.readyState !== 1 || getWs() !== socket || !lifecycle.current(attemptEpoch)) {
-      stopHeartbeat();
-      return;
-    }
-    try { socket.send(JSON.stringify({ type: "ping" })); } catch (e) {
-      forceReplaceSocket("heartbeat_error", 0, attemptEpoch);
-      return;
-    }
-    heartbeatAwaitingSocket = socket;
-    if (heartbeatDeadlineTimer) clearTimeout(heartbeatDeadlineTimer);
-    heartbeatDeadlineTimer = setTimeout(function () {
-      heartbeatDeadlineTimer = null;
-      if (getWs() === socket && socket.readyState === 1 && lifecycle.current(attemptEpoch)) {
-        forceReplaceSocket("heartbeat_timeout", 0, attemptEpoch);
-      }
-    }, 10000);
-  }, HEARTBEAT_MS);
+  watchdog.startHeartbeat(socket, attemptEpoch);
+}
+
+function suspendSocketWatchdogs() {
+  // A frozen page cannot promise proxy keepalive. Retire its deadlines without
+  // closing the socket; resume performs a fresh bounded liveness check.
+  watchdog.suspend();
+}
+
+function resumeSocketWatchdogs(reason) {
+  var resumed = watchdog.resume();
+  var socket = getWs();
+  if (socket && socket.readyState === 1 && resumed) startHeartbeat(socket, lifecycle.getEpoch());
+  probeReconnect(reason);
 }
 
 export function initConnection() {
   connectOverlay = document.getElementById("connect-overlay");
   if (typeof navigator !== "undefined" && navigator.onLine === false) lifecycle.setOffline(true);
+  if (document.hidden) suspendSocketWatchdogs();
   window.addEventListener("clay-message-delivery-timeout", function (event) {
     var socket = event.detail && event.detail.socket;
     recordConnectionDiagnostic("ack-timeout", 0, null);
@@ -186,17 +173,19 @@ export function initConnection() {
   });
   window.addEventListener("online", function () {
     lifecycle.wake(function () {
-      var socket = getWs();
-      if (socket && socket.readyState === 1) startHeartbeat(socket, lifecycle.getEpoch());
-      probeReconnect("online");
+      if (document.hidden) return;
+      resumeSocketWatchdogs("online");
     });
   });
   document.addEventListener("visibilitychange", function () {
-    if (!document.hidden) {
-      var socket = getWs();
-      if (socket && socket.readyState === 1) startHeartbeat(socket, lifecycle.getEpoch());
-      probeReconnect("visible");
-    }
+    if (document.hidden) suspendSocketWatchdogs();
+    else resumeSocketWatchdogs("visible");
+  });
+  document.addEventListener("freeze", function () {
+    suspendSocketWatchdogs();
+  });
+  document.addEventListener("resume", function () {
+    if (!document.hidden) resumeSocketWatchdogs("visible");
   });
 
   // --- Reactive UI sync for connected/processing state ---
@@ -379,7 +368,7 @@ export function connect() {
   newWs.onclose = function (e) {
     if (getWs() !== newWs || !lifecycle.current(attemptEpoch)) return;
     stopHeartbeat();
-    clearProbe();
+    watchdog.clearProbe();
     disconnectedAt = Date.now();
     recordConnectionDiagnostic("close", e && e.code, attemptStartedAt ? Date.now() - attemptStartedAt : null);
     closeDmUserPicker();
@@ -408,18 +397,13 @@ export function connect() {
     var msg;
     try { msg = JSON.parse(event.data); } catch (e) { return; }
     lifecycle.markLive(attemptEpoch);
-    if (msg.type === "pong" && heartbeatDeadlineTimer && heartbeatAwaitingSocket === newWs) {
-      clearTimeout(heartbeatDeadlineTimer);
-      heartbeatDeadlineTimer = null;
-      heartbeatAwaitingSocket = null;
-    }
-    if (msg.type === "pong" && probeSocket === newWs && lifecycle.current(probeEpoch)) clearProbe();
+    if (msg.type === "pong") watchdog.acceptPong(newWs, attemptEpoch);
     processMessage(msg);
   };
 }
 
 export function cancelReconnect() {
-  clearProbe();
+  watchdog.clearProbe();
   stopHeartbeat();
   lifecycle.cancel();
 }
@@ -429,18 +413,7 @@ function probeReconnect(reason) {
   var socket = getWs();
   if (socket && socket.readyState === 0) return;
   if (socket && socket.readyState === 1) {
-    if (probeTimer) return;
-    probeSocket = socket;
-    probeEpoch = lifecycle.getEpoch();
-    probeStartedAt = Date.now();
-    try { socket.send(JSON.stringify({ type: "ping" })); } catch (e) {
-      forceReplaceSocket("probe_error", 0, probeEpoch);
-      return;
-    }
-    probeTimer = setTimeout(function () {
-      probeTimer = null;
-      if (probeSocket === socket && lifecycle.current(probeEpoch) && getWs() === socket && socket.readyState === 1) forceReplaceSocket("probe_timeout", 0, probeEpoch);
-    }, 4000);
+    watchdog.probe(socket, lifecycle.getEpoch());
     return;
   }
   scheduleReconnect(reason);