clay-server 3.8.1 → 4.0.0-beta.1

package/lib/public/modules/tool-runtime.js

@@ -0,0 +1,309 @@
+// tool-runtime.js - Web Worker host for user-installed tool logic.
+
+import { getWs } from './ws-ref.js';
+
+var ACTION_TIMEOUT_MS = 10000;
+var LLM_ACTION_TIMEOUT_MS = 90000;
+var LLM_TIMEOUT_MS = 60000;
+var WS_WAIT_MS = 5000;
+var WS_RETRY_MS = 250;
+
+function workerProgram(logicSource, allowLlm) {
+  return [
+    "self.fetch = undefined; self.XMLHttpRequest = undefined; self.WebSocket = undefined; self.EventSource = undefined; self.importScripts = undefined;",
+    "var tool; var currentState = {}; var storageSeq = 0; var storagePending = Object.create(null); var llmSeq = 0; var llmPending = Object.create(null); var actionQueue = Promise.resolve();",
+    "function storageCall(op, args) {",
+    "  return new Promise(function (resolve, reject) {",
+    "    storageSeq++; storagePending[storageSeq] = { resolve: resolve, reject: reject };",
+    "    self.postMessage({ type: 'storage', op: op, args: args || {}, seq: storageSeq });",
+    "  });",
+    "}",
+    "function llmCall(args, callerId) {",
+    allowLlm ? "  return new Promise(function (resolve, reject) { llmSeq++; llmPending[llmSeq] = { resolve: resolve, reject: reject }; self.postMessage({ type: 'llm', seq: llmSeq, args: args || {}, callerId: callerId || 'user' }); });" : "  return Promise.reject(new Error('This capsule does not have the llm permission.'));",
+    "}",
+    "var api = { storage: {",
+    "  list: function () { return storageCall('list', {}); },",
+    "  get: function (id) { return storageCall('get', { id: id }); },",
+    "  put: function (doc) { return storageCall('put', { doc: doc }); },",
+    "  delete: function (id) { return storageCall('delete', { id: id }); },",
+    "  query: function (query) { return storageCall('query', { query: query }); }",
+    "}, llm: { complete: function () { return Promise.reject(new Error('api.llm.complete is only available inside an action.')); } } };",
+    logicSource,
+    "if (!tool || !tool.actions || typeof tool.actions !== 'object') throw new Error('logic.js must define var tool with an actions object.');",
+    "self.onmessage = function (event) {",
+    "  var msg = event.data || {};",
+    "  if (msg.type === 'init') {",
+    "    currentState = msg.state || tool.initialState || {};",
+    "    self.postMessage({ type: 'state', newState: currentState }); return;",
+    "  }",
+    "  if (msg.type === 'storage_result') {",
+    "    var pending = storagePending[msg.seq]; if (!pending) return; delete storagePending[msg.seq];",
+    "    if (msg.error) pending.reject(new Error(msg.error)); else pending.resolve(msg.data); return;",
+    "  }",
+    "  if (msg.type === 'llm_result') {",
+    "    var llmRequest = llmPending[msg.seq]; if (!llmRequest) return; delete llmPending[msg.seq];",
+    "    if (msg.error) llmRequest.reject(new Error(msg.error)); else llmRequest.resolve(msg.data); return;",
+    "  }",
+    "  if (msg.type === 'action') {",
+    "    var action = tool.actions[msg.name];",
+    "    if (typeof action !== 'function') { self.postMessage({ type: 'error', message: 'Unknown action: ' + msg.name, actionSeq: msg.actionSeq }); return; }",
+    "    var actionStartState;",
+    "    actionQueue = actionQueue.then(function () {",
+    "      actionStartState = currentState;",
+    "      var actionApi = Object.create(api); actionApi.callerId = msg.callerId || 'user'; actionApi.llm = { complete: function (args) { return llmCall(args, actionApi.callerId); } };",
+    "      actionApi.setState = function (nextState) { if (!nextState || typeof nextState !== 'object' || Array.isArray(nextState)) throw new Error('api.setState requires a state object.'); currentState = nextState; self.postMessage({ type: 'state', newState: currentState, actionSeq: msg.actionSeq, intermediate: true }); };",
+    "      return action(currentState, msg.args || {}, actionApi);",
+    "    }).then(function (nextState) {",
+    "      if (nextState !== undefined) currentState = nextState;",
+    "      self.postMessage({ type: 'state', newState: currentState, actionSeq: msg.actionSeq });",
+    "    }).catch(function (error) { if (actionStartState !== undefined) { currentState = actionStartState; self.postMessage({ type: 'state', newState: currentState, actionSeq: msg.actionSeq, intermediate: true, rollback: true }); } self.postMessage({ type: 'error', message: error && error.message ? error.message : String(error), actionSeq: msg.actionSeq }); });",
+    "  }",
+    "};",
+  ].join("\n");
+}
+
+export function createToolRuntime(config) {
+  var worker = null;
+  var state = config.state || null;
+  var actionSeq = 0;
+  var actionTimeouts = Object.create(null);
+  var stopped = false;
+  var restartCount = 0;
+  var initialActionSent = false;
+  var workerGeneration = 0;
+  var pendingStorage = Object.create(null);
+  var pendingLlm = Object.create(null);
+  var pendingActions = Object.create(null);
+  var readyWaiters = [];
+  var isReady = false;
+
+  function clearActionTimeout() {
+    var keys = Object.keys(actionTimeouts);
+    for (var i = 0; i < keys.length; i++) clearTimeout(actionTimeouts[keys[i]]);
+    actionTimeouts = Object.create(null);
+  }
+
+  function clearOneActionTimeout(seq) {
+    if (seq === undefined || !actionTimeouts[seq]) return;
+    clearTimeout(actionTimeouts[seq]);
+    delete actionTimeouts[seq];
+  }
+
+  function rejectActions(message) {
+    var keys = Object.keys(pendingActions);
+    for (var i = 0; i < keys.length; i++) pendingActions[keys[i]].reject(new Error(message));
+    pendingActions = Object.create(null);
+  }
+
+  function reportError(message) {
+    if (typeof config.onError === "function") config.onError(message);
+  }
+
+  function markReady() {
+    isReady = true;
+    if (readyWaiters.length === 0) return;
+    var waiters = readyWaiters;
+    readyWaiters = [];
+    for (var i = 0; i < waiters.length; i++) waiters[i].resolve(state);
+  }
+
+  function terminateWorker() {
+    clearActionTimeout();
+    if (worker) worker.terminate();
+    worker = null;
+    pendingStorage = Object.create(null);
+    var llmKeys = Object.keys(pendingLlm);
+    for (var li = 0; li < llmKeys.length; li++) clearTimeout(pendingLlm[llmKeys[li]].timer);
+    pendingLlm = Object.create(null);
+  }
+
+  function restartWorker(message) {
+    rejectActions(message);
+    terminateWorker();
+    reportError(message);
+    if (stopped) return;
+    restartCount++;
+    if (restartCount > 3) {
+      reportError("Tool worker stopped after repeated failures.");
+      var waiters = readyWaiters;
+      readyWaiters = [];
+      for (var i = 0; i < waiters.length; i++) waiters[i].reject(new Error(message));
+      return;
+    }
+    initialActionSent = false;
+    isReady = false;
+    setTimeout(function () { if (!stopped) spawnWorker(); }, 100);
+  }
+
+  function withReadySocket(startedAt, generation, onReady, onTimeout) {
+    if (stopped || generation !== workerGeneration || !worker) return;
+    var ws = getWs();
+    if (ws && ws.readyState === 1) {
+      try {
+        onReady(ws);
+        return;
+      } catch (error) {}
+    }
+    var waitMs = config.wsWaitMs === undefined ? WS_WAIT_MS : config.wsWaitMs;
+    if (Date.now() - startedAt >= waitMs) {
+      onTimeout();
+      return;
+    }
+    var retryMs = config.wsRetryMs === undefined ? WS_RETRY_MS : config.wsRetryMs;
+    setTimeout(function () { withReadySocket(startedAt, generation, onReady, onTimeout); }, retryMs);
+  }
+
+  function sendStorageOperation(msg) {
+    var generation = workerGeneration;
+    withReadySocket(Date.now(), generation, function (ws) {
+      var externalSeq = config.toolId + ":" + generation + ":" + msg.seq;
+      pendingStorage[externalSeq] = msg.seq;
+      try {
+        ws.send(JSON.stringify({ type: "tool_storage_op", toolId: config.toolId, op: msg.op, args: msg.args, seq: externalSeq }));
+      } catch (error) {
+        delete pendingStorage[externalSeq];
+        throw error;
+      }
+    }, function () {
+      if (worker && generation === workerGeneration) {
+        worker.postMessage({ type: "storage_result", seq: msg.seq, error: "Tool storage is unavailable after waiting 5 seconds for the connection." });
+      }
+    });
+  }
+
+  function sendLlmOperation(msg) {
+    if (!config.allowLlm) {
+      worker.postMessage({ type: "llm_result", seq: msg.seq, error: "This capsule does not have the llm permission." });
+      return;
+    }
+    if (typeof config.onLlmRequest === "function") config.onLlmRequest(msg.args && msg.args.model ? msg.args.model : "fast");
+    var generation = workerGeneration;
+    withReadySocket(Date.now(), generation, function (ws) {
+      var requestId = config.toolId + ":llm:" + generation + ":" + msg.seq;
+      pendingLlm[requestId] = {
+        seq: msg.seq,
+        timer: setTimeout(function () {
+          if (!pendingLlm[requestId] || !worker) return;
+          delete pendingLlm[requestId];
+          worker.postMessage({ type: "llm_result", seq: msg.seq, error: "LLM request timed out after 60 seconds." });
+        }, LLM_TIMEOUT_MS),
+      };
+      try {
+        ws.send(JSON.stringify({ type: "tool_llm_op", toolId: config.toolId, requestId: requestId, args: msg.args, callerId: msg.callerId || "user" }));
+      } catch (error) {
+        clearTimeout(pendingLlm[requestId].timer);
+        delete pendingLlm[requestId];
+        throw error;
+      }
+    }, function () {
+      if (worker && generation === workerGeneration) {
+        worker.postMessage({ type: "llm_result", seq: msg.seq, error: "Tool LLM service is unavailable after waiting 5 seconds for the connection." });
+      }
+    });
+  }
+
+  function handleWorkerMessage(event) {
+    var msg = event.data || {};
+    if (msg.type === "state") {
+      restartCount = 0;
+      state = msg.newState || {};
+      if (typeof config.onState === "function") config.onState(state);
+      if (msg.intermediate) return;
+      clearOneActionTimeout(msg.actionSeq);
+      if (msg.actionSeq !== undefined && pendingActions[msg.actionSeq]) {
+        pendingActions[msg.actionSeq].resolve(state);
+        delete pendingActions[msg.actionSeq];
+      }
+      var shouldInitialize = !initialActionSent && config.initialAction;
+      if (shouldInitialize) {
+        initialActionSent = true;
+        dispatchAction(config.initialAction, {}, "user").catch(function () { markReady(); });
+      } else {
+        markReady();
+      }
+    } else if (msg.type === "storage") {
+      sendStorageOperation(msg);
+    } else if (msg.type === "llm") {
+      sendLlmOperation(msg);
+    } else if (msg.type === "error") {
+      clearOneActionTimeout(msg.actionSeq);
+      if (msg.actionSeq !== undefined) {
+        if (pendingActions[msg.actionSeq]) {
+          pendingActions[msg.actionSeq].reject(new Error(msg.message || "Tool action failed."));
+          delete pendingActions[msg.actionSeq];
+        }
+        reportError(msg.message || "Tool action failed.");
+        return;
+      }
+      restartWorker(msg.message || "Tool worker failed.");
+    }
+  }
+
+  function spawnWorker() {
+    terminateWorker();
+    workerGeneration++;
+    var blob = new Blob([workerProgram(config.logicSource, !!config.allowLlm)], { type: "text/javascript" });
+    var url = URL.createObjectURL(blob);
+    worker = new Worker(url);
+    URL.revokeObjectURL(url);
+    worker.onmessage = handleWorkerMessage;
+    worker.onerror = function (event) {
+      if (event.preventDefault) event.preventDefault();
+      restartWorker(event.message || "Tool worker crashed.");
+    };
+    worker.postMessage({ type: "init", state: state });
+  }
+
+  function dispatchAction(name, args, callerId) {
+    if (!worker || stopped) return Promise.reject(new Error("Tool worker is not running."));
+    actionSeq++;
+    var currentActionSeq = actionSeq;
+    return new Promise(function (resolve, reject) {
+      pendingActions[currentActionSeq] = { resolve: resolve, reject: reject };
+      var timeoutMs = config.allowLlm ? LLM_ACTION_TIMEOUT_MS : ACTION_TIMEOUT_MS;
+      actionTimeouts[currentActionSeq] = setTimeout(function () {
+        restartWorker("Action '" + name + "' timed out after " + Math.round(timeoutMs / 1000) + " seconds.");
+      }, timeoutMs);
+      worker.postMessage({ type: "action", name: name, args: args || {}, callerId: callerId || "user", actionSeq: currentActionSeq });
+    });
+  }
+
+  function handleStorageResult(msg) {
+    if (!worker) return;
+    var localSeq = pendingStorage[msg.seq];
+    if (localSeq === undefined) return;
+    delete pendingStorage[msg.seq];
+    worker.postMessage({ type: "storage_result", seq: localSeq, data: msg.data, error: msg.error });
+  }
+
+  function handleLlmResult(msg) {
+    if (!worker) return;
+    var pending = pendingLlm[msg.requestId];
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    delete pendingLlm[msg.requestId];
+    worker.postMessage({ type: "llm_result", seq: pending.seq, data: msg.data, error: msg.error });
+  }
+
+  function start() {
+    stopped = false;
+    isReady = false;
+    spawnWorker();
+  }
+
+  function stop() {
+    stopped = true;
+    rejectActions("Tool worker stopped.");
+    var waiters = readyWaiters;
+    readyWaiters = [];
+    for (var i = 0; i < waiters.length; i++) waiters[i].reject(new Error("Tool worker stopped."));
+    terminateWorker();
+  }
+
+  function ready() {
+    if (isReady) return Promise.resolve(state);
+    return new Promise(function (resolve, reject) { readyWaiters.push({ resolve: resolve, reject: reject }); });
+  }
+
+  return { start: start, ready: ready, action: dispatchAction, handleStorageResult: handleStorageResult, handleLlmResult: handleLlmResult, stop: stop, getState: function () { return state; } };
+}

