clay-server 3.4.0-beta.16 → 3.4.0-beta.18

package/lib/project-worker-proposal.js

@@ -154,6 +154,18 @@ 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: "Worker suggestions are only available in an unpaired Fable session." });
     if (hasPendingProposal(session)) return toolResult({ error: "A Worker suggestion is already awaiting a decision." });
@@ -166,6 +178,7 @@ function attachWorkerProposal(ctx) {
     var options = proposalOptions();
     if (options.installedVendors.length === 0) return toolResult({ error: "No coding agent is installed for a Worker session." });
     var recommendation = chooseRecommendation(args, session, options);
+    var autoApprove = skipPermissionsEnabled(session);
     var proposal = {
       type: "worker_proposal",
       proposalId: "worker_" + crypto.randomUUID(),
@@ -178,7 +191,22 @@ function attachWorkerProposal(ctx) {
       recommendedEffort: recommendation.effort,
       options: options,
     };
+    if (autoApprove) proposal.autoApproved = true;
     sm.sendAndRecord(session, proposal);
+    if (autoApprove) {
+      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 Worker." });
+      return toolResult({
+        status: "running",
+        proposalId: proposal.proposalId,
+        instruction: "The Worker was auto-approved and started because skip permissions is enabled. Its result will return for review.",
+      });
+    }
     return toolResult({
       status: "posted",
       proposalId: proposal.proposalId,
@@ -238,30 +266,24 @@ function attachWorkerProposal(ctx) {
     return session;
   }
 
-  async function respondToProposal(ws, msg) {
-    var session = sessionForResponse(ws);
-    var proposal = findProposal(session, msg.proposalId);
-    if (!proposal) throw new Error("Worker suggestion not found");
-    if (proposal.status !== "pending") throw new Error("Worker suggestion has already been resolved");
-    if (!msg.accepted) {
-      updateProposal(session, proposal, { status: "declined" });
-      await resumeDriver(session, "[Worker suggestion declined]\nContinue this task in the current session using the plan you already prepared.");
-      return { ok: true, status: "declined" };
-    }
+  async function acceptProposal(session, proposal, msg, ws) {
     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 Worker vendor is not installed");
     if (!modelIsAvailable(options, vendor, model)) throw new Error("Selected Worker model is unavailable");
     var effort = yoke.clampEffort(vendor, msg.effort || proposal.recommendedEffort || "medium") || "";
-    updateProposal(session, proposal, { status: "starting", selectedVendor: vendor, selectedModel: model, selectedEffort: effort });
+    var startingPatch = { status: "starting", selectedVendor: vendor, selectedModel: model, selectedEffort: effort };
+    if (msg.autoApproved) startingPatch.autoApproved = true;
+    updateProposal(session, proposal, startingPatch);
     try {
       var created = ctx.createPairRecord(ws, {
         driver: { sessionId: session.localId },
         worker: { vendor: vendor, model: model, effort: effort },
       });
       updateProposal(session, proposal, { status: "running", groupId: created.group.id, workerId: created.worker.localId });
-      ctx.sendTo(ws, { type: "pair_session_created", ok: true, group: created.group });
+      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 });
       runWorker(session, proposal).catch(function (err) {
         updateProposal(session, proposal, { status: "error", error: err.message || String(err) });
         resumeDriver(session, "[Worker execution failed]\n" + (err.message || String(err))).catch(function () {});
@@ -273,6 +295,19 @@ function attachWorkerProposal(ctx) {
     }
   }
 
+  async function respondToProposal(ws, msg) {
+    var session = sessionForResponse(ws);
+    var proposal = findProposal(session, msg.proposalId);
+    if (!proposal) throw new Error("Worker suggestion not found");
+    if (proposal.status !== "pending") throw new Error("Worker suggestion has already been resolved");
+    if (!msg.accepted) {
+      updateProposal(session, proposal, { status: "declined" });
+      await resumeDriver(session, "[Worker suggestion declined]\nContinue this task in the current session using the plan you already prepared.");
+      return { ok: true, status: "declined" };
+    }
+    return acceptProposal(session, proposal, msg, ws);
+  }
+
   function handleMessage(ws, msg) {
     if (msg.type !== "worker_proposal_response") return false;
     respondToProposal(ws, msg).catch(function (err) {

package/lib/public/modules/worker-proposal.js

@@ -103,8 +103,10 @@ function statusLabel(status) {
 function applyState(card, msg) {
   var status = msg.status || "pending";
   card.dataset.status = status;
+  if (msg.autoApproved) card.dataset.autoApproved = "true";
+  var autoApproved = card.dataset.autoApproved === "true";
   var badge = card.querySelector(".worker-proposal-status");
-  if (badge) badge.textContent = statusLabel(status);
+  if (badge) badge.textContent = statusLabel(status) + (autoApproved ? " · auto-approved" : "");
   var error = card.querySelector(".worker-proposal-error");
   if (error) {
     error.textContent = msg.error || "";
@@ -116,6 +118,8 @@ function applyState(card, msg) {
     preview.classList.remove("hidden");
   }
   setControlsDisabled(card, status !== "pending");
+  var actions = card.querySelector(".worker-proposal-actions");
+  if (actions) actions.classList.toggle("hidden", autoApproved);
 }
 
 function sendDecision(card, accepted) {

package/lib/session-notes-mcp-server.js

@@ -7,6 +7,7 @@ var MEMORY_CONTRACT =
   "Default to not writing. Create a note proactively only when the user explicitly asks to remember or track something, or when all of these are true: it will remain useful after the current task and session, it is not already adequately recorded in the repository or another note, and the user would likely be glad to find it on the board a week later. " +
   "Good notes capture an unresolved commitment, durable product decision, user preference, constraint, or handoff that will materially change future work. " +
   "Important exception for deferred defects: while doing code or technical work, actively create a sticky note when you discover a concrete defect, regression risk, security issue, or data-loss risk that is outside the current session goal and will remain unfixed when the turn ends. Do not wait for the user to ask. Include the observable evidence, affected component, likely impact, and a clear next action. Check active notes first when a duplicate is plausible. Do not create defect notes for speculation, general cleanup ideas, or problems you fixed in the current session. " +
+  "Important exception for deferred proposals: when you propose work (a fix, follow-up, improvement, or next step) and the user defers it rather than declining it (\"let's do that later\", \"next time\", \"after this\"), actively create a sticky note before the topic moves on. Do not wait to be asked. Capture what was proposed, why it mattered, and the agreed timing if any. Deferred agreements scroll out of chat history quickly and are hard to track; the board is where they survive. If the user declines the idea outright, do not write a note. " +
   "Never create a note merely because work is important, lengthy, spans agents or restarts, or might help another agent. Do not record completed work, implementation details, test results, investigation logs, transient blockers, conversation summaries, or announcements of your own activity. When uncertain, do not write. " +
   "Updates are visible too: update only when durable state materially changes, and remove a note created by your session when it stops being useful instead of turning it into a completion log. Put a concise plain-text title on the first line, stay focused on one topic, and include only the context needed for future action.";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "3.4.0-beta.16",
+  "version": "3.4.0-beta.18",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js",