clay-server 4.0.0 → 4.1.0-beta.1

package/lib/session-pair-factory.js

@@ -42,6 +42,9 @@ function attachPairFactory(ctx) {
   function validateVendor(vendor) {
     var installed = sm.installedVendors || [];
     if (!vendor || installed.indexOf(vendor) === -1) throw new Error("vendor is not installed: " + (vendor || "unknown"));
+    if (Array.isArray(sm.availableVendors) && sm.availableVendors.indexOf(vendor) === -1) {
+      throw new Error("vendor runtime is temporarily unavailable: " + vendor);
+    }
     return vendor;
   }
 

package/lib/session-pair-history.js

@@ -0,0 +1,40 @@
+var MAX_RESPONSE_CHARS = 30000;
+
+function responseText(history, fromIndex) {
+  var text = "";
+  for (var i = Math.max(0, fromIndex || 0); i < history.length; i++) {
+    if (history[i] && history[i].type === "delta" && history[i].text) text += history[i].text;
+  }
+  return text.length > MAX_RESPONSE_CHARS ? text.slice(-MAX_RESPONSE_CHARS) : text;
+}
+
+function errorSince(history, fromIndex) {
+  for (var i = history.length - 1; i >= Math.max(0, fromIndex || 0); i--) {
+    if (history[i] && history[i].type === "error") return history[i].text || "partner turn failed";
+  }
+  return null;
+}
+
+function recentTurns(session, count) {
+  var history = session.history || [];
+  var starts = [];
+  for (var i = 0; i < history.length; i++) if (history[i] && history[i].type === "user_message") starts.push(i);
+  var from = starts.length > 0 ? starts[Math.max(0, starts.length - count)] : 0;
+  var turns = [];
+  var current = null;
+  for (var j = from; j < history.length; j++) {
+    var item = history[j];
+    if (!item) continue;
+    if (item.type === "user_message") {
+      current = { user: item.text || "", delegated: !!item.delegated, response: "" };
+      turns.push(current);
+    } else if (item.type === "delta" && item.text) {
+      if (!current) { current = { user: "", delegated: false, response: "" }; turns.push(current); }
+      current.response += item.text;
+      if (current.response.length > MAX_RESPONSE_CHARS) current.response = current.response.slice(-MAX_RESPONSE_CHARS);
+    }
+  }
+  return turns;
+}
+
+module.exports = { errorSince: errorSince, recentTurns: recentTurns, responseText: responseText };

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

@@ -15,6 +15,7 @@ function getToolDefs(handlers, options) {
         wait: { type: "boolean", description: "Wait for the partner's turn to finish. Defaults to true." },
         timeoutSeconds: { type: "number", description: "Maximum wait in seconds, from 1 to 900. Defaults to 300." },
         operationId: { type: "string", description: "Optional stable id for this delegation. Reusing it within the same human turn returns the original operation instead of sending twice." },
+        taskId: { type: "string", description: "Optional stable task id for generation and completion correlation." },
       }, ["message"]),
       handler: function (args) { return handlers.send(args || {}); },
     },
@@ -29,7 +30,7 @@ function getToolDefs(handlers, options) {
     {
       name: "interrupt_partner",
       description: "Interrupt the Split Worker's current task. Use this when the task is going in the wrong direction, needs to be reprioritized, or must stop before the next instruction. The Split Worker returns any partial result to you for review.",
-      inputSchema: buildShape({}),
+      inputSchema: buildShape({ reason: { type: "string", description: "Why the Driver is interrupting this task." } }),
       handler: function (args) { return handlers.interrupt(args || {}); },
     },
     {
@@ -41,6 +42,15 @@ function getToolDefs(handlers, options) {
   ];
   if (!lifecycle) return defs;
   return defs.concat([
+    {
+      name: "message_partner",
+      description: "Queue a non-interrupting message on the active Split Worker's runtime input without creating a delegated follow-up. Returns queued or rejected with an exact request id; queued does not claim model execution.",
+      inputSchema: buildShape({
+        message: { type: "string", description: "Bounded correction or context for the current active Worker turn." },
+        requestId: { type: "string", description: "Optional stable request id. Reuse it to deduplicate a retried delivery within this human turn." },
+      }, ["message"]),
+      handler: function (args) { return handlers.message(args || {}); },
+    },
     {
       name: "partner_status",
       description: "Bounded capacity and continuity report for your Split Worker, for deciding reuse against replacement: context tokens used and the ratio of its window, current task and activity, vendor/model/effort, history size and idle time, whether it is safe to replace right now, and your own recorded results for earlier Worker generations. Returns no transcript. Prefer this over reading turns when you only need to decide.",
@@ -62,6 +72,7 @@ function getToolDefs(handlers, options) {
           description: "Optional bounded assessment of the Worker being replaced, recorded against that exact generation.",
         },
         operationId: { type: "string", description: "Optional stable id for this replacement. Reusing it within the same human turn returns the original operation instead of replacing twice." },
+        supersedeProposalId: { type: "string", description: "Exact pending replacement proposal id to supersede with this new configuration." },
       }, ["message", "recommendationRationale"]),
       handler: function (args) { return handlers.replace(args || {}); },
     },

package/lib/session-pair-operation.js

@@ -0,0 +1,11 @@
+function fingerprint(args, fields) {
+  var source = args || {};
+  var value = {};
+  for (var i = 0; i < fields.length; i++) {
+    var name = fields[i];
+    value[name] = Object.prototype.hasOwnProperty.call(source, name) ? source[name] : null;
+  }
+  return JSON.stringify(value);
+}
+
+module.exports = { fingerprint: fingerprint };

package/lib/session-pair-prompts.js

@@ -3,6 +3,19 @@
 // Pure data, extracted from project-session-pair.js so that module stays under
 // the size limit and so the guidance can be reviewed as prose.
 
+var WORKER_RUNTIME_SELECTION = [
+  "Use a high-low model mix: keep decomposition, judgment, and review with the Driver, and prefer a lighter",
+  "Worker model capable of the bounded execution task. Do not mirror the Driver's model or default to the",
+  "strongest available model merely because it is available. Explicitly fill the vendor, model, and thinking",
+  "effort recommendation fields for both creation and replacement; never leave model selection to card defaults.",
+  "Select model capability and thinking effort separately. Start with the lowest effort adequate for the task,",
+  "not high effort by habit. Choose from the installed, offered catalog; do not invent model availability or prices.",
+  "Explain why the lighter choice can handle the task. Escalate only for a concrete requirement beyond its",
+  "capabilities or observed failures, and state that reason. Use recorded Worker outcomes when available,",
+  "and reconsider a lighter model for the next bounded task after an escalation. Honor the user's explicit",
+  "runtime choice; this is a recommendation policy, not a restriction on which model the user may select.",
+].join(" ").replace(/ {2,}/g, " ");
+
 var DRIVER_DELEGATION = [
   "Your management objective: protect your own context, keep the Split Worker compact, and put execution where",
   "it runs best. Delegate implementation-heavy work rather than doing it here. Treat work spanning multiple modules,",
@@ -13,9 +26,10 @@ var DRIVER_DELEGATION = [
 ].join(" ").replace(/ {2,}/g, " ");
 
 var DRIVER_CORE = [
+  WORKER_RUNTIME_SELECTION,
   "You are the Driver of a visible Driver/Split Worker pair, and you manage that Split Worker yourself.",
-  "The tools send_to_partner, read_partner, partner_status, replace_partner, interrupt_partner, close_partner,",
-  "and record_partner_evaluation are provided directly to you.",
+  "The pair tools distinguish a live message, a queued follow-up, an interrupt-and-replace task, resumption,",
+  "and replacement of the Worker runtime. Inspect exact task and proposal ids before changing queued work.",
   "",
   "Reuse the existing Split Worker",
   "only when its accumulated context genuinely helps the next task; when it is context-bloated, stale, or",
@@ -34,6 +48,8 @@ var DRIVER_CORE = [
   "interrupt true, which stops it first only after acceptance. A human Stop",
   "is authoritative: do not retry, send more work, or replace the Worker in the same turn. Clay blocks those",
   "actions until the human sends a new Driver message. Use close_partner when they ask to close the pane.",
+  "A Worker outcome envelope is Worker-reported evidence, not Driver verification. Preserve partial results and",
+  "correlate completions to their task and generation; never attach a late old-generation result to a new Worker.",
   "",
   "Recommend a Worker vendor, model, and effort from what is actually installed and offered, and include a concise",
   "rationale explaining why all three fit the task. The card remains visible as an audit trail even when full access",
@@ -56,7 +72,12 @@ var DRIVER_CORE = [
 
 var DRIVER = DRIVER_CORE + " " + DRIVER_DELEGATION;
 
+function worker(taskId) {
+  return "You are the configured Split Worker. For task " + (taskId || "unknown") + ", call report_partner_outcome before finishing when the tool is available. Report only what you observed: changed files, verification commands/results, unverified work, running processes, and next action. Never claim Driver verification.";
+}
+
 var UNPAIRED = [
+  WORKER_RUNTIME_SELECTION,
   "Infer the user's intended target from conversational and UI context. References to a user-visible paired or",
   "split pane, its session, its activity or status, or a collaborator the user wants opened resolve to Clay's",
   "Split Worker and its partner tools. Internal Sub-agents are a distinct execution mechanism, not a lexical",
@@ -76,4 +97,5 @@ module.exports = {
   DRIVER_CORE: DRIVER_CORE,
   DRIVER_DELEGATION: DRIVER_DELEGATION,
   UNPAIRED: UNPAIRED,
+  worker: worker,
 };

package/lib/session-pair-turn-control.js

@@ -111,14 +111,19 @@ function attachPairTurnControl(ctx) {
     return clean;
   }
 
-  function runOperation(driver, kind, rawId, fn) {
+  function runOperation(driver, kind, rawId, fn, fingerprint) {
     var id = operationId(rawId);
     if (!id) return Promise.resolve().then(fn);
     var state = stateFor(driver);
     var key = kind + ":" + id;
-    if (state.operations[key]) return state.operations[key];
+    if (state.operations[key]) {
+      if (fingerprint !== undefined && state.operations[key].fingerprint !== fingerprint) {
+        return Promise.reject(new Error("operation id was already used with different input"));
+      }
+      return state.operations[key].promise;
+    }
     var promise = Promise.resolve().then(fn);
-    state.operations[key] = promise;
+    state.operations[key] = { fingerprint: fingerprint, promise: promise };
     return promise;
   }
 

package/lib/worker-proposal-control.js

@@ -0,0 +1,69 @@
+var buildShape = require("./session-spawn-mcp-server").buildShape;
+
+function findProposal(session, proposalId) {
+  var history = (session && session.history) || [];
+  for (var i = history.length - 1; i >= 0; i--) {
+    if (history[i] && history[i].type === "worker_proposal" && history[i].proposalId === proposalId) return history[i];
+  }
+  return null;
+}
+
+function pendingProposal(session) {
+  var history = (session && session.history) || [];
+  for (var i = history.length - 1; i >= 0; i--) {
+    var item = history[i];
+    if (!item || item.type !== "worker_proposal") continue;
+    if (item.status === "pending" || item.status === "starting") return item;
+  }
+  return null;
+}
+
+function projection(proposal) {
+  if (!proposal) return { status: "none", proposal: null };
+  return {
+    status: proposal.status,
+    proposal: {
+      proposalId: proposal.proposalId,
+      action: proposal.action === "replace" ? "replace" : "create",
+      summary: proposal.summary || "",
+      recommendedVendor: proposal.recommendedVendor || null,
+      recommendedModel: proposal.recommendedModel || null,
+      recommendedEffort: proposal.recommendedEffort || null,
+      status: proposal.status,
+      pending: proposal.status === "pending",
+      decisionRequired: proposal.status === "pending",
+      transactionId: proposal.transactionId || null,
+      sourceWorkerId: proposal.sourceWorkerId || null,
+      createdAt: proposal.createdAt || null,
+      updatedAt: proposal.updatedAt || null,
+    },
+  };
+}
+
+function getToolDefs(handlers) {
+  return [{
+    name: "inspect_worker_proposal",
+    description: "Inspect the exact unresolved Split Worker configuration proposal for this Driver. Returns none when no user decision is pending.",
+    inputSchema: buildShape({}),
+    handler: function () { return handlers.inspect(); },
+  }, {
+    name: "cancel_worker_proposal",
+    description: "Cancel one exact pending Split Worker configuration proposal. A proposal that is already accepted, starting, superseded, declined, or otherwise resolved cannot be cancelled.",
+    inputSchema: buildShape({
+      proposalId: { type: "string", description: "Exact proposal id returned by propose_worker, replace_partner, or inspect_worker_proposal." },
+    }, ["proposalId"]),
+    handler: function (args) { return handlers.cancel(args || {}); },
+  }, {
+    name: "worker_runtime_catalog",
+    description: "List server-observed executable Split Worker vendor, model, and effort combinations, including approval mode and temporary unavailability reasons.",
+    inputSchema: buildShape({}),
+    handler: function () { return handlers.catalog(); },
+  }];
+}
+
+module.exports = {
+  findProposal: findProposal,
+  getToolDefs: getToolDefs,
+  pendingProposal: pendingProposal,
+  projection: projection,
+};

package/lib/worker-proposal-decision.js

@@ -0,0 +1,7 @@
+// An accepted execution record is not an unanswered configuration decision.
+// Execution interruption and replacement safety belong to the pair lifecycle.
+var pendingProposal = require("./worker-proposal-control").pendingProposal;
+
+function hasPendingProposal(session) { return !!pendingProposal(session); }
+
+module.exports = { hasPendingProposal: hasPendingProposal };

package/lib/worker-runtime-catalog.js

@@ -0,0 +1,52 @@
+var yoke = require("./yoke");
+
+function modelValue(entry) { return typeof entry === "string" ? entry : entry && (entry.value || entry.id) || ""; }
+
+function build(options, fullAccess, preflight) {
+  var vendors = [];
+  var installed = options.installedVendors || [];
+  for (var i = 0; i < installed.length; i++) {
+    var vendor = installed[i];
+    var models = options.modelsByVendor[vendor] || [];
+    var capability = options.capabilitiesByVendor[vendor] || {};
+    var vendorInfo = yoke.getVendorInfo(vendor) || {};
+    var combinations = [];
+    var readyObserved = Array.isArray(options.availableVendors);
+    var adapterReady = !readyObserved || options.availableVendors.indexOf(vendor) !== -1;
+    for (var j = 0; j < models.length; j++) {
+      var model = modelValue(models[j]);
+      if (!model) continue;
+      var levels = models[j] && models[j].supportedEffortLevels;
+      if (!Array.isArray(levels) || levels.length === 0) levels = vendorInfo.effortLevels || [];
+      if (capability.effort === false || levels.length === 0) levels = [null];
+      for (var k = 0; k < levels.length; k++) {
+        try {
+          if (preflight) preflight(vendor, model, levels[k]);
+          if (adapterReady) combinations.push({ model: model, effort: levels[k] });
+        } catch (err) {}
+      }
+    }
+    vendors.push({
+      vendor: vendor,
+      status: combinations.length ? "available" : "temporarily_unavailable",
+      unavailableReason: combinations.length ? null : (!adapterReady ? "The runtime adapter is not currently available." : (options.unavailableReasons && options.unavailableReasons[vendor] || "No executable model and effort combination passed server preflight.")),
+      evidence: {
+        installation: "observed",
+        adapter: readyObserved ? (adapterReady ? "ready" : "unavailable") : "unknown",
+        authentication: "unknown",
+        authenticationReason: "Authentication is confirmed by the vendor runtime when a task starts; catalog discovery alone is not proof of credentials.",
+      },
+      combinations: combinations,
+    });
+  }
+  return {
+    status: "ok",
+    observedAt: Date.now(),
+    vendors: vendors,
+    approval: fullAccess
+      ? { mode: "conditional_auto_accept", reason: "Only an exact server-validated Driver recommendation may auto-accept." }
+      : { mode: "user_required", reason: "Runtime creation and replacement require the visible configuration decision." },
+  };
+}
+
+module.exports = { build: build };

package/lib/workspace-query-access.js

@@ -77,10 +77,11 @@ function attachWorkspaceQueryAccess(deps) {
 
   // `accessible` decides whether the container is visible at all; `owned`
   // drives the separate rule that an accessible container holding no session of
-  // the caller's own is omitted. Worktrees are never surfaced directly.
+  // the caller's own is omitted. Exact worktree grants are resolved from their
+  // own authoritative access record rather than inferred from the parent.
   function evaluate(principal, status) {
     var denied = { owned: false, accessible: false };
-    if (!principal || !status || status.isWorktree) return denied;
+    if (!principal || !status) return denied;
     if (typeof isMultiUser !== "function" || !isMultiUser()) {
       var owned = ownsSingleUser(principal, status);
       return { owned: owned, accessible: owned };

package/lib/workspace-query-service.js

@@ -181,7 +181,7 @@ function attachWorkspaceQueryService(ctx) {
     var projects = [];
     getProjects().forEach(function (project, slug) {
       var status = project.getStatus();
-      if (!status || status.isWorktree) return;
+      if (!status) return;
       // Authorized here rather than at bind time, so an already-created tool
       // handler loses a project the moment its access record changes.
       var verdict = projectAccess.evaluate(principal, status);

package/lib/worktree.js

@@ -55,7 +55,7 @@ function worktreePath(projectPath, dirName) {
 // Scan worktrees for a given project path
 // Returns array of { path, branch, bare, detached, external }
 // external = true when Git registered the worktree outside the main project folder
-function scanWorktrees(projectPath, osUserInfo) {
+function scanWorktreesResult(projectPath, osUserInfo) {
   var resolvedParent = path.resolve(projectPath);
   try { resolvedParent = fs.realpathSync(resolvedParent); } catch (e) {}
   try {
@@ -76,12 +76,16 @@ function scanWorktrees(projectPath, osUserInfo) {
       wt.dirName = path.basename(wt.path);
       results.push(wt);
     }
-    return results;
+    return { ok: true, worktrees: results };
   } catch (e) {
-    return [];
+    return { ok: false, worktrees: [], error: e.message || "Failed to scan worktrees" };
   }
 }
 
+function scanWorktrees(projectPath, osUserInfo) {
+  return scanWorktreesResult(projectPath, osUserInfo).worktrees;
+}
+
 // Create a new worktree inside the parent project directory
 // Returns { ok, path, error }
 function createWorktree(projectPath, branchName, dirName, baseBranch, osUserInfo) {
@@ -127,4 +131,4 @@ function removeWorktree(projectPath, worktreeDirName, osUserInfo) {
   }
 }
 
-module.exports = { scanWorktrees: scanWorktrees, createWorktree: createWorktree, removeWorktree: removeWorktree, isWorktree: isWorktree, isPathInside: isPathInside };
+module.exports = { scanWorktrees: scanWorktrees, scanWorktreesResult: scanWorktreesResult, createWorktree: createWorktree, removeWorktree: removeWorktree, isWorktree: isWorktree, isPathInside: isPathInside };

package/lib/ws-schema.js

@@ -72,6 +72,7 @@ var schema = {
   "home_project_assignment_proposal": { direction: "s2c", handler: "lib/public/modules/app-message-router.js", description: "Home-projected exact-session assignment approval card" },
   "home_project_assignment_status": { direction: "s2c", handler: "lib/public/modules/app-message-router.js", description: "Home-projected exact-session assignment lifecycle" },
   "split_delegation":         { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "A pair delegation started or ended (drives the split-view flow indicator)" },
+  "partner_task_completed":   { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Structured completion event for one correlated Split Worker task" },
 
   // -----------------------------------------------------------------------
   // History replay
@@ -643,6 +644,8 @@ var schema = {
   "home_mate_sessions_list":  { direction: "c2s", handler: "lib/server-home-chat.js", description: "List the current user's conversations with the selected mate" },
   "home_mate_session_open":   { direction: "c2s", handler: "lib/server-home-chat.js", description: "Open one explicit conversation with the selected mate" },
   "home_mate_send":           { direction: "c2s", handler: "lib/server-home-chat.js", description: "Send a message to the selected mate from the home hub" },
+  "home_mate_stop":           { direction: "c2s", handler: "lib/server-home-chat.js", description: "Stop the exact query-bound global Ask Clay turn" },
+  "home_mate_permission_response": { direction: "c2s", handler: "lib/server-home-chat.js", description: "Answer an exact pending global Ask Clay permission request" },
   "home_mate_new_session":    { direction: "c2s", handler: "lib/server-home-chat.js", description: "Start a fresh embedded session with the selected mate, optionally with a typed creation intent" },
   "home_mate_debate_plan":    { direction: "c2s", handler: "lib/server-home-chat.js", description: "Start a fresh server-seeded debate planning conversation with Clay using an optional prefilled topic" },
   "home_mate_creation_plan":  { direction: "c2s", handler: "lib/server-home-chat.js", description: "Start a fresh server-seeded Mate creation interview with Clay" },
@@ -659,6 +662,10 @@ var schema = {
   "home_mate_model_set":      { direction: "c2s", handler: "lib/server-home-chat.js", description: "Validate and persist the Mate vendor/model, optionally applying it to an exact owned pristine Home draft" },
   "home_mate_history":        { direction: "s2c", handler: "lib/public/modules/home-mate-chat.js", description: "Selected mate's initial or refreshed chat history" },
   "home_clay_activity":       { direction: "s2c", handler: "lib/public/modules/search-clay-chat.js", description: "Sanitized progress stage for a query-bound global-search Clay conversation" },
+  "home_mate_permission_request": { direction: "s2c", handler: "lib/public/modules/search-clay-chat.js", description: "Exact pending permission card for a global Ask Clay conversation" },
+  "home_mate_permission_resolved": { direction: "s2c", handler: "lib/public/modules/search-clay-chat.js", description: "Server-confirmed Ask Clay permission decision" },
+  "home_mate_permission_cancelled": { direction: "s2c", handler: "lib/public/modules/search-clay-chat.js", description: "Server-confirmed Ask Clay permission cancellation" },
+  "home_mate_stopping":       { direction: "s2c", handler: "lib/public/modules/search-clay-chat.js", description: "Server accepted Stop for the exact Ask Clay conversation" },
   "home_mate_session_identity": { direction: "s2c", handler: "lib/public/modules/app-message-router.js", description: "Promote an active Home session from its local reference to its durable runtime identity" },
   "home_mate_sessions_state": { direction: "s2c", handler: "lib/public/modules/home-mate-chat.js", description: "Owned visible Mate conversations with sanitized runtime identity, model, status, and timestamps" },
   "home_mate_delta":          { direction: "s2c", handler: "lib/public/modules/home-mate-chat.js", description: "Selected mate's streaming assistant text delta" },

package/lib/yoke/adapters/codex.js

@@ -1269,7 +1269,11 @@ function createCodexQueryHandle(appServer, queryOpts) {
     },
 
     getContextUsage: function() {
-      return Promise.resolve(state.lastUsage);
+      if (state.lastInputTokens == null && state.modelContextWindow == null) return Promise.resolve(null);
+      return Promise.resolve({
+        input_tokens: state.lastInputTokens == null ? null : state.lastInputTokens,
+        contextWindow: state.modelContextWindow || null,
+      });
     },
 
     abort: function() {
@@ -1342,8 +1346,8 @@ function createCodexAdapter(opts) {
   // listing them would only surface a runtime failure in the model picker.
   var CODEX_MODELS = [
     "gpt-6-astra",
-    "gpt-5.6-terra",
     "gpt-5.6-sol",
+    "gpt-5.6-terra",
     "gpt-5.6-luna",
     "gpt-5.5",
     "gpt-5.2",

package/package.json

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