package/lib/public/modules/tool-ui-evaluator.js

@@ -0,0 +1,97 @@
+// Pure bounded evaluation for safe declarative Capsule UI.
+
+var MAX_COLLECTION_ITEMS = 500;
+
+export function normalizeOptions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, 100).reduce(function (result, option) {
+    if (typeof option === "string" || typeof option === "number") result.push({ value: option, label: String(option), disabled: false });
+    else if (option && typeof option === "object" && (typeof option.value === "string" || typeof option.value === "number") && typeof option.label === "string") result.push({ value: option.value, label: option.label.slice(0, 500), disabled: option.disabled === true });
+    return result;
+  }, []);
+}
+
+export function normalizeColumns(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, 20).filter(function (column) {
+    return column && typeof column === "object" && typeof column.key === "string" && /^(?:\$(?:state|item)\.)?[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/.test(column.key) && !/(?:__proto__|constructor|prototype)/.test(column.key);
+  }).map(function (column) { return { key: column.key, label: typeof column.label === "string" ? column.label.slice(0, 500) : column.key }; });
+}
+
+export function valueAtPath(state, path, item) {
+  if (!path) return undefined;
+  var source = state;
+  var parts = path.split(".");
+  if (parts[0] === "$item") { source = item; parts.shift(); }
+  else if (parts[0] === "$state") parts.shift();
+  for (var i = 0; i < parts.length; i++) {
+    if (source === null || source === undefined) return undefined;
+    source = source[parts[i]];
+  }
+  return source;
+}
+
+export function resolveValue(value, state, item) {
+  if (value && typeof value === "object" && !Array.isArray(value) && value.$bind) {
+    var bound = valueAtPath(state, value.$bind, item);
+    if (Array.isArray(value.$enum)) return value.$enum.indexOf(bound) !== -1 ? bound : value.fallback !== undefined ? value.fallback : value.$enum[0];
+    return bound === undefined ? value.fallback : bound;
+  }
+  if (typeof value === "string" && (value.indexOf("$item") === 0 || value.indexOf("$state") === 0)) return valueAtPath(state, value, item);
+  if (Array.isArray(value)) return value.map(function (entry) { return resolveValue(entry, state, item); });
+  if (value && typeof value === "object") {
+    var result = {};
+    Object.keys(value).forEach(function (key) { result[key] = resolveValue(value[key], state, item); });
+    return result;
+  }
+  return value;
+}
+
+export function evaluateCondition(condition, state, item) {
+  if (typeof condition === "string") return !!valueAtPath(state, condition, item);
+  if (!condition || typeof condition !== "object") return false;
+  if (condition.all) return condition.all.every(function (entry) { return evaluateCondition(entry, state, item); });
+  if (condition.any) return condition.any.some(function (entry) { return evaluateCondition(entry, state, item); });
+  if (condition.not) return !evaluateCondition(condition.not, state, item);
+  var operators = ["equals", "notEquals", "in", "gt", "gte", "lt", "lte"];
+  for (var i = 0; i < operators.length; i++) {
+    var operator = operators[i];
+    if (!condition[operator]) continue;
+    var rule = condition[operator];
+    var actual = valueAtPath(state, rule.path, item);
+    if (operator === "equals") return actual === rule.value;
+    if (operator === "notEquals") return actual !== rule.value;
+    if (operator === "in") return rule.values.indexOf(actual) !== -1;
+    if (typeof actual !== "number") return false;
+    if (operator === "gt") return actual > rule.value;
+    if (operator === "gte") return actual >= rule.value;
+    if (operator === "lt") return actual < rule.value;
+    if (operator === "lte") return actual <= rule.value;
+  }
+  return false;
+}
+
+export function resolveProps(props, state, item) {
+  var result = {};
+  Object.keys(props || {}).forEach(function (key) { result[key] = resolveValue(props[key], state, item); });
+  return result;
+}
+
+export function collectionView(value, props) {
+  var items = Array.isArray(value) ? value.slice(0, MAX_COLLECTION_ITEMS) : [];
+  var filter = String(props.filter || "").trim().toLocaleLowerCase();
+  if (filter) items = items.filter(function (item) {
+    var candidate = props.filterKey ? valueAtPath(item, props.filterKey, null) : item;
+    return String(candidate === undefined ? "" : candidate).toLocaleLowerCase().indexOf(filter) !== -1;
+  });
+  if (props.sortKey) items.sort(function (left, right) {
+    var a = valueAtPath(left, props.sortKey, null);
+    var b = valueAtPath(right, props.sortKey, null);
+    if (a === b) return 0;
+    var result = a === undefined || a === null ? 1 : b === undefined || b === null ? -1 : a < b ? -1 : 1;
+    return props.sortDirection === "desc" ? -result : result;
+  });
+  var pageSize = Math.max(1, Math.min(100, Number(props.pageSize) || 100));
+  var page = Math.max(1, Number(props.page) || 1);
+  return items.slice((page - 1) * pageSize, page * pageSize);
+}

