clay-server 3.8.1 → 4.0.0-beta.1

package/lib/public/modules/home-surface-boot.js

@@ -0,0 +1,68 @@
+// One-shot boot routing after durable Home preferences become available.
+import { store } from './store.js';
+import { rememberHomePrimarySurface } from './home-surface.js';
+
+var initialized = false;
+var resolved = false;
+
+function explicitProjectPath(pathname) {
+  return /^\/p\/[a-z0-9_-]+(?:\/|$)/.test(pathname || "");
+}
+
+export function resolveHomeBootDestination(options) {
+  if (!options || options.surfaceLoaded !== true) return "wait";
+  if (options.paneMode || explicitProjectPath(options.pathname)) return "project";
+  if (options.surface === "project" && options.currentSlug) return "project";
+  if (options.dockLoaded !== true) return "wait";
+  return "home";
+}
+
+function finishPendingShell() {
+  document.body.classList.remove("home-surface-boot-pending");
+  var overlay = document.getElementById("connect-overlay");
+  if (overlay && store.get('connected')) overlay.classList.add("hidden");
+}
+
+function projectRoute(slug) {
+  return slug ? "/p/" + slug + "/" : null;
+}
+
+function settleBoot(state) {
+  if (resolved) return;
+  var destination = resolveHomeBootDestination({
+    surfaceLoaded: state.homeSurfaceLoaded,
+    dockLoaded: state.homeDockPreferenceLoaded,
+    surface: state.homePrimarySurface,
+    currentSlug: state.currentSlug,
+    pathname: location.pathname,
+    paneMode: state.paneMode,
+  });
+  if (destination === "wait") return;
+  resolved = true;
+  if (destination === "project") {
+    rememberHomePrimarySurface("project");
+    if (!explicitProjectPath(location.pathname)) {
+      var route = projectRoute(state.currentSlug);
+      if (route) history.replaceState(null, "", route);
+    }
+    store.set({ homeSurfaceBootResolved: true });
+    finishPendingShell();
+    var input = document.getElementById("input");
+    if (input && !input.disabled) input.focus({ preventScroll: true });
+    return;
+  }
+  store.set({ homeSurfaceBootResolved: true, homeSurfaceRestoreRequested: true });
+  finishPendingShell();
+}
+
+export function initHomeSurfaceBoot() {
+  if (initialized) return;
+  initialized = true;
+  if (!explicitProjectPath(location.pathname) && !store.get('paneMode')) {
+    document.body.classList.add("home-surface-boot-pending");
+    var message = document.getElementById("connect-overlay-msg");
+    if (message) message.textContent = "Restoring your workspace…";
+  }
+  store.subscribe(function (state) { settleBoot(state); });
+  settleBoot(store.snap());
+}

package/lib/public/modules/home-surface.js

