clay-server 4.0.0-beta.8 → 4.0.0

package/lib/project-worker-proposal.js

@@ -1,48 +1,34 @@
 var crypto = require("crypto");
 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 MAX_SUMMARY_CHARS = 600;
 var MAX_PLAN_CHARS = 6000;
 var MAX_TASK_CHARS = 30000;
-
+var MAX_RATIONALE_CHARS = 1000;
 function modelValue(entry) {
   if (typeof entry === "string") return entry;
   return entry && (entry.value || entry.id) || "";
 }
-
 function modelLabel(entry) {
   if (typeof entry === "string") return entry;
   return entry && (entry.displayName || entry.name || entry.value || entry.id) || "";
 }
-
-function isFableSession(session, modelsByVendor, fallbackModel) {
-  if (!session || (session.vendor || "claude") !== "claude") return false;
-  var effectiveModel = session.model || fallbackModel || "";
-  var selected = String(effectiveModel).toLowerCase();
-  if (selected.indexOf("fable") !== -1) return true;
-  var models = (modelsByVendor && modelsByVendor.claude) || [];
-  for (var i = 0; i < models.length; i++) {
-    if (modelValue(models[i]) !== effectiveModel) continue;
-    if (modelLabel(models[i]).toLowerCase().indexOf("fable") !== -1) return true;
-  }
-  return false;
-}
-
 function toolResult(value) {
   return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] });
 }