package/lib/public/modules/tool-ui-tree.js

@@ -0,0 +1,21 @@
+// Pure helpers for inspecting declarative Capsule UI trees.
+
+export function hasToolUiNodeType(node, type) {
+  if (!node || typeof node !== "object") return false;
+  if (node.type === type) return true;
+  var children = Array.isArray(node.children) ? node.children : [];
+  for (var i = 0; i < children.length; i++) {
+    if (hasToolUiNodeType(children[i], type)) return true;
+  }
+  return false;
+}
+
+export function isToolModelAlias(value) {
+  return value === "fast" || value === "standard" || value === "deep";
+}
+
+export function shouldInjectToolLlmStatus(definition) {
+  var permissions = definition && definition.manifest && Array.isArray(definition.manifest.permissions)
+    ? definition.manifest.permissions : [];
+  return permissions.indexOf("llm") !== -1 && !hasToolUiNodeType(definition.uiTree, "model-select");
+}

package/lib/public/modules/user-settings.js

@@ -211,22 +211,20 @@ export function initUserSettings(appCtx) {
     });
   }
 
-  // Mates UI toggle. Default-on, so flipping off hides every Mates
-  // surface in the app (sidebar avatars, DM picker entry, home-hub strip)
-  // via the body.mates-disabled CSS gate. Flipping back on restores the
-  // surface; existing Mate data is never deleted.
+  // This legacy preference now controls only project-local Mate DM entry
+  // points. Home, mentions, creation, debates, and Mate data stay available.
   var matesEnabledToggle = document.getElementById('us-mates-enabled');
   if (matesEnabledToggle) {
     matesEnabledToggle.addEventListener('change', function () {
       var want = !!this.checked;
-      applyMatesEnabledClass(want);
-      store.set({ matesEnabled: want });
+      applyProjectMateDmsClass(want);
+      store.set({ projectMateDmsEnabled: want });
       fetch('/api/user/mates-enabled', {
         method: 'PUT',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ enabled: want }),
       }).then(function (r) { return r.json(); }).then(function (data) {
-        if (data.ok) showToast(data.matesEnabled ? 'Mates on' : 'Mates off');
+        if (data.ok) showToast(data.matesEnabled ? 'Mate DMs shown in projects' : 'Mate DMs hidden in projects');
       }).catch(function () {});
     });
   }
@@ -317,22 +315,17 @@ function stopProp(e) {
   e.stopPropagation();
 }
 
-// Mates UI gate. When the toggle is off we add `mates-disabled` to the
-// body so CSS can hide every Mates surface (sidebar avatars, DM picker
-// "Create a Mate" entry, home-hub mates strip) without touching the
-// underlying data. JS code paths that gate on `store.get('matesEnabled')`
-// also short-circuit so we don't, for example, open the mate wizard if
-// someone fires it programmatically.
-function applyMatesEnabledClass(enabled) {
+// Project-only Mate DM gate. The persisted server field retains its legacy
+// name for migration compatibility, but it no longer disables Mate features.
+function applyProjectMateDmsClass(enabled) {
   if (!document.body) return;
-  document.body.classList.toggle('mates-disabled', !enabled);
+  document.body.classList.toggle('project-mate-dms-disabled', !enabled);
 }
 
-export function isMatesEnabled() {
-  // Default to true if the store hasn't received profile yet — populating
-  // the false state happens after /api/profile resolves, so an undefined
-  // value at boot should not hide Mates UI.
-  return store.get('matesEnabled') !== false;
+export function isProjectMateDmsEnabled() {
+  // Default to true until the profile arrives so boot does not briefly hide
+  // a project shortcut that the persisted preference enables.
+  return store.get('projectMateDmsEnabled') !== false;
 }
 
 function showPinForm() {
@@ -467,12 +460,12 @@ function populateAccount() {
     if (data.mateOnboardingShown) {
       try { localStorage.setItem("clay-mate-onboarding-shown", "1"); } catch (e) {}
     }
-    // Mates UI toggle: default OFF (opt-in); enable only when explicitly true
+    // Project Mate DM shortcuts remain opt-in for legacy profiles.
     var matesOn = data.matesEnabled === true;
     var matesToggle = document.getElementById('us-mates-enabled');
     if (matesToggle) matesToggle.checked = matesOn;
-    store.set({ matesEnabled: matesOn });
-    applyMatesEnabledClass(matesOn);
+    store.set({ projectMateDmsEnabled: matesOn });
+    applyProjectMateDmsClass(matesOn);
     if (data.chatLayout) {
       setChatLayout(data.chatLayout); // update local cache + CSS
     }

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

@@ -158,7 +158,7 @@ export function renderWorkerProposal(msg) {
 
   var summary = document.createElement("p");
   summary.className = "worker-proposal-summary";
-  summary.textContent = msg.summary || "This task can be planned here and executed in a visible Worker session.";
+  summary.textContent = msg.summary || "This task can be planned here and executed in a visible Split Worker session.";
   card.appendChild(summary);
 
   var steps = planSteps(msg.plan);
@@ -225,7 +225,7 @@ export function renderWorkerProposal(msg) {
   var accept = document.createElement("button");
   accept.type = "button";
   accept.className = "worker-proposal-action primary";
-  accept.innerHTML = iconHtml("panel-right-open") + "<span>Run with Worker</span>";
+  accept.innerHTML = iconHtml("panel-right-open") + "<span>Run with Split Worker</span>";
   accept.addEventListener("click", function () { sendDecision(card, true); });
   actions.appendChild(decline);
   actions.appendChild(accept);

package/lib/public/modules/workspace-assignment-card.js

@@ -0,0 +1,149 @@
+import { getWs } from './ws-ref.js';
+import { iconHtml, refreshIcons } from './icons.js';
+
+var pendingFocus = {};
+
+function textElement(tag, className, text) {
+  var element = document.createElement(tag);
+  element.className = className;
+  element.textContent = text || "";
+  return element;
+}
+
+function statusLabel(status) {
+  if (status === "starting") return "Starting";
+  if (status === "running") return "In progress";
+  if (status === "completed") return "Completed";
+  if (status === "failed") return "Failed";
+  if (status === "cancelled") return "Cancelled";
+  if (status === "interrupted") return "Interrupted";
+  return "Approval required";
+}
+
+function sendDecision(assignment, action, surface, context, card, opener) {
+  var ws = getWs();
+  if (!ws || ws.readyState !== 1 || !assignment || assignment.status !== "proposed") return false;
+  pendingFocus[assignment.assignmentId] = opener || null;
+  card.setAttribute("aria-busy", "true");
+  var buttons = card.querySelectorAll("button");
+  for (var i = 0; i < buttons.length; i++) buttons[i].disabled = true;
+  ws.send(JSON.stringify({
+    type: "project_assignment_response",
+    assignmentId: assignment.assignmentId,
+    action: action,
+    surface: surface,
+    sourceProjectSlug: assignment.sourceProjectSlug,
+    sourceSessionRef: assignment.sourceSessionRef,
+    mateId: context && context.mateId || null,
+    sessionId: context && context.sessionId || null,
+    requestId: context && context.requestId || null,
+  }));
+  return true;
+}
+
+export function restoreWorkspaceAssignmentFocus(assignmentId, card) {
+  if (!assignmentId || !pendingFocus[assignmentId] || !card) return false;
+  delete pendingFocus[assignmentId];
+  var focusTarget = card.querySelector(".workspace-assignment-error") || card.querySelector('[role="status"]');
+  if (!focusTarget) return false;
+  focusTarget.tabIndex = -1;
+  requestAnimationFrame(function () { focusTarget.focus({ preventScroll: true }); });
+  return true;
+}
+
+export function createWorkspaceAssignmentCard(assignment, options) {
+  var config = options || {};
+  var followUp = assignment.delivery === "follow_up";
+  var card = document.createElement("section");
+  card.className = "workspace-assignment-card" + (config.home ? " home-workspace-assignment" : "");
+  card.dataset.assignmentId = assignment.assignmentId || "";
+  card.dataset.status = assignment.status || "proposed";
+  card.dataset.delivery = followUp ? "follow_up" : "new_session";
+  card.setAttribute("aria-label", (followUp ? "Project follow-up: " : "Project assignment: ") + (assignment.title || "Untitled assignment"));
+
+  var header = document.createElement("div");
+  header.className = "workspace-assignment-header";
+  var mark = document.createElement("span");
+  mark.className = "workspace-assignment-mark";
+  mark.innerHTML = iconHtml(followUp ? "message-square-plus" : "send");
+  mark.setAttribute("aria-hidden", "true");
+  header.appendChild(mark);
+  var heading = document.createElement("div");
+  heading.className = "workspace-assignment-heading";
+  heading.appendChild(textElement("span", "workspace-assignment-kicker", followUp ? "PROJECT FOLLOW-UP" : "PROJECT ASSIGNMENT"));
+  heading.appendChild(textElement("h3", "workspace-assignment-title", assignment.title || "Untitled assignment"));
+  header.appendChild(heading);
+  var status = textElement("span", "workspace-assignment-status", statusLabel(assignment.status));
+  status.setAttribute("role", "status");
+  header.appendChild(status);
+  card.appendChild(header);
+
+  var targetText = followUp
+    ? "Continue “" + (assignment.targetSessionTitle || "Existing session") + "” in " + (assignment.projectTitle || assignment.projectSlug || "project")
+    : "New private session in " + (assignment.projectTitle || assignment.projectSlug || "project");
+  var target = textElement("p", "workspace-assignment-target", targetText);
+  card.appendChild(target);
+  card.appendChild(textElement("p", "workspace-assignment-task", assignment.task || ""));
+
+  if (assignment.error) {
+    var error = textElement("p", "workspace-assignment-error", assignment.error);
+    error.setAttribute("role", "alert");
+    card.appendChild(error);
+  }
+  if (assignment.resultSummary) card.appendChild(textElement("p", "workspace-assignment-result", assignment.resultSummary));
+
+  var actions = document.createElement("div");
+  actions.className = "workspace-assignment-actions";
+  if (assignment.status === "proposed") {
+    var cancel = textElement("button", "workspace-assignment-action secondary", "Cancel");
+    cancel.type = "button";
+    cancel.setAttribute("aria-label", "Cancel project assignment");
+    cancel.addEventListener("click", function () { sendDecision(assignment, "cancel", config.home ? "home" : "project", config.context, card, cancel); });
+    var approve = textElement("button", "workspace-assignment-action primary", "Approve");
+    approve.type = "button";
+    approve.setAttribute("aria-label", followUp ? "Approve follow-up in " + (assignment.targetSessionTitle || "the target session") : "Approve new session in " + (assignment.projectTitle || assignment.projectSlug || "the target project"));
+    approve.addEventListener("click", function () { sendDecision(assignment, "approve", config.home ? "home" : "project", config.context, card, approve); });
+    actions.appendChild(cancel);
+    actions.appendChild(approve);
+  } else {
+    var resolved = textElement("span", "workspace-assignment-resolved", statusLabel(assignment.status));
+    resolved.setAttribute("role", "status");
+    resolved.tabIndex = -1;
+    actions.appendChild(resolved);
+  }
+  card.appendChild(actions);
+  restoreWorkspaceAssignmentFocus(assignment.assignmentId, card);
+  refreshIcons();
+  return card;
+}
+
+export function showWorkspaceAssignmentError(card, msg) {
+  if (!card) return false;
+  card.removeAttribute("aria-busy");
+  var buttons = card.querySelectorAll("button");
+  for (var i = 0; i < buttons.length; i++) buttons[i].disabled = false;
+  var error = card.querySelector(".workspace-assignment-error");
+  if (!error) {
+    error = textElement("p", "workspace-assignment-error", "");
+    error.setAttribute("role", "alert");
+    card.insertBefore(error, card.querySelector(".workspace-assignment-actions"));
+  }
+  error.textContent = msg.error || "The assignment could not be updated.";
+  error.tabIndex = -1;
+  error.focus({ preventScroll: true });
+  return true;
+}
+
+export function applyHomeWorkspaceAssignment(messages, msg) {
+  var assignment = msg && msg.assignment;
+  if (!assignment || !assignment.assignmentId) return messages;
+  var next = (messages || []).slice();
+  for (var i = 0; i < next.length; i++) {
+    if (next[i].role === "assignment" && next[i].assignment && next[i].assignment.assignmentId === assignment.assignmentId) {
+      next[i] = { role: "assignment", assignment: assignment };
+      return next;
+    }
+  }
+  next.push({ role: "assignment", assignment: assignment });
+  return next;
+}