@@ -0,0 +1,141 @@
+// Durable, server-backed Home conversation selection state.
+
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+
+function send(message) {
+  var ws = getWs();
+  if (!ws || ws.readyState !== 1) return false;
+  ws.send(JSON.stringify(message));
+  return true;
+}
+
+function normalizeSessions(value) {
+  var source = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  var result = {};
+  var keys = Object.keys(source);
+  for (var i = 0; i < keys.length; i++) {
+    if (typeof source[keys[i]] === "string" && source[keys[i]]) result[keys[i]] = source[keys[i]];
+  }
+  return result;
+}
+
+function normalizePrimarySurface(value) {
+  return value === "home" || value === "project" ? value : null;
+}
+
+function normalizeProjectSlug(value) {
+  return typeof value === "string" && /^[a-z0-9][a-z0-9_-]{0,127}$/.test(value) ? value : null;
+}
+
+function normalizeChatScope(value) {
+  return value === "current" ? "current" : "all";
+}
+
+function normalizeSubSurface(value) {
+  return value === "debates" ? "debates" : "chat";
+}
+
+export function requestHomeSurfacePreference() {
+  return send({ type: "home_surface_get" });
+}
+
+export function updateHomeSurfacePreference(patch) {
+  var state = store.snap();
+  var next = {
+    surface: normalizePrimarySurface(state.homePrimarySurface),
+    projectSlug: normalizeProjectSlug(state.homeSurfaceProjectSlug || state.currentSlug),
+    activeMateId: state.homeChatMateId || null,
+    activeSessionByMate: Object.assign({}, state.homeActiveSessionByMate || {}),
+    sidebarCollapsed: state.homeSidebarCollapsed === true,
+    chatScope: normalizeChatScope(state.homeChatScope),
+    subSurface: normalizeSubSurface(state.homeSubSurface),
+  };
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "surface")) next.surface = normalizePrimarySurface(patch.surface);
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "projectSlug")) next.projectSlug = normalizeProjectSlug(patch.projectSlug);
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "activeMateId")) next.activeMateId = patch.activeMateId;
+  if (patch && patch.activeSessionByMate) next.activeSessionByMate = Object.assign({}, next.activeSessionByMate, patch.activeSessionByMate);
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "sidebarCollapsed")) next.sidebarCollapsed = patch.sidebarCollapsed === true;
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "chatScope")) next.chatScope = normalizeChatScope(patch.chatScope);
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "subSurface")) next.subSurface = normalizeSubSurface(patch.subSurface);
+  store.set({
+    homePrimarySurface: next.surface,
+    homeSurfaceProjectSlug: next.projectSlug,
+    homeActiveSessionByMate: normalizeSessions(next.activeSessionByMate),
+    homeSidebarCollapsed: next.sidebarCollapsed,
+    homeChatScope: next.chatScope,
+    homeSubSurface: next.subSurface,
+  });
+  var outgoing = {};
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "surface")) outgoing.surface = next.surface;
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "projectSlug")) outgoing.projectSlug = next.projectSlug;
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "activeMateId")) outgoing.activeMateId = next.activeMateId;
+  if (patch && patch.activeSessionByMate) outgoing.activeSessionByMate = patch.activeSessionByMate;
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "sidebarCollapsed")) outgoing.sidebarCollapsed = next.sidebarCollapsed;
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "chatScope")) outgoing.chatScope = next.chatScope;
+  if (patch && Object.prototype.hasOwnProperty.call(patch, "subSurface")) outgoing.subSurface = next.subSurface;
+  return send({ type: "home_surface_set", preference: outgoing });
+}
+
+export function rememberHomePrimarySurface(surface, routeProjectSlug) {
+  var normalized = normalizePrimarySurface(surface);
+  if (!normalized) return false;
+  var projectSlug = normalizeProjectSlug(routeProjectSlug || store.get('currentSlug'));
+  if (store.get('homePrimarySurface') === normalized && store.get('homeSurfaceProjectSlug') === projectSlug) return false;
+  store.set({ homeSurfaceIntent: normalized, homePrimarySurface: normalized, homeSurfaceProjectSlug: projectSlug });
+  return updateHomeSurfacePreference({ surface: normalized, projectSlug: projectSlug });
+}
+
+export function rememberHomeMate(mateId) {
+  if (!mateId) return;
+  if (store.get('homePreferredMateId') === mateId) return;
+  store.set({ homePreferredMateId: mateId });
+  updateHomeSurfacePreference({ activeMateId: mateId });
+}
+
+export function rememberHomeSession(mateId, sessionId) {
+  if (!mateId || !sessionId) return;
+  if ((store.get('homeActiveSessionByMate') || {})[mateId] === sessionId && store.get('homePreferredMateId') === mateId) return;
+  var patch = {};
+  patch[mateId] = sessionId;
+  updateHomeSurfacePreference({ activeMateId: mateId, activeSessionByMate: patch });
+}
+
+export function forgetHomeSession(mateId) {
+  if (!mateId) return;
+  var sessions = Object.assign({}, store.get('homeActiveSessionByMate') || {});
+  delete sessions[mateId];
+  store.set({ homeActiveSessionByMate: sessions, homeChatSessionId: null });
+  var patch = {};
+  patch[mateId] = "";
+  send({ type: "home_surface_set", preference: { activeSessionByMate: patch } });
+}
+
+export function handleHomeSurfaceState(msg) {
+  if (!msg || msg.error || !msg.preference) {
+    if (!store.get('homeSurfaceLoaded')) store.set({ homeSurfaceLoaded: true });
+    return;
+  }
+  var preference = msg.preference;
+  var wasLoaded = store.get('homeSurfaceLoaded');
+  var intent = normalizePrimarySurface(store.get('homeSurfaceIntent'));
+  var intendedProject = normalizeProjectSlug(store.get('homeSurfaceProjectSlug'));
+  var savedSurface = normalizePrimarySurface(preference.surface);
+  var savedProject = normalizeProjectSlug(preference.projectSlug);
+  var intentConfirmed = !!intent && intent === savedSurface && intendedProject === savedProject;
+  var update = {
+    homeSurfaceLoaded: true,
+    homePrimarySurface: intent || savedSurface,
+    homeSurfaceProjectSlug: intent ? intendedProject : savedProject,
+    homeActiveSessionByMate: normalizeSessions(preference.activeSessionByMate),
+    homeSidebarCollapsed: preference.sidebarCollapsed === true,
+    homeChatScope: normalizeChatScope(preference.chatScope),
+    homeSubSurface: normalizeSubSurface(preference.subSurface),
+  };
+  if (intentConfirmed) update.homeSurfaceIntent = null;
+  if (!wasLoaded) {
+    update.homePreferredMateId = store.get('homePreferredMateId') || preference.activeMateId || store.get('homeChatMateId') || null;
+  }
+  store.set(update);
+  if (intent && !intentConfirmed) send({ type: "home_surface_set", preference: { surface: intent, projectSlug: intendedProject } });
+}

package/lib/public/modules/home-tools.js

@@ -0,0 +1,271 @@
+// home-tools.js - Installed tool registration, rendering, and runtime glue.
+
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { registerDockTool, unregisterDockTool, renderDock, pulseDockTool, markDockToolChanged, reconcileDockActiveTool } from './home-dock.js';
+import { renderToolUi, disposeToolUi, getControlCatalog } from './tool-renderer.js';
+import { createToolRuntime } from './tool-runtime.js';
+import { showToast } from './utils.js';
+import { createToolLlmStatus, initialToolLlmAlias } from './tool-llm-status.js';
+import { isToolModelAlias, shouldInjectToolLlmStatus } from './tool-ui-tree.js';
+import { mountCapsuleHostControls, disposeCapsuleHostControls, handleToolSourceState as applyToolSourceState, handleToolMateAccessState as applyToolMateAccessState } from './home-capsule-source.js';
+
+var definitions = Object.create(null);
+var runtimes = Object.create(null);
+var registeredIds = Object.create(null);
+var errorSurfaces = Object.create(null);
+var displays = Object.create(null);
+var llmStatuses = Object.create(null);
+
+export function requestTools() {
+  var ws = getWs();
+  if (ws && ws.readyState === 1) {
+    store.set({ homeToolRegistryLoaded: false });
+    ws.send(JSON.stringify({ type: "tools_list" }));
+  }
+}
+
+function stopRuntime(toolId) {
+  if (runtimes[toolId]) runtimes[toolId].stop();
+  if (llmStatuses[toolId]) llmStatuses[toolId].dispose();
+  if (displays[toolId]) disposeToolUi(displays[toolId]);
+  delete runtimes[toolId];
+  delete errorSurfaces[toolId];
+  delete displays[toolId];
+  delete llmStatuses[toolId];
+  disposeCapsuleHostControls(toolId);
+}
+
+function showRuntimeError(toolId, message) {
+  var surface = errorSurfaces[toolId];
+  if (!surface) return;
+  surface.textContent = message;
+  surface.classList.remove("hidden");
+}
+
+function renderRuntimeState(toolId, state) {
+  var definition = definitions[toolId];
+  var display = displays[toolId];
+  if (!definition || !display || !runtimes[toolId]) return;
+  renderToolUi(toolId, definition.uiTree, state, function (actionName, args) {
+    runtimes[toolId].action(actionName, args, "user").catch(function () {});
+  }, display);
+}
+
+function ensureRuntime(toolId) {
+  if (runtimes[toolId]) return runtimes[toolId];
+  var definition = definitions[toolId];
+  if (!definition) throw new Error("Tool is not installed on this home screen.");
+  if (definition.manifest.runtime === "server") throw new Error("Server-runtime capsules do not run in a browser worker.");
+  displays[toolId] = document.createElement("div");
+  displays[toolId].className = "home-tool-display";
+  var runtime = createToolRuntime({
+    toolId: toolId,
+    logicSource: definition.logicSource,
+    initialAction: definition.manifest.initialAction || null,
+    allowLlm: (definition.manifest.permissions || []).indexOf("llm") !== -1,
+    onLlmRequest: function (alias) {
+      if (llmStatuses[toolId]) llmStatuses[toolId].setAlias(alias);
+    },
+    onState: function (state) {
+      var error = errorSurfaces[toolId];
+      if (error) error.classList.add("hidden");
+      renderRuntimeState(toolId, state);
+    },
+    onError: function (message) { showRuntimeError(toolId, message); },
+  });
+  runtimes[toolId] = runtime;
+  runtime.start();
+  return runtime;
+}
+
+function mountTool(toolId, contentEl, chromeEl) {
+  var definition = definitions[toolId];
+  if (!definition) return;
+  var root = document.createElement("div");
+  root.className = "home-tool-root";
+  mountCapsuleHostControls(toolId, definition, chromeEl, root);
+  var permissions = definition.manifest.permissions || [];
+  if (permissions.indexOf("llm") !== -1 && shouldInjectToolLlmStatus(definition)) {
+    if (llmStatuses[toolId]) llmStatuses[toolId].dispose();
+    llmStatuses[toolId] = createToolLlmStatus(initialToolLlmAlias(definition.manifest));
+    llmStatuses[toolId].element.dataset.capsuleRuntimeSurface = "true";
+    root.appendChild(llmStatuses[toolId].element);
+  }
+  var error = document.createElement("div");
+  error.className = "home-tool-error hidden";
+  error.dataset.capsuleRuntimeSurface = "true";
+  root.appendChild(error);
+  contentEl.appendChild(root);
+  errorSurfaces[toolId] = error;
+  if (definition.manifest.runtime === "server") {
+    var serverDisplay = document.createElement("div");
+    serverDisplay.className = "home-tool-display";
+    serverDisplay.dataset.capsuleRuntimeSurface = "true";
+    root.appendChild(serverDisplay);
+    renderToolUi(toolId, definition.uiTree, {}, function () {}, serverDisplay);
+    return;
+  }
+  var runtime = ensureRuntime(toolId);
+  displays[toolId].dataset.capsuleRuntimeSurface = "true";
+  root.appendChild(displays[toolId]);
+  if (runtime.getState() !== null) renderRuntimeState(toolId, runtime.getState());
+}
+
+function registerDefinition(definition) {
+  if (!definition || !definition.manifest || !definition.manifest.id) return;
+  var toolId = definition.manifest.id;
+  definitions[toolId] = definition;
+  registeredIds[toolId] = true;
+  var dockTool = {
+    id: toolId,
+    name: definition.manifest.name,
+    lucideIcon: definition.manifest.lucideIcon || "box",
+    render: function (contentEl, chromeEl) { mountTool(toolId, contentEl, chromeEl); },
+    onChromeHide: function () { disposeCapsuleHostControls(toolId); },
+    onHide: function () { stopRuntime(toolId); },
+  };
+  registerDockTool(dockTool);
+}
+
+function syncStore() {
+  var tools = [];
+  var ids = Object.keys(definitions);
+  for (var i = 0; i < ids.length; i++) tools.push(definitions[ids[i]]);
+  store.set({ installedTools: tools });
+}
+
+export function handleToolsState(msg) {
+  var completeSync = !msg.requestedToolId;
+  var incoming = msg.tools || [];
+  var validIncoming = [];
+  var scanErrors = [];
+  for (var ei = 0; ei < incoming.length; ei++) {
+    if (incoming[ei] && incoming[ei].error) scanErrors.push(incoming[ei]);
+    else if (incoming[ei] && incoming[ei].manifest) validIncoming.push(incoming[ei]);
+  }
+  incoming = validIncoming;
+  store.set({ toolScanErrors: scanErrors });
+  if (scanErrors.length > 0) showToast("One or more capsule folders could not be loaded.", "error");
+  if (completeSync) {
+    var previousIds = Object.keys(registeredIds);
+    var incomingIds = Object.create(null);
+    for (var ii = 0; ii < incoming.length; ii++) incomingIds[incoming[ii].manifest.id] = true;
+    for (var pi = 0; pi < previousIds.length; pi++) {
+      if (incomingIds[previousIds[pi]]) continue;
+      stopRuntime(previousIds[pi]);
+      delete definitions[previousIds[pi]];
+      delete registeredIds[previousIds[pi]];
+      unregisterDockTool(previousIds[pi]);
+    }
+  }
+  for (var i = 0; i < incoming.length; i++) registerDefinition(incoming[i]);
+  syncStore();
+  if (completeSync) store.set({ homeToolRegistryLoaded: true });
+  if (completeSync && reconcileDockActiveTool()) return;
+  renderDock();
+}
+
+export function handleToolInstalled(msg) {
+  if (msg.tool && msg.tool.manifest && definitions[msg.tool.manifest.id]) stopRuntime(msg.tool.manifest.id);
+  registerDefinition(msg.tool);
+  syncStore();
+  renderDock();
+  markDockToolChanged(msg.tool && msg.tool.manifest ? msg.tool.manifest.id : null);
+}
+
+export function handleToolSourceState(msg) {
+  applyToolSourceState(msg);
+}
+
+export function handleToolMateAccessState(msg) {
+  if (msg.ok && msg.metadata && definitions[msg.toolId]) {
+    definitions[msg.toolId].metadata = msg.metadata;
+    syncStore();
+  }
+  applyToolMateAccessState(msg);
+}
+
+export function handleToolRemoved(msg) {
+  stopRuntime(msg.toolId);
+  delete definitions[msg.toolId];
+  delete registeredIds[msg.toolId];
+  unregisterDockTool(msg.toolId);
+  syncStore();
+  renderDock();
+}
+
+export function handleToolStorageResult(msg) {
+  if (runtimes[msg.toolId]) runtimes[msg.toolId].handleStorageResult(msg);
+}
+
+export function handleToolLlmResult(msg) {
+  if (runtimes[msg.toolId]) runtimes[msg.toolId].handleLlmResult(msg);
+}
+
+export function handleToolsError(msg) {
+  if (msg.toolId && msg.requestId && runtimes[msg.toolId]) {
+    runtimes[msg.toolId].handleLlmResult({ requestId: msg.requestId, error: msg.message });
+    return;
+  }
+  if (msg.toolId && msg.seq !== undefined && runtimes[msg.toolId]) {
+    runtimes[msg.toolId].handleStorageResult({ seq: msg.seq, error: msg.message });
+    return;
+  }
+  if (msg.toolId) showRuntimeError(msg.toolId, msg.message || "Tool operation failed.");
+  else showToast(msg.message || "Tool operation failed.", "error");
+}
+
+export function getToolRuntimeState(toolId) {
+  return runtimes[toolId] ? runtimes[toolId].getState() : null;
+}
+
+function replyControl(requestId, data, error) {
+  var ws = getWs();
+  if (!ws || ws.readyState !== 1) return;
+  ws.send(JSON.stringify({
+    type: "tool_control_response",
+    requestId: requestId,
+    data: data || null,
+    error: error || null,
+  }));
+}
+
+export function handleToolControlRequest(msg) {
+  Promise.resolve().then(async function () {
+    var definition = definitions[msg.toolId];
+    if (!definition) throw new Error("Tool is not installed on this home screen.");
+    var runtime = ensureRuntime(msg.toolId);
+    await runtime.ready();
+    var payload = msg.payload || {};
+    var state;
+    if (msg.kind === "snapshot") {
+      state = runtime.getState();
+    } else if (msg.kind === "act") {
+      state = await runtime.action(payload.actionId, payload.args || {}, msg.callerId);
+      pulseDockTool(msg.toolId);
+    } else if (msg.kind === "set") {
+      var control = getControlCatalog(msg.toolId)[payload.controlId];
+      if (!control) throw new Error("Unknown control '" + payload.controlId + "'.");
+      if (!control.action) throw new Error("Control '" + payload.controlId + "' does not expose an action.");
+      if (control.type === "model-select" && !isToolModelAlias(payload.value)) {
+        throw new Error("Model controls accept only fast, standard, or deep.");
+      }
+      state = await runtime.action(control.action, {
+        value: payload.value,
+        controlId: payload.controlId,
+        bind: control.bind,
+      }, msg.callerId);
+      pulseDockTool(msg.toolId);
+    } else {
+      throw new Error("Unknown tool control request kind '" + msg.kind + "'.");
+    }
+    replyControl(msg.requestId, {
+      state: state,
+      controls: getControlCatalog(msg.toolId),
+      ui: definition.uiTree,
+    }, null);
+  }).catch(function (error) {
+    replyControl(msg.requestId, null, error && error.message ? error.message : "Tool control failed.");
+  });
+}

package/lib/public/modules/markdown.js

@@ -35,14 +35,62 @@ export function updateMermaidTheme(vars) {
 
 var mermaidIdCounter = 0;
 
+function normalizeAdjacentEmphasis(text) {
+  var parts = text.split(/(```[\s\S]*?```|~~~[\s\S]*?~~~|`[^`\n]*`)/g);
+  for (var i = 0; i < parts.length; i++) {
+    if (/^(?:```|~~~|`)/.test(parts[i])) continue;
+    parts[i] = parts[i].replace(/(\*{1,3})([^*\n]+?)\1(?=[\p{L}\p{N}])/gu, "$1$2$1<wbr>");
+  }
+  return parts.join("");
+}
+
 export function renderMarkdown(text) {
   // Normalize smart quotes so bold/italic delimiters flanking them parse correctly
-  var normalized = text
+  var normalized = normalizeAdjacentEmphasis(text
     .replace(/[\u201C\u201D]/g, '"')
-    .replace(/[\u2018\u2019]/g, "'");
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/\*\*[ \t]+([^*\n]+?)[ \t]+\*\*/g, "**$1**"));
   return DOMPurify.sanitize(marked.parse(normalized));
 }
 
+export function enhanceClaySessionLinks(root) {
+  if (!root || typeof document === "undefined") return;
+  var walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  var nodes = [];
+  var node;
+  while ((node = walker.nextNode())) {
+    if (!node.parentElement || node.parentElement.closest("code, pre, a, button")) continue;
+    if (/\[clayos\/session:[A-Za-z0-9_-]{24}(?:\s+[\u2014-]\s+[^\]\n]{1,80})?\]/.test(node.nodeValue || "")) nodes.push(node);
+  }
+  for (var i = 0; i < nodes.length; i++) {
+    var text = nodes[i].nodeValue || "";
+    var pattern = /\[clayos\/(session:[A-Za-z0-9_-]{24})(?:\s+[\u2014-]\s+([^\]\n]{1,80}))?\]/g;
+    var fragment = document.createDocumentFragment();
+    var offset = 0;
+    var match;
+    while ((match = pattern.exec(text))) {
+      fragment.appendChild(document.createTextNode(text.slice(offset, match.index)));
+      var button = document.createElement("button");
+      button.type = "button";
+      button.className = "clayos-session-link";
+      button.dataset.sessionRef = match[1];
+      button.setAttribute("aria-label", "Open session" + (match[2] ? " from " + match[2].trim() : ""));
+      var label = document.createElement("span");
+      label.textContent = "Session";
+      button.appendChild(label);
+      if (match[2]) {
+        var meta = document.createElement("small");
+        meta.textContent = match[2].trim();
+        button.appendChild(meta);
+      }
+      fragment.appendChild(button);
+      offset = pattern.lastIndex;
+    }
+    fragment.appendChild(document.createTextNode(text.slice(offset)));
+    nodes[i].parentNode.replaceChild(fragment, nodes[i]);
+  }
+}
+
 /**
  * Parse Unicode emojis inside an element into Twemoji SVG images.
  * Used only for UI chrome (icon strip, emoji picker, title bar) where

package/lib/public/modules/mate-management.js

@@ -0,0 +1,86 @@
+// Shared Mate profile and removal flows used by project and Home surfaces.
+
+import { getWs } from './ws-ref.js';
+import { showMateProfilePopover } from './profile.js';
+import { showConfirm } from './app-misc.js';
+import { iconHtml, refreshIcons } from './icons.js';
+
+var mateMenu = null;
+
+function send(message) {
+  var ws = getWs();
+  if (ws && ws.readyState === 1) ws.send(JSON.stringify(message));
+}
+
+export function editMateProfile(anchorEl, mate) {
+  if (!anchorEl || !mate || mate.primary) return;
+  showMateProfilePopover(anchorEl, mate, function (updates) {
+    send({ type: "mate_update", mateId: mate.id, updates: updates });
+  });
+}
+
+export function confirmMateRemoval(anchorEl, mate, onRemoved) {
+  if (!anchorEl || !mate || mate.primary) return;
+  showConfirm(
+    mate.builtinKey ? "Remove this mate? You can restore it from the home switcher." : "Delete this mate permanently?",
+    function () {
+      if (onRemoved) onRemoved();
+      send({ type: "mate_delete", mateId: mate.id });
+    },
+    mate.builtinKey ? "Remove" : "Delete",
+    true
+  );
+}
+
+export function closeMateManagementMenu() {
+  if (mateMenu) mateMenu.remove();
+  mateMenu = null;
+  document.removeEventListener("click", handleMateMenuOutside, true);
+}
+
+function handleMateMenuOutside(event) {
+  if (mateMenu && !mateMenu.contains(event.target)) closeMateManagementMenu();
+}
+
+export function showMateManagementMenu(anchorEl, mate, options) {
+  if (!anchorEl || !mate || mate.primary) return;
+  options = options || {};
+  closeMateManagementMenu();
+  if (options.beforeOpen) options.beforeOpen();
+  var menu = document.createElement("div");
+  menu.className = "project-ctx-menu";
+  var edit = document.createElement("button");
+  edit.className = "project-ctx-item";
+  edit.innerHTML = iconHtml("edit-2") + " <span>Edit Profile</span>";
+  edit.addEventListener("click", function (event) {
+    event.stopPropagation();
+    closeMateManagementMenu();
+    editMateProfile(anchorEl, mate);
+  });
+  var remove = document.createElement("button");
+  remove.className = "project-ctx-item project-ctx-delete";
+  remove.innerHTML = iconHtml(mate.builtinKey ? "minus-circle" : "trash-2")
+    + " <span>" + (mate.builtinKey ? "Remove mate" : "Delete mate") + "</span>";
+  remove.addEventListener("click", function (event) {
+    event.stopPropagation();
+    closeMateManagementMenu();
+    confirmMateRemoval(anchorEl, mate, options.onRemoved);
+  });
+  menu.appendChild(edit);
+  menu.appendChild(remove);
+  document.body.appendChild(menu);
+  mateMenu = menu;
+  refreshIcons();
+  requestAnimationFrame(function () {
+    var rect = anchorEl.getBoundingClientRect();
+    menu.style.position = "fixed";
+    menu.style.left = (rect.right + 6) + "px";
+    menu.style.top = rect.top + "px";
+    var menuRect = menu.getBoundingClientRect();
+    if (menuRect.right > window.innerWidth - 8) menu.style.left = (rect.left - menuRect.width - 6) + "px";
+    if (menuRect.bottom > window.innerHeight - 8) menu.style.top = (window.innerHeight - menuRect.height - 8) + "px";
+  });
+  setTimeout(function () {
+    document.addEventListener("click", handleMateMenuOutside, true);
+  }, 0);
+}

package/lib/public/modules/mate-wizard.js

@@ -102,13 +102,6 @@ export function initMateWizard(sendWs, onMateCreated) {
 }
 
 export function openMateWizard() {
-  // Defensive: if the user has turned off the Mates UI in User Settings,
-  // do not open the wizard even if it gets fired programmatically (e.g.
-  // via a stale event handler). The CSS gate hides the entry point but
-  // we still short-circuit here so JS calls become no-ops.
-  if (typeof document !== "undefined" && document.body && document.body.classList.contains("mates-disabled")) {
-    return;
-  }
   mateWizardStep = 0;
   mateWizardData = {
     relationship: null,