-
 function attachWorkerProposal(ctx) {
   var sm = ctx.sm;
   var store = ctx.splitStore;
+  function isLiveSession(session) {
+    return !!session && sm.sessions.get(session.localId) === session;
+  }
 
+  function canOffer(session) { return !ctx.isMate && isLiveSession(session) && driverEligibility.isEligibleDriverSession(session, sm); }
   function isEligible(session) {
-    if (ctx.isMate || !session || session.mode === "tui") return false;
-    if (store.groupForMember(session.localId)) return false;
-    return isFableSession(session, sm.modelsByVendor, (sm.defaultModelByVendor || {})[session.vendor || "claude"]);
+    return canOffer(session) && !store.groupForMember(session.localId);
   }
-
   function safeModelsByVendor(installed) {
     var result = {};
     for (var i = 0; i < installed.length; i++) {
@@ -95,7 +81,21 @@ function attachWorkerProposal(ctx) {
     for (var i = 0; i < models.length; i++) {
       if (modelValue(models[i]) === model) return true;
     }
-    return models.length === 0;
+    return false;
+  }
+
+  function effortIsAvailable(options, vendor, model, effort) {
+    var capabilities = options.capabilitiesByVendor[vendor] || {};
+    if (capabilities.effort === false) return !effort;
+    var clamped = yoke.clampEffort(vendor, effort) || "";
+    if (!effort || clamped !== effort) return false;
+    var models = options.modelsByVendor[vendor] || [];
+    for (var i = 0; i < models.length; i++) {
+      if (modelValue(models[i]) !== model) continue;
+      var levels = models[i] && models[i].supportedEffortLevels;
+      return !Array.isArray(levels) || levels.length === 0 || levels.indexOf(effort) !== -1;
+    }
+    return true;
   }
 
   function chooseRecommendation(args, session, options) {
@@ -117,7 +117,6 @@ function attachWorkerProposal(ctx) {
     if (!model && models.length > 0) {
       for (var j = 0; j < models.length; j++) {
         if (vendor === session.vendor && modelValue(models[j]) === currentModel) continue;
-        if (modelLabel(models[j]).toLowerCase().indexOf("fable") !== -1) continue;
         model = modelValue(models[j]);
         break;
       }
@@ -127,6 +126,31 @@ function attachWorkerProposal(ctx) {
     return { vendor: vendor, model: model, effort: effort };
   }
 
+  function skipPermissionsEnabled(session) {
+    return !!(session && (session.permissionMode === "bypassPermissions" ||
+      session.dangerouslySkipPermissions || ctx.dangerouslySkipPermissions));
+  }
+
+  function recommendationCanAutoAccept(args, recommendation, options) {
+    var requestedVendor = typeof args.recommendedVendor === "string" ? args.recommendedVendor.trim() : "";
+    var requestedModel = typeof args.recommendedModel === "string" ? args.recommendedModel.trim() : "";
+    var requestedEffort = typeof args.recommendedEffort === "string" ? args.recommendedEffort.trim() : "";
+    if (!requestedVendor || requestedVendor !== recommendation.vendor) return false;
+    if (!requestedModel || requestedModel !== recommendation.model ||
+        !modelIsAvailable(options, requestedVendor, requestedModel)) return false;
+    var capabilities = options.capabilitiesByVendor[requestedVendor] || {};
+    if (capabilities.effort === false) return !requestedEffort && !recommendation.effort;
+    return requestedEffort === recommendation.effort &&
+      effortIsAvailable(options, requestedVendor, requestedModel, requestedEffort);
+  }
+
+  function autoAcceptanceWs(session) {
+    return {
+      _clayActiveSession: session.localId,
+      _clayUser: session.ownerId ? { id: session.ownerId } : null,
+    };
+  }
+
   function findProposal(session, proposalId) {
     var history = (session && session.history) || [];
     for (var i = history.length - 1; i >= 0; i--) {
@@ -154,31 +178,24 @@ function attachWorkerProposal(ctx) {
     }, patch));
   }
 
-  function skipPermissionsEnabled(session) {
-    return !!session && (session.permissionMode === "bypassPermissions" || session.dangerouslySkipPermissions === true);
-  }
-
-  function autoApprovalWs(session) {
-    return {
-      _clayActiveSession: session.localId,
-      _clayUser: session.ownerId ? { id: session.ownerId } : null,
-      _autoApproval: true,
-    };
-  }
-
   async function propose(args, session) {
-    if (!isEligible(session)) return toolResult({ error: "Split Worker suggestions are only available in an unpaired Fable session." });
+    if (!isEligible(session)) return toolResult({ error: "Split Worker proposals are only available in an eligible unpaired Driver session." });
     if (hasPendingProposal(session)) return toolResult({ error: "A Split Worker suggestion is already awaiting a decision." });
     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() : "";
-    if (!summary || !plan || !task) return toolResult({ error: "summary, plan, and message are required." });
+    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 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 autoApprove = skipPermissionsEnabled(session);
     var proposal = {
       type: "worker_proposal",
       proposalId: "worker_" + crypto.randomUUID(),
@@ -189,22 +206,22 @@ function attachWorkerProposal(ctx) {
       recommendedVendor: recommendation.vendor,
       recommendedModel: recommendation.model,
       recommendedEffort: recommendation.effort,
+      recommendationRationale: rationale.slice(0, MAX_RATIONALE_CHARS),
       options: options,
     };
-    if (autoApprove) proposal.autoApproved = true;
     sm.sendAndRecord(session, proposal);
-    if (autoApprove) {
+    if (skipPermissionsEnabled(session) && recommendationCanAutoAccept(args, recommendation, options)) {
       var accepted = await acceptProposal(session, proposal, {
         vendor: recommendation.vendor,
         model: recommendation.model,
         effort: recommendation.effort,
-        autoApproved: true,
-      }, autoApprovalWs(session));
-      if (!accepted.ok) return toolResult({ error: accepted.error || "Could not start the Split Worker." });
+      }, autoAcceptanceWs(session), true);
       return toolResult({
-        status: "running",
+        status: accepted.ok ? "auto_accepted" : "posted",
         proposalId: proposal.proposalId,
-        instruction: "The Split Worker was auto-approved and started because skip permissions is enabled. Its result will return for review.",
+        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({
@@ -214,6 +231,75 @@ function attachWorkerProposal(ctx) {
     });
   }
 
+  async function proposeReplacement(args, session) {
+    var group = session && store.groupForMember(session.localId);
+    if (ctx.isMate || !isLiveSession(session) || !driverEligibility.isEligibleDriverSession(session, sm) || !group ||
+        !group.pair || group.pair.driverId !== session.localId) {
+      return toolResult({ error: "Split Worker replacement proposals require the exact paired Driver session." });
+    }
+    var sourceGroupId = group.id;
+    var sourceWorkerId = group.pair.workerId;
+    if (hasPendingProposal(session)) return toolResult({ error: "A Split Worker proposal is already awaiting a decision." });
+    var task = typeof args.message === "string" ? args.message.trim() : "";
+    var rationale = typeof args.recommendationRationale === "string" ? args.recommendationRationale.trim() : "";
+    if (!task) return toolResult({ error: "message is required so an accepted replacement delegates exactly once." });
+    if (!rationale) return toolResult({ error: "recommendationRationale is required for the replacement audit trail." });
+    if (task.length > MAX_TASK_CHARS) return toolResult({ error: "The Split Worker task is too long." });
+    await ensureModelCatalogs();
+    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) {
+      return toolResult({ error: "The Driver/Split Worker pair changed while replacement 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 recommendationArgs = {
+      recommendedVendor: args.workerVendor,
+      recommendedModel: args.workerModel,
+      recommendedEffort: args.workerEffort,
+    };
+    var recommendation = chooseRecommendation(recommendationArgs, session, options);
+    var proposal = {
+      type: "worker_proposal",
+      proposalId: "worker_" + crypto.randomUUID(),
+      action: "replace",
+      summary: "Replace the current Split Worker before the next delegated task.",
+      plan: "1. Preserve the current Worker's session and history\n2. Create the selected replacement runtime\n3. Delegate the next task exactly once",
+      message: task,
+      status: "pending",
+      recommendedVendor: recommendation.vendor,
+      recommendedModel: recommendation.model,
+      recommendedEffort: recommendation.effort,
+      recommendationRationale: rationale.slice(0, MAX_RATIONALE_CHARS),
+      options: options,
+      sourceGroupId: sourceGroupId,
+      sourceWorkerId: sourceWorkerId,
+      interrupt: args.interrupt === true,
+      evaluation: args.evaluation || null,
+    };
+    sm.sendAndRecord(session, proposal);
+    if (skipPermissionsEnabled(session) && recommendationCanAutoAccept(recommendationArgs, 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 replacement configuration was auto-accepted under the Driver session's full-access mode."
+          : "The automatic replacement failed closed. The card remains pending for the user.",
+      });
+    }
+    return toolResult({
+      status: "posted",
+      proposalId: proposal.proposalId,
+      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"));
@@ -268,31 +354,86 @@ function attachWorkerProposal(ctx) {
     return session;
   }
 
-  async function acceptProposal(session, proposal, msg, ws) {
-    var options = proposal.options || proposalOptions();
+  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)) {
+      throw new Error("The Driver is no longer eligible to create this Split Worker");
+    }
+    var approvedGroup = null;
+    if (proposal.action === "replace") {
+      approvedGroup = store.groupForMember(session.localId);
+      if (!driverEligibility.isEligibleDriverSession(session, sm) || !approvedGroup ||
+          approvedGroup.id !== proposal.sourceGroupId || !approvedGroup.pair ||
+          approvedGroup.pair.driverId !== session.localId || approvedGroup.pair.workerId !== proposal.sourceWorkerId) {
+        throw new Error("The Driver/Split Worker pair changed before the replacement was approved");
+      }
+    }
+    var 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");
     if (!modelIsAvailable(options, vendor, model)) throw new Error("Selected Split Worker model is unavailable");
-    var effort = yoke.clampEffort(vendor, msg.effort || proposal.recommendedEffort || "medium") || "";
-    var startingPatch = { status: "starting", selectedVendor: vendor, selectedModel: model, selectedEffort: effort };
-    if (msg.autoApproved) startingPatch.autoApproved = true;
+    var requestedEffort = msg.effort || proposal.recommendedEffort || "medium";
+    var effort = yoke.clampEffort(vendor, requestedEffort) || "";
+    if ((msg.effort && effort !== msg.effort) || !effortIsAvailable(options, vendor, model, effort)) {
+      throw new Error("Selected Split Worker reasoning effort is unavailable");
+    }
+    var autoAccepted = trustedAutoAcceptance === true;
+    var startingPatch = {
+      status: "starting",
+      selectedVendor: vendor,
+      selectedModel: model,
+      selectedEffort: effort,
+      autoAccepted: autoAccepted,
+      decisionMode: autoAccepted ? "driver_recommendation" : "user",
+      decidedAt: Date.now(),
+    };
     updateProposal(session, proposal, startingPatch);
     try {
+      if (proposal.action === "replace") {
+        var liveGroup = approvedGroup;
+        var replaced = await ctx.replacePartner({
+          interrupt: proposal.interrupt === true,
+          workerVendor: vendor,
+          workerModel: model,
+          workerEffort: effort,
+          evaluation: proposal.evaluation || undefined,
+        }, session);
+        liveGroup = store.groupForMember(session.localId);
+        updateProposal(session, proposal, { status: "running", groupId: liveGroup.id, workerId: replaced.workerSessionId });
+        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: liveGroup, replacement: replaced };
+      }
       var created = ctx.createPairRecord(ws, {
         driver: { sessionId: session.localId },
         worker: { vendor: vendor, model: model, effort: effort },
       });
+      ctx.recordGenerationStart(session, created.worker);
       updateProposal(session, proposal, { status: "running", groupId: created.group.id, workerId: created.worker.localId });
-      if (ws._autoApproval) sm.sendToSession(session, { type: "pair_session_created", ok: true, group: created.group });
-      else ctx.sendTo(ws, { type: "pair_session_created", ok: true, group: created.group });
+      ctx.sendTo(ws, { type: "pair_session_created", ok: true, group: created.group });
       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: created.group };
     } catch (err) {
-      updateProposal(session, proposal, { status: "pending", error: err.message || String(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) {
+          proposal.sourceGroupId = restoredGroup.id;
+        }
+      }
+      updateProposal(session, proposal, {
+        status: "pending",
+        error: err.message || String(err),
+        autoAccepted: false,
+        decisionMode: null,
+        decidedAt: null,
+      });
       return { ok: false, status: "pending", error: err.message || String(err) };
     }
   }
@@ -304,7 +445,10 @@ function attachWorkerProposal(ctx) {
     if (proposal.status !== "pending") throw new Error("Split Worker suggestion has already been resolved");
     if (!msg.accepted) {
       updateProposal(session, proposal, { status: "declined" });
-      await resumeDriver(session, "[Split Worker suggestion declined]\nContinue this task in the current session using the plan you already prepared.");
+      var declinedText = proposal.action === "replace"
+        ? "[Split Worker replacement declined]\nContinue with the existing Split Worker and the current task."
+        : "[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" };
     }
     return acceptProposal(session, proposal, msg, ws);
@@ -318,11 +462,12 @@ function attachWorkerProposal(ctx) {
     return true;
   }
 
-  function getToolDefs(session) {
-    if (!isEligible(session)) return [];
+  function getToolDefs(session, options) {
+    var persistent = !!(options && options.persistent);
+    if (!isEligible(session) && !(persistent && canOffer(session))) return [];
     return [{
       name: "propose_worker",
-      description: "After making a concise plan for an implementation-heavy task, suggest that the user run the execution with another model in a visible Split Worker session. Use this only before substantial execution begins, never for small edits, explanations, or tasks the user asked you to keep in this session.",
+      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({
         summary: { type: "string", description: "One short sentence explaining why a Split Worker is useful for this task." },
         plan: { type: "string", description: "A concise numbered implementation plan to show in the approval card." },
@@ -330,19 +475,21 @@ function attachWorkerProposal(ctx) {
         recommendedVendor: { type: "string", description: "Optional installed vendor id for the Split Worker." },
         recommendedModel: { type: "string", description: "Optional exact Split Worker model id. Omit when uncertain." },
         recommendedEffort: { type: "string", description: "Optional reasoning effort: minimal, low, medium, high, xhigh, or max." },
-      }, ["summary", "plan", "message"]),
+        recommendationRationale: { type: "string", description: "Concise Driver-authored explanation of why the recommended vendor, model, and effort fit this exact task." },
+      }, ["summary", "plan", "message", "recommendationRationale"]),
       handler: function (args) { return propose(args || {}, session); },
     }];
   }
 
   function getSystemPrompt(session) {
-    if (!isEligible(session)) return "";
-    return "You can introduce Clay's Driver/Split Worker workflow with propose_worker. For an implementation-heavy task that is likely to consume substantial execution time, first reason about the work and form a concise plan. Before editing files or running substantial execution, call propose_worker once with that plan and a complete Split Worker instruction, recommending another suitable execution model. Use it conservatively: do not suggest a Split Worker for questions, investigations, tiny fixes, or when the user explicitly wants you to execute here. After posting a proposal, end the turn and wait. If accepted, the Split Worker runs visibly and its result returns to you for review.";
+    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.";
   }
 
   return {
     getToolDefs: getToolDefs,
     getSystemPrompt: getSystemPrompt,
+    proposeReplacement: proposeReplacement,
     handleMessage: handleMessage,
     respondToProposal: respondToProposal,
   };
@@ -350,5 +497,4 @@ function attachWorkerProposal(ctx) {
 
 module.exports = {
   attachWorkerProposal: attachWorkerProposal,
-  isFableSession: isFableSession,
 };