clay-server 4.0.0-beta.13 → 4.0.0-beta.15

package/lib/capsules/tictactoe/ui.json

@@ -0,0 +1,203 @@
+{
+  "type": "stack",
+  "props": {
+    "gap": "md"
+  },
+  "children": [
+    {
+      "type": "text",
+      "props": {
+        "text": {
+          "$bind": "$state.statusText",
+          "fallback": "You (X) to play."
+        },
+        "role": "output"
+      }
+    },
+    {
+      "type": "row",
+      "props": {
+        "gap": "sm"
+      },
+      "children": [
+        {
+          "type": "button",
+          "action": "mark",
+          "props": {
+            "label": {
+              "$bind": "$state.cell0",
+              "fallback": " "
+            },
+            "accessibleLabel": "Mark cell 0",
+            "variant": "secondary",
+            "disabled": "$state.cell0Disabled",
+            "args": {
+              "cell": 0
+            }
+          }
+        },
+        {
+          "type": "button",
+          "action": "mark",
+          "props": {
+            "label": {
+              "$bind": "$state.cell1",
+              "fallback": " "
+            },
+            "accessibleLabel": "Mark cell 1",
+            "variant": "secondary",
+            "disabled": "$state.cell1Disabled",
+            "args": {
+              "cell": 1
+            }
+          }
+        },
+        {
+          "type": "button",
+          "action": "mark",
+          "props": {
+            "label": {
+              "$bind": "$state.cell2",
+              "fallback": " "
+            },
+            "accessibleLabel": "Mark cell 2",
+            "variant": "secondary",
+            "disabled": "$state.cell2Disabled",
+            "args": {
+              "cell": 2
+            }
+          }
+        }
+      ]
+    },
+    {
+      "type": "row",
+      "props": {
+        "gap": "sm"
+      },
+      "children": [
+        {
+          "type": "button",
+          "action": "mark",
+          "props": {
+            "label": {
+              "$bind": "$state.cell3",
+              "fallback": " "
+            },
+            "accessibleLabel": "Mark cell 3",
+            "variant": "secondary",
+            "disabled": "$state.cell3Disabled",
+            "args": {
+              "cell": 3
+            }
+          }
+        },
+        {
+          "type": "button",
+          "action": "mark",
+          "props": {
+            "label": {
+              "$bind": "$state.cell4",
+              "fallback": " "
+            },
+            "accessibleLabel": "Mark cell 4",
+            "variant": "secondary",
+            "disabled": "$state.cell4Disabled",
+            "args": {
+              "cell": 4
+            }
+          }
+        },
+        {
+          "type": "button",
+          "action": "mark",
+          "props": {
+            "label": {
+              "$bind": "$state.cell5",
+              "fallback": " "
+            },
+            "accessibleLabel": "Mark cell 5",
+            "variant": "secondary",
+            "disabled": "$state.cell5Disabled",
+            "args": {
+              "cell": 5
+            }
+          }
+        }
+      ]
+    },
+    {
+      "type": "row",
+      "props": {
+        "gap": "sm"
+      },
+      "children": [
+        {
+          "type": "button",
+          "action": "mark",
+          "props": {
+            "label": {
+              "$bind": "$state.cell6",
+              "fallback": " "
+            },
+            "accessibleLabel": "Mark cell 6",
+            "variant": "secondary",
+            "disabled": "$state.cell6Disabled",
+            "args": {
+              "cell": 6
+            }
+          }
+        },
+        {
+          "type": "button",
+          "action": "mark",
+          "props": {
+            "label": {
+              "$bind": "$state.cell7",
+              "fallback": " "
+            },
+            "accessibleLabel": "Mark cell 7",
+            "variant": "secondary",
+            "disabled": "$state.cell7Disabled",
+            "args": {
+              "cell": 7
+            }
+          }
+        },
+        {
+          "type": "button",
+          "action": "mark",
+          "props": {
+            "label": {
+              "$bind": "$state.cell8",
+              "fallback": " "
+            },
+            "accessibleLabel": "Mark cell 8",
+            "variant": "secondary",
+            "disabled": "$state.cell8Disabled",
+            "args": {
+              "cell": 8
+            }
+          }
+        }
+      ]
+    },
+    {
+      "type": "row",
+      "props": {
+        "gap": "sm"
+      },
+      "children": [
+        {
+          "type": "button",
+          "action": "reset",
+          "props": {
+            "label": "Reset",
+            "accessibleLabel": "Reset the game",
+            "variant": "ghost"
+          }
+        }
+      ]
+    }
+  ]
+}

package/lib/project-capsule-catalog.js

@@ -1,4 +1,12 @@
 // Bounded progressive-disclosure catalog for Capsules visible to a Mate.
+//
+// Skills are gated by Display: a Capsule the human cannot operate by hand is a
+// Capsule no Mate may reach either, so an entry appears here only while its
+// declarative Display floor validates. The gate reads the Capsule's own tree,
+// carried alongside each manifest, and fails closed on a scan error, a missing
+// ID, or a missing or invalid Display.
+
+var capsuleFloor = require("./capsule-display-floor");
 
 var MAX_NAME_LENGTH = 80;
 var MAX_DESCRIPTION_LENGTH = 240;
@@ -35,7 +43,7 @@ function discoveryEntry(manifest) {
 function buildCapsuleCatalogPrompt(manifests) {
   if (!Array.isArray(manifests) || manifests.length === 0) return "";
   var sorted = manifests.filter(function (manifest) {
-    return manifest && !manifest.error && manifest.id;
+    return capsuleFloor.hasUsableFloor(manifest);
   }).slice().sort(function (a, b) {
     var first = String(a.id);
     var second = String(b.id);

package/lib/project-connection.js

@@ -233,7 +233,7 @@ function attachConnection(ctx) {
     // so vendor badges showed Claude until the next broadcast).
     sendTo(ws, {
       type: "session_list",
-      sessions: allSessions.map(function (s) { return sm.mapSessionForClient(s); }),
+      sessions: sm.mapSessionsForClient(allSessions),
     });
     if (_splitGroups) _splitGroups.sendConnectionState(ws);
 

package/lib/project-log-feedback-delivery.js

@@ -0,0 +1,76 @@
+// Deliver new Project Log comments to the exact live session responsible for
+// the canonical entry. Comments remain durable in the ledger when that session
+// is gone; this module never guesses another session or creates one.
+
+function attachProjectLogFeedbackDelivery(ctx) {
+  var sm = ctx.sm;
+  var getSdk = ctx.getSdk;
+  var onProcessingChanged = ctx.onProcessingChanged || function () {};
+  var getLinuxUserForSession = ctx.getLinuxUserForSession || function () { return null; };
+
+  function findAuthorSession(entry) {
+    var author = entry && entry.updatedBy;
+    if (!author || author.type !== "session" || !author.sessionKey) return null;
+    var match = null;
+    sm.sessions.forEach(function (session) {
+      if (match || !session || session.destroying || session.hidden) return;
+      if (session.cliSessionId !== author.sessionKey && "local:" + session.localId !== author.sessionKey) return;
+      if ((session.ownerId || null) !== (author.userId || null)) return;
+      if (sm.sessions.get(session.localId) !== session) return;
+      match = session;
+    });
+    return match;
+  }
+
+  function feedbackPrompt(entry) {
+    return "[Project Log feedback]\n" +
+      "A user added a comment to " + entry.ref + ". Review the pending feedback now with list_log_feedback, " +
+      "then resolve this specific comment through review_log_comment. Apply supported corrections to the canonical " +
+      "entry; otherwise clarify or decline with a concise reason. Do not treat this internal notification as user " +
+      "chat or answer it only in the conversation.\n" +
+      "[End Project Log feedback]";
+  }
+
+  function deliver(entry) {
+    if (!entry || !entry.ref || !entry.pendingFeedbackCount) return false;
+    var session = findAuthorSession(entry);
+    var sdk = getSdk();
+    if (!session || !sdk) return false;
+    var text = feedbackPrompt(entry);
+    sm.sendAndRecord(session, {
+      type: "user_message",
+      text: text,
+      _internal: true,
+      projectLogFeedback: true,
+      projectLogRef: entry.ref,
+    });
+    session.lastActivity = Date.now();
+    if (!session.isProcessing) {
+      session.isProcessing = true;
+      session.sentToolResults = {};
+      onProcessingChanged();
+      sm.sendToSession(session, { type: "status", status: "processing" });
+    }
+    if (!sdk.pushMessage(session, text)) {
+      session._queryStartTs = Date.now();
+      Promise.resolve(sdk.startQuery(session, text, null, getLinuxUserForSession(session))).catch(function (error) {
+        session.isProcessing = false;
+        sm.sendAndRecord(session, {
+          type: "error",
+          text: "Could not deliver Project Log feedback: " + (error.message || String(error)),
+          _internal: true,
+        });
+        onProcessingChanged();
+      });
+    }
+    sm.broadcastSessionList();
+    return true;
+  }
+
+  return {
+    deliver: deliver,
+    findAuthorSession: findAuthorSession,
+  };
+}
+
+module.exports = { attachProjectLogFeedbackDelivery: attachProjectLogFeedbackDelivery };

package/lib/project-logs.js

@@ -88,6 +88,7 @@ function attachProjectLogs(ctx) {
   var sendTo = ctx.sendTo;
   var getClients = ctx.getClients || function () { return []; };
   var getProjectOwnerId = ctx.getProjectOwnerId || function () { return null; };
+  var onFeedback = ctx.onFeedback || function () {};
 
   // Every socket in this project's client set passed the project access check
   // at WebSocket upgrade, so a broadcast here is already scoped to authorized
@@ -204,6 +205,9 @@ function attachProjectLogs(ctx) {
       if (msg.type === "project_log_comment") {
         var commented = bound.commentLog({ ref: msg.ref, body: msg.body });
         sendTo(ws, { type: "project_log_commented", requestId: requestId, entry: commented });
+        try { onFeedback(commented); } catch (deliveryError) {
+          console.error("[project-logs] Failed to deliver comment:", deliveryError.message || deliveryError);
+        }
         return true;
       }
     } catch (e) {

package/lib/project-pair-lifecycle.js

@@ -1,13 +1,9 @@
-// Autonomous Split Worker lifecycle: bounded status, atomic replacement, and
-// the per-generation evaluation ledger.
-//
-// A qualified Driver manages its visible Worker without asking the user: it
-// decides reuse against replacement from exact server-derived accounting, and
-// it replaces in one operation rather than a close/create dance. Nothing here
-// posts a proposal or waits for an approval card.
+// Split Worker lifecycle internals: bounded status, transactional replacement,
+// and the per-generation evaluation ledger. The Driver-facing tool posts a
+// user-controlled runtime card before accepted replacement reaches this module.
 //
 // Everything is bound to the exact live pair. The Driver is re-resolved from
-// the split store on every call, its eligibility is re-checked every time, and
+// the split store on every call, its structural capability is re-checked every time, and
 // ownership must match on both sessions. No active-tab or global-session
 // fallback exists in this module.
 //
@@ -187,7 +183,7 @@ function attachPairLifecycle(ctx) {
     return record;
   }
 
-  // The exact pair, with the Driver's eligibility re-checked on every call.
+  // The exact pair, with the Driver's structural capability re-checked on every call.
   function resolveDriverPair(caller) {
     if (!caller) throw new Error("pair lifecycle tools require a session-bound tool server");
     // Exact live object identity, before anything is read off the caller. A
@@ -206,7 +202,7 @@ function attachPairLifecycle(ctx) {
     var worker = sm.sessions.get(group.pair.workerId);
     if (!worker) throw new Error("split partner session was not found");
     if ((caller.ownerId || null) !== (worker.ownerId || null)) throw new Error("split partner access denied");
-    return { group: group, worker: worker, tier: verdict.tier };
+    return { group: group, worker: worker };
   }
 
   function replaceBlockedReason(worker) {
@@ -246,12 +242,11 @@ function attachPairLifecycle(ctx) {
       orchestration: turnControl.status(caller),
       replaceSafe: !blocked,
       replaceBlockedReason: blocked,
-      driverTier: resolved.tier ? resolved.tier.name : null,
       generations: ledger,
     };
   }
 
-  // Atomic replacement. Rejects an active Worker unless interrupt is
+  // Transactional replacement. Rejects an active Worker unless interrupt is
   // explicitly true, cancels anything the old Worker was waiting on, dissolves
   // the exact pair without deleting history, and creates a fresh Worker.
   // Idempotent in the sense that it either completes or leaves the existing

package/lib/project-session-pair.js

@@ -7,17 +7,13 @@ var driverEligibility = require("./session-driver-eligibility");
 var { attachWorkerPermission } = require("./project-worker-permission");
 var { attachWorkerProposal } = require("./project-worker-proposal");
 var MAX_RESPONSE_CHARS = 30000;
-function toolResult(value) {
-  return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] });
-}
-
+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 responseText(history, fromIndex) {
   var text = "";
   for (var i = Math.max(0, fromIndex || 0); i < history.length; i++) {
@@ -65,14 +61,14 @@ function attachSessionPair(ctx) {
   var workerPermission;
   var lifecycle;
   var turnControl = attachPairTurnControl({ sm: sm, splitStore: store });
-  function groupAndPartner(caller) {
+  function groupAndPartner(caller, missingPairMessage) {
     if (!caller) throw new Error("partner tools require a session-bound tool server");
     // Captured handlers must remain bound to the exact live Session object.
     if (sm.sessions.get(caller.localId) !== caller) {
       throw new Error("this session is no longer live; the partner tools are bound to an exact session");
     }
     var group = store.groupForMember(caller.localId);
-    if (!group) throw new Error("this session is not in a split group");
+    if (!group) throw new Error(missingPairMessage || "this session is not in a split group");
     if (group.pair && group.pair.driverId !== caller.localId) {
       throw new Error("only the configured Driver can direct this pair");
     }
@@ -102,7 +98,6 @@ function attachSessionPair(ctx) {
     broadcastDelegation(group, caller, partner, false);
   }
 
-  // Shared resume path for delegated results and Worker permission routing.
   function resumeDriverWithMessage(caller, text, meta) {
     if (!caller || caller.destroying) return false;
     if (turnControl.blockedReason(caller)) return false;
@@ -160,7 +155,6 @@ function attachSessionPair(ctx) {
     });
   }
 
-  // Give a waiting Driver its turn back so it can answer Worker permissions.
   function requestDetach(worker) {
     var token = worker && worker._pairDelegation;
     if (!token || token.detached || token.detachRequested) return false;
@@ -234,17 +228,11 @@ function attachSessionPair(ctx) {
   async function sendToPartner(args, caller) {
     try {
       if (caller && caller._delegatedBy) throw new Error("delegated turns cannot delegate to another session");
+      var resolved = groupAndPartner(caller,
+        "send_to_partner requires an exact existing Driver/Split Worker pair; call propose_worker while unpaired");
       var message = typeof args.message === "string" ? args.message.trim() : "";
       if (!message) throw new Error("message is required");
       turnControl.assertWorkerAction(caller);
-      var created = null;
-      if (caller && !store.groupForMember(caller.localId)) {
-        var creationTicket = turnControl.reserveCreation(caller, "create");
-        try { created = createWorkerForDriver(caller, args); }
-        catch (createError) { turnControl.releaseCreation(creationTicket); throw createError; }
-      }
-      var resolved = groupAndPartner(caller);
-      if (created && created.worker) lifecycle.recordGenerationStart(caller, created.worker);
       var wait = args.wait !== false;
       var timeout = Number.isFinite(args.timeoutSeconds) ? Math.floor(args.timeoutSeconds) : 300;
       timeout = Math.max(1, Math.min(900, timeout));
@@ -282,13 +270,18 @@ function attachSessionPair(ctx) {
       if (!wait) {
         token.detached = true;
         monitorPartner(resolved.group, caller, partner, token);
-        return toolResult({ status: "running", partnerId: partner.localId, workerCreated: !!created, 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, hint: "The completed result will be pushed back automatically. Use read_partner only for an interim status check." });
       }
-      var completed = await waitForPartner(resolved.group, caller, partner, token, timeout);
-      if (created) {
-        completed.workerCreated = true;
-        completed.partnerId = partner.localId;
+      if (!partner.isProcessing && !partner._queryStarting) {
+        finishDelegation(resolved.group, caller, partner, token);
+        var immediateFailure = errorSince(partner.history || [], token.startIndex);
+        return toolResult({
+          status: immediateFailure ? "error" : "complete",
+          response: responseText(partner.history || [], token.startIndex),
+          error: immediateFailure || undefined,
+        });
       }
+      var completed = await waitForPartner(resolved.group, caller, partner, token, timeout);
       return toolResult(completed);
     } catch (e) {
       if (caller) {
@@ -316,7 +309,6 @@ function attachSessionPair(ctx) {
         title: resolved.partner.title || "New Session",
         turns: count > 0 ? recentTurns(resolved.partner, count) : [],
       };
-      // partner_status's bounded report, so reading turns needs no second call.
       payload.capacity = lifecycle.optionalStatus(caller);
       return toolResult(payload);
     } catch (e) {
@@ -349,8 +341,6 @@ function attachSessionPair(ctx) {
         if (partner.abortController) partner.abortController.abort();
       }
       if (partner._pairDelegation) finishDelegation(resolved.group, caller, partner, partner._pairDelegation);
-      // Anything the Worker was waiting on the Driver to decide dies with the
-      // pair, immediately rather than on the next liveness sweep.
       workerPermission.cancelForSession(partner, "The Driver closed the Split Worker pair.");
       var ws = { _clayUser: caller.ownerId ? { id: caller.ownerId } : null };
       var result = store.dissolve(ws, { id: resolved.group.id });
@@ -378,12 +368,14 @@ function attachSessionPair(ctx) {
       replace: function () { return toolError(new Error("replace_partner requires a session-bound tool server")); },
       evaluate: function () { return toolError(new Error("record_partner_evaluation requires a session-bound tool server")); },
     });
-    // Mount for the query lifetime; handlers re-resolve live pair state.
     var group = store.groupForMember(boundSession.localId);
     if (group && group.pair && group.pair.driverId !== boundSession.localId) return [];
-    // Plain splits keep base tools; autonomous Drivers must pass the tier gate.
     var adHocSplit = !!(group && !group.pair);
-    if (!adHocSplit && !driverEligibility.isEligibleDriverSession(boundSession, sm)) return [];
+    if (!driverEligibility.isEligibleDriverSession(boundSession, sm)) return [];
+    if (!group) {
+      return workerProposal.getToolDefs(boundSession)
+        .concat(workerPermission.getToolDefs(boundSession, { dormantDriver: true }));
+    }
     var lifecycleHandlers = lifecycle.toolHandlers(boundSession);
     var tools = pairMcp.getToolDefs({
       send: function (args) {
@@ -397,17 +389,15 @@ function attachSessionPair(ctx) {
       status: lifecycleHandlers.status,
       replace: function (args) {
         return turnControl.runOperation(boundSession, "replace", args && args.operationId, function () {
-          return lifecycleHandlers.replace(args || {});
+          return workerProposal.proposeReplacement(args || {}, boundSession);
         });
       },
       evaluate: lifecycleHandlers.evaluate,
     }, { lifecycle: !adHocSplit });
     return tools
-      .concat(workerPermission.getToolDefs(boundSession, { dormantDriver: !group }))
-      .concat(workerProposal.getToolDefs(boundSession));
+      .concat(workerPermission.getToolDefs(boundSession, { dormantDriver: false }));
   }
 
-  // Passed through as-is; re-wrapping drops fields. See session-pair-factory.js.
   var factory = attachPairFactory(ctx);
   var createPairRecord = factory.createPairRecord;
   var createWorkerForDriver = factory.createWorkerForDriver;
@@ -445,8 +435,11 @@ function attachSessionPair(ctx) {
     getLinuxUserForSession: ctx.getLinuxUserForSession,
     onProcessingChanged: ctx.onProcessingChanged,
     adapters: ctx.adapters,
+    dangerouslySkipPermissions: ctx.dangerouslySkipPermissions,
     createPairRecord: createPairRecord,
+    recordGenerationStart: function (driver, worker) { return lifecycle.recordGenerationStart(driver, worker); },
     sendToPartner: sendToPartner,
+    replacePartner: function (args, session) { return lifecycle.replacePartner(args, session); },
   });
 
   function handleMessage(ws, msg) {
@@ -474,8 +467,8 @@ function attachSessionPair(ctx) {
     var pairPrompt = "";
     if (group && group.pair && group.pair.driverId === session.localId) {
       pairPrompt = pairPrompts.DRIVER;
-    } else if (!group && !ctx.isMate) {
-      pairPrompt = pairPrompts.UNPAIRED;
+    } else if (!group && !ctx.isMate && driverEligibility.isEligibleDriverSession(session, sm)) {
+      pairPrompt = pairPrompts.UNPAIRED + " " + workerProposal.getSystemPrompt(session);
     }
     return pairPrompt;
   }
@@ -487,12 +480,9 @@ function attachSessionPair(ctx) {
     handleMessage: handleMessage,
     handleTurnDone: handleTurnDone,
     getSystemPrompt: getSystemPrompt,
+    respondToWorkerProposal: workerProposal.respondToProposal,
     workerPermission: workerPermission,
   };
 }
 
-module.exports = {
-  attachSessionPair: attachSessionPair,
-  responseText: responseText,
-  recentTurns: recentTurns,
-};
+module.exports = { attachSessionPair: attachSessionPair, responseText: responseText, recentTurns: recentTurns };