clay-server 4.0.1-beta.1 → 4.1.0-beta.2

package/lib/sessions.js

@@ -186,6 +186,7 @@ function createSessionManager(opts) {
       var provenanceMeta = sessionProvenance.metadata(session);
       metaObj.sessionOriginId = provenanceMeta.sessionOriginId;
       if (provenanceMeta.sessionProvenance) metaObj.sessionProvenance = provenanceMeta.sessionProvenance;
+      if (Array.isArray(session._workerGenerations)) metaObj.workerGenerations = session._workerGenerations;
       var meta = JSON.stringify(metaObj);
       var lines = [meta];
       for (var i = 0; i < session.history.length; i++) {
@@ -308,6 +309,7 @@ function createSessionManager(opts) {
       if (m.ownerId) session.ownerId = m.ownerId;
       session.sessionOriginId = m.sessionOriginId || null;
       session._provenanceMigrationNeeded = sessionProvenance.restore(m, session);
+      if (Array.isArray(m.workerGenerations)) session._workerGenerations = m.workerGenerations;
       // Born-TUI session: PTY is gone after restart, but the cliSessionId
       // is still resumable via `claude --resume <id>`. We mark the mode
       // here so it shows up in the sidebar with the right icon; the

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

package/lib/yoke/adapters/codex.js

@@ -193,7 +193,8 @@ function flattenEvent(notification, state) {
     if (turnStatus === "interrupted" || state.aborted) {
       events.push({ yokeType: "interrupted" });
     }
-    var inputTokens = state.lastInputTokens || (usage ? (usage.input_tokens || 0) + (usage.cached_input_tokens || 0) : 0);
+    var inputTokens = state.lastInputTokens !== null && state.lastInputTokens !== undefined
+      ? state.lastInputTokens : (usage ? (usage.input_tokens || 0) : 0);
     var outputTokens = (usage ? (usage.output_tokens || 0) : 0) || state.lastOutputTokens || 0;
     var cachedTokens = (usage ? (usage.cached_input_tokens || 0) : 0) || state.lastCachedTokens || 0;
     var hasTokenData = inputTokens > 0 || outputTokens > 0;
@@ -217,7 +218,7 @@ function flattenEvent(notification, state) {
       } : null,
       modelUsage: resultModelUsage,
       sessionId: state.threadId || null,
-      lastStreamInputTokens: state.lastInputTokens || null,
+      lastStreamInputTokens: null,
     });
     state.lastInputTokens = null;
     state.lastCachedTokens = null;
@@ -675,15 +676,28 @@ function flattenEvent(notification, state) {
   // context gauge must use the LAST turn, not the running total: each turn's
   // input already contains the whole conversation, so summing turns
   // overstates occupancy (a 5k + 8k thread reads as 13k of an 8k context).
-  // `total` is only a fallback for servers that omit lastTurn.
+  // A missing lastTurn is not evidence of current context occupancy. The
+  // protocol's total is cumulative across the thread and must never be used
+  // as the context gauge.
   if (method === "thread/tokenUsage/updated") {
     var tu = params.tokenUsage;
     if (tu) {
-      var turnUsage = tu.lastTurn || tu.total;
+      var turnUsage = tu.lastTurn;
       if (turnUsage) {
-        state.lastInputTokens = (turnUsage.inputTokens || 0) + (turnUsage.cachedInputTokens || 0);
+        var candidateInput = typeof turnUsage.inputTokens === "number" ? turnUsage.inputTokens : null;
+        var currentWindow = typeof tu.modelContextWindow === "number" ? tu.modelContextWindow : null;
+        state.lastInputTokens = candidateInput !== null && (currentWindow === null || candidateInput <= currentWindow) ? candidateInput : null;
         state.lastCachedTokens = turnUsage.cachedInputTokens || 0;
         state.lastOutputTokens = turnUsage.outputTokens || 0;
+        state.currentContextUsage = state.lastInputTokens !== null &&
+          (currentWindow === null || state.lastInputTokens <= currentWindow)
+          ? { input_tokens: state.lastInputTokens, contextWindow: currentWindow }
+          : { input_tokens: null, contextWindow: currentWindow };
+      } else {
+        state.lastInputTokens = null;
+        state.lastCachedTokens = null;
+        state.lastOutputTokens = null;
+        state.currentContextUsage = null;
       }
       if (tu.modelContextWindow) state.modelContextWindow = tu.modelContextWindow;
     }
@@ -734,6 +748,7 @@ function createEventState(model) {
     lastInputTokens: null,
     lastCachedTokens: null,
     lastOutputTokens: null,
+    currentContextUsage: null,
     modelContextWindow: null,
     done: false,
     aborted: false,
@@ -1107,6 +1122,9 @@ function createCodexQueryHandle(appServer, queryOpts) {
 
       var threadResult;
       if (queryOpts.resumeSessionId) {
+        // ThreadResumeParams in the installed app-server schema has no
+        // dynamicTools field. New tools therefore require a new Driver/Worker
+        // thread; resumed threads can only refresh handlers for persisted tools.
         threadResult = await appServer.send("thread/resume", {
           threadId: queryOpts.resumeSessionId,
           model: threadParams.model,
@@ -1269,7 +1287,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
     },
 
     getContextUsage: function() {
-      return Promise.resolve(state.lastUsage);
+      return Promise.resolve(state.currentContextUsage);
     },
 
     abort: function() {
@@ -1342,8 +1360,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.1-beta.1",
+  "version": "4.1.0-beta.2",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js",