agent-relay-server 0.6.0 → 0.7.0

package/public/dashboard/computed.js

@@ -0,0 +1,693 @@
+import { HUMAN_AGENT_ID, CLOSED_TASK_STATUSES, WAITING_TASK_STATUSES, STATUS_SORT_ORDER } from "./constants.js";
+import {
+  isBuiltInAgent, isChannelAgent, agentType, isAgentStale, visibleAgents, messageBody,
+  messageLooksLikeQuestion, inboxPeer, isHumanInboundMessage, isUnreadHumanMessage,
+  maxMessageId, readCursorForPeer, draftForPeer, isClaimableTaskWaiting,
+  isClaimableMessageWaiting, targetMatchesAgent, messageMatchesChannel,
+  activityItem, toTimestamp,
+} from "./utils.js";
+import { agentAttention } from "./display.js";
+import { baseUrl } from "./api.js";
+
+export function createComputedDescriptors() {
+  return {
+    onlineCount: { get: getOnlineCount },
+    busyAgentCount: { get: getBusyAgentCount },
+    hiddenBuiltInAgentCount: { get: getHiddenBuiltInAgentCount },
+    sortedAgents: { get: getSortedAgents },
+    pairsByAgentId: { get: getPairsByAgentId },
+    selectedAgentDetail: { get: getSelectedAgentDetail },
+    agentDetailMessages: { get: getAgentDetailMessages },
+    selectedChannelDetail: { get: getSelectedChannelDetail },
+    channelDetailMessages: { get: getChannelDetailMessages },
+    pairMessagePair: { get: getPairMessagePair },
+    allInboxThreads: { get: getAllInboxThreads },
+    inboxThreads: { get: getInboxThreads },
+    selectedInboxThreadData: { get: getSelectedInboxThreadData },
+    selectedInboxMessages: { get: getSelectedInboxMessages },
+    inboxComposeTargetOptions: { get: getInboxComposeTargetOptions },
+    attentionSummary: { get: getAttentionSummary },
+    attentionAgentCount: { get: getAttentionAgentCount },
+    activityItems: { get: getActivityItems },
+    workQueueItems: { get: getWorkQueueItems },
+    channelCards: { get: getChannelCards },
+    connectorCards: { get: getConnectorCards },
+    integrationCards: { get: getIntegrationCards },
+    openPairCount: { get: getOpenPairCount },
+    filteredMessages: { get: getFilteredMessages },
+    groupedMessages: { get: getGroupedMessages },
+    filteredTasks: { get: getFilteredTasks },
+    composeAgents: { get: getComposeAgents },
+    uniqueLabels: { get: getUniqueLabels },
+    uniqueCaps: { get: getUniqueCaps },
+    uniqueTags: { get: getUniqueTags },
+    healthIssues: { get: getHealthIssues },
+    healthDiagnostics: { get: getHealthDiagnostics },
+    commandPaletteItems: { get: getCommandPaletteItems },
+    spawnAvailableProviders: { get: getSpawnAvailableProviders },
+    onlineOrchestratorCount: { get: getOnlineOrchestratorCount },
+    readyChannelCount: { get: getReadyChannelCount },
+  };
+}
+
+function getSpawnAvailableProviders() {
+  const orch = this.orchestrators.find((o) => o.id === this.spawnOrchId);
+  return orch ? orch.providers : ["claude", "codex"];
+}
+
+function getOnlineCount() {
+  return visibleAgents(this).filter((agent) => agent.status !== "offline").length;
+}
+
+function getBusyAgentCount() {
+  return this.agents.filter((agent) => agent.status === "busy").length;
+}
+
+function getHiddenBuiltInAgentCount() {
+  return this.showBuiltIns ? 0 : this.agents.filter(isBuiltInAgent).length;
+}
+
+function getSortedAgents() {
+  let list = visibleAgents(this);
+  list = applyAgentPreset(this, list);
+  if (!this.showOffline) list = list.filter((agent) => agent.status !== "offline");
+  if (this.agentStatusFilter === "starting") {
+    list = list.filter((agent) => agent.status !== "offline" && !agent.ready);
+  } else if (this.agentStatusFilter) {
+    list = list.filter((agent) => agent.status === this.agentStatusFilter);
+  }
+  if (this.agentTagFilter) {
+    list = list.filter((agent) => (agent.tags || []).includes(this.agentTagFilter));
+  }
+  const dir = this.agentSortDir === "desc" ? -1 : 1;
+  return list.sort((a, b) => compareAgents(this, a, b) * dir);
+}
+
+function getPairsByAgentId() {
+  const byAgent = {};
+  for (const pair of this.pairs || []) {
+    if (pair.requesterId) byAgent[pair.requesterId] = pair;
+    if (pair.targetId) byAgent[pair.targetId] = pair;
+  }
+  return byAgent;
+}
+
+function getSelectedAgentDetail() {
+  if (!this.agentDetailId) return null;
+  return this.agentsById[this.agentDetailId] || null;
+}
+
+function getAgentDetailMessages() {
+  if (!this.agentDetailId) return [];
+  return this.messages
+    .filter((msg) => msg.from === this.agentDetailId || msg.to === this.agentDetailId)
+    .slice()
+    .sort((a, b) => b.id - a.id)
+    .slice(0, 8);
+}
+
+function getSelectedChannelDetail() {
+  if (!this.channelDetailId) return null;
+  return (this.channels || []).find((channel) => channel.id === this.channelDetailId) || null;
+}
+
+function getChannelDetailMessages() {
+  const channel = this.selectedChannelDetail;
+  if (!channel) return [];
+  return this.messages
+    .filter((msg) => messageMatchesChannel(msg, channel))
+    .slice()
+    .sort((a, b) => b.id - a.id)
+    .slice(0, 8);
+}
+
+function getPairMessagePair() {
+  return this.pairs.find((pair) => pair.id === this.pairMessage.pairId) || null;
+}
+
+function getAllInboxThreads() {
+  return buildInboxThreads(this);
+}
+
+function getInboxThreads() {
+  const search = this.inboxSearch.trim().toLowerCase();
+  const filtered = this.allInboxThreads.filter((thread) => {
+    if (!this.inboxShowArchived && thread.archived) return false;
+    if (search && !threadMatchesSearch(this, thread, search)) return false;
+    return true;
+  });
+  return sortInboxThreads(filtered, this.inboxSort, this.inboxSortDir);
+}
+
+function sortInboxThreads(threads, sort, dir) {
+  const mul = dir === "asc" ? 1 : -1;
+  return [...threads].sort((a, b) => {
+    switch (sort) {
+      case "updated":
+        return mul * ((b.lastMessage?.id || 0) - (a.lastMessage?.id || 0));
+      case "created": {
+        const aFirst = a.messages[0]?.id || 0;
+        const bFirst = b.messages[0]?.id || 0;
+        return mul * (bFirst - aFirst);
+      }
+      case "name":
+        return mul * String(a.peer).localeCompare(String(b.peer));
+      case "attention":
+      default:
+        return compareInboxThreads(a, b) * mul;
+    }
+  });
+}
+
+function buildInboxThreads(vm) {
+  const threads = new Map();
+  for (const msg of vm.messages) {
+    const peer = inboxPeer(msg);
+    if (!peer) continue;
+    if (!threads.has(peer)) threads.set(peer, { id: peer, peer, messages: [], lastMessage: null });
+    threads.get(peer).messages.push(msg);
+  }
+  for (const thread of threads.values()) {
+    thread.messages.sort((a, b) => a.id - b.id);
+    thread.lastMessage = thread.messages[thread.messages.length - 1] || null;
+    thread.attention = getThreadAttention(vm, thread);
+    thread.archived = isInboxThreadArchived(vm, thread);
+    thread.draft = draftForPeer(vm, thread.peer);
+  }
+  return [...threads.values()].sort(compareInboxThreads);
+}
+
+function threadMatchesSearch(vm, thread, search) {
+  const haystack = [
+    vm.displayTarget(thread.peer),
+    thread.peer,
+    ...thread.messages.flatMap((msg) => [msg.subject || "", messageBody(msg) || "", msg.channel || "", vm.displayTarget(msg.from), vm.displayTarget(msg.to)]),
+  ].join("\n").toLowerCase();
+  return haystack.includes(search);
+}
+
+function isInboxThreadArchived(vm, thread) {
+  const archivedAtId = Number(vm.inboxArchivedThreads?.[thread.peer] || 0);
+  return Boolean(thread.lastMessage?.id && archivedAtId >= thread.lastMessage.id);
+}
+
+function compareInboxThreads(a, b) {
+  const scoreDelta = (b.attention?.score || 0) - (a.attention?.score || 0);
+  if (scoreDelta !== 0) return scoreDelta;
+  return (b.lastMessage?.id || 0) - (a.lastMessage?.id || 0);
+}
+
+function getSelectedInboxThreadData() {
+  if (!this.selectedInboxThread) return null;
+  return this.inboxThreads.find((thread) => thread.id === this.selectedInboxThread) || null;
+}
+
+function getSelectedInboxMessages() {
+  return this.selectedInboxThreadData?.messages || [];
+}
+
+function getInboxComposeTargetOptions() {
+  if (this.inboxCompose.toMode === "tag") return this.uniqueTags.map((value) => ({ value, label: "#" + value }));
+  if (this.inboxCompose.toMode === "cap") return this.uniqueCaps.map((value) => ({ value, label: value }));
+  return this.composeAgents.map((agent) => ({ value: agent.id, label: `${this.displayName(agent)} [${agent.id.slice(-6)}]` }));
+}
+
+function getAttentionSummary() {
+  const threads = this.allInboxThreads.filter((thread) => !thread.archived);
+  const pendingPairInvites = this.pairs.filter((pair) => pair.status === "pending").length;
+  const claimableTasks = countClaimableWaiting(this);
+  const unreadInbox = threads.reduce((sum, thread) => sum + (thread.attention?.unread || 0), 0);
+  const agentQuestions = threads.filter((thread) => thread.attention?.agentQuestion).length;
+  return {
+    unreadInbox,
+    needsHumanResponse: 0,
+    agentQuestions,
+    pendingPairInvites,
+    claimableTasks,
+    total: unreadInbox + agentQuestions + pendingPairInvites + claimableTasks,
+  };
+}
+
+function getAttentionAgentCount() {
+  return this.sortedAgents.filter((agent) => this.agentAttention(agent).total > 0).length;
+}
+
+function getActivityItems() {
+  const items = [
+    ...serverActivityItems(this),
+    ...messageActivityItems(this),
+    ...pairActivityItems(this),
+    ...taskActivityItems(this),
+    ...operatorActivityItems(this),
+  ].filter((item) => item.ts);
+
+  const filter = this.activityFilter;
+  const filtered = filter ? items.filter((item) => item.kind === filter) : items;
+  return filtered.sort((a, b) => b.ts - a.ts).slice(0, 150);
+}
+
+function getWorkQueueItems() {
+  const taskItems = (this.tasks || [])
+    .filter((task) => !CLOSED_TASK_STATUSES.has(task.status))
+    .map((task) => ({
+      id: "task-" + task.id,
+      sourceType: "task",
+      title: task.title,
+      body: task.body,
+      severity: task.severity || "info",
+      status: task.status,
+      owner: task.claimedBy || "",
+      target: task.target,
+      source: task.source,
+      channel: task.channel || "",
+      updatedAt: task.updatedAt || task.createdAt,
+      createdAt: task.createdAt,
+      claimable: isClaimableTaskWaiting(task),
+      task,
+    }));
+
+  const messageItems = (this.messages || [])
+    .filter(isClaimableMessageWaiting)
+    .map((msg) => ({
+      id: "message-" + msg.id,
+      sourceType: "message",
+      title: msg.subject || "Claimable message #" + msg.id,
+      body: messageBody(msg),
+      severity: "warning",
+      status: msg.claimedBy ? "claimed" : "open",
+      owner: msg.claimedBy || "",
+      target: msg.to,
+      source: "message",
+      channel: msg.channel || "",
+      updatedAt: msg.claimedAt || msg.createdAt,
+      createdAt: msg.createdAt,
+      claimable: isClaimableMessageWaiting(msg),
+      message: msg,
+    }));
+
+  return [...taskItems, ...messageItems].sort(compareWorkQueueItems);
+}
+
+function compareWorkQueueItems(a, b) {
+  const claimableDelta = Number(b.claimable) - Number(a.claimable);
+  if (claimableDelta !== 0) return claimableDelta;
+  const severityOrder = { critical: 0, warning: 1, info: 2 };
+  const severityDelta = (severityOrder[a.severity] ?? 9) - (severityOrder[b.severity] ?? 9);
+  if (severityDelta !== 0) return severityDelta;
+  return toTimestamp(a.updatedAt) - toTimestamp(b.updatedAt);
+}
+
+function serverActivityItems(vm) {
+  return (vm.activityEvents || []).map((event) => activityItem({
+    id: "activity-" + event.id,
+    clientId: event.clientId,
+    kind: event.kind,
+    ts: toTimestamp(event.createdAt),
+    icon: event.icon,
+    title: event.title,
+    body: event.body,
+    meta: event.meta,
+    view: event.view,
+    peer: event.peer,
+    messageId: event.messageId,
+    pairId: event.pairId,
+    taskId: event.taskId,
+    agentId: event.agentId,
+  }));
+}
+
+function messageActivityItems(vm) {
+  return (vm.messages || []).flatMap((msg) => {
+    const ts = toTimestamp(msg.createdAt);
+    const items = [];
+    const pairEvent = msg.payload?.pairEvent;
+    if (pairEvent) {
+      items.push(activityItem({
+        id: "pair-message-" + msg.id,
+        kind: pairEvent === "message" ? "pair" : "state",
+        ts,
+        icon: pairEvent === "message" ? "ti-messages" : "ti-link",
+        title: pairEvent === "message" ? "Pair message" : "Pair " + pairEvent,
+        body: vm.messagePreview(msg),
+        meta: `${vm.displayTarget(msg.from)} -> ${vm.displayTarget(msg.to)}`,
+        view: "pairs",
+        messageId: msg.id,
+      }));
+    } else if (msg.from === HUMAN_AGENT_ID) {
+      items.push(activityItem({
+        id: "human-send-" + msg.id,
+        kind: msg.kind === "task" ? "task" : "message",
+        ts,
+        icon: msg.kind === "task" ? "ti-hand-grab" : "ti-send",
+        title: msg.kind === "task" ? "Claimable task sent" : "Message sent",
+        body: vm.messagePreview(msg),
+        meta: "to " + vm.displayTarget(msg.to),
+        view: inboxPeer(msg) ? "inbox" : "messages",
+        peer: inboxPeer(msg),
+        messageId: msg.id,
+      }));
+    } else if (msg.to === HUMAN_AGENT_ID) {
+      items.push(activityItem({
+        id: "agent-reply-" + msg.id,
+        kind: messageLooksLikeQuestion(msg) ? "question" : "reply",
+        ts,
+        icon: messageLooksLikeQuestion(msg) ? "ti-help-circle" : "ti-message-reply",
+        title: messageLooksLikeQuestion(msg) ? "Agent asked a question" : "Agent replied",
+        body: vm.messagePreview(msg),
+        meta: "from " + vm.displayTarget(msg.from),
+        view: "inbox",
+        peer: msg.from,
+        agentId: msg.from,
+        messageId: msg.id,
+      }));
+    } else {
+      items.push(activityItem({
+        id: "message-" + msg.id,
+        kind: "message",
+        ts,
+        icon: "ti-messages",
+        title: "Agent message",
+        body: vm.messagePreview(msg),
+        meta: `${vm.displayTarget(msg.from)} -> ${vm.displayTarget(msg.to)}`,
+        view: "messages",
+        messageId: msg.id,
+      }));
+    }
+    if (msg.claimedBy) {
+      items.push(activityItem({
+        id: "claim-" + msg.id,
+        kind: "task",
+        ts: toTimestamp(msg.claimedAt || msg.createdAt),
+        icon: "ti-user-check",
+        title: "Task claimed",
+        body: vm.messagePreview(msg),
+        meta: "by " + vm.displayTarget(msg.claimedBy),
+        view: "tasks",
+        messageId: msg.id,
+        agentId: msg.claimedBy,
+      }));
+    }
+    return items;
+  });
+}
+
+function pairActivityItems(vm) {
+  return (vm.pairs || []).flatMap((pair) => {
+    const created = activityItem({
+      id: "pair-created-" + pair.id,
+      kind: "pair",
+      ts: toTimestamp(pair.createdAt),
+      icon: "ti-link-plus",
+      title: "Pair invite created",
+      body: pair.objective || "",
+      meta: `${vm.displayTarget(pair.requesterId)} <-> ${vm.displayTarget(pair.targetId)}`,
+      view: "pairs",
+      pairId: pair.id,
+    });
+    const statusTs = toTimestamp(pair.updatedAt || pair.acceptedAt || pair.endedAt);
+    if (!statusTs || statusTs === created.ts || pair.status === "pending") return [created];
+    return [created, activityItem({
+      id: "pair-status-" + pair.id + "-" + pair.status,
+      kind: "state",
+      ts: statusTs,
+      icon: pair.status === "active" ? "ti-link" : "ti-phone-off",
+      title: "Pair " + pair.status,
+      body: pair.objective || "",
+      meta: pair.endedBy ? "by " + vm.displayTarget(pair.endedBy) : `${vm.displayTarget(pair.requesterId)} <-> ${vm.displayTarget(pair.targetId)}`,
+      view: "pairs",
+      pairId: pair.id,
+    })];
+  });
+}
+
+function taskActivityItems(vm) {
+  return (vm.tasks || []).map((task) => activityItem({
+    id: "task-" + task.id + "-" + task.status,
+    kind: "task",
+    ts: toTimestamp(task.updatedAt || task.createdAt),
+    icon: task.claimedBy ? "ti-user-check" : "ti-checkup-list",
+    title: task.status === "open" ? "Claimable task waiting" : "Task " + task.status,
+    body: task.title || task.body || "",
+    meta: task.claimedBy ? "claimed by " + vm.displayTarget(task.claimedBy) : vm.displayTarget(task.target),
+    view: "tasks",
+    taskId: task.id,
+    agentId: task.claimedBy || task.target,
+  }));
+}
+
+function operatorActivityItems(vm) {
+  const serverClientIds = new Set((vm.activityEvents || []).map((event) => event.clientId).filter(Boolean));
+  return (vm.operatorActivity || []).map((item) => activityItem({
+    ...item,
+    id: item.id || "operator-" + item.ts + "-" + item.title,
+    clientId: item.clientId || item.id,
+  })).filter((item) => !serverClientIds.has(item.clientId));
+}
+
+function getThreadAttention(vm, thread) {
+  const lastHumanReplyId = maxMessageId(thread.messages, (msg) => msg.from === HUMAN_AGENT_ID);
+  const unread = thread.messages.filter((msg) => isUnreadHumanMessage(vm, thread.peer, msg)).length;
+  const agentQuestion = thread.messages.some((msg) =>
+    isHumanInboundMessage(msg) && msg.id > lastHumanReplyId && messageLooksLikeQuestion(msg)
+  );
+  return {
+    unread,
+    needsHumanResponse: false,
+    agentQuestion,
+    score: unread * 10 + (agentQuestion ? 3 : 0),
+  };
+}
+
+function countClaimableWaiting(vm) {
+  const taskCount = vm.tasks.filter(isClaimableTaskWaiting).length;
+  const messageCount = vm.messages.filter(isClaimableMessageWaiting).length;
+  return taskCount + messageCount;
+}
+
+function getFilteredMessages() {
+  if (!this.tagFilter) return this.messages;
+  return this.messages.filter((msg) => messageMatchesTag(this, msg, this.tagFilter));
+}
+
+function messageMatchesTag(vm, msg, tag) {
+  if (msg.to === "tag:" + tag) return true;
+  if (vm.agentsById[msg.from]?.tags?.includes(tag)) return true;
+  if (vm.agentsById[msg.to]?.tags?.includes(tag)) return true;
+  return false;
+}
+
+function getGroupedMessages() {
+  const threads = new Map();
+  for (const msg of this.filteredMessages) {
+    const threadId = msg.threadId || msg.id;
+    if (!threads.has(threadId)) threads.set(threadId, { threadId, messages: [] });
+    threads.get(threadId).messages.push(msg);
+  }
+  for (const group of threads.values()) {
+    group.messages.sort((a, b) => a.id - b.id);
+  }
+  return [...threads.values()].sort(compareThreadGroups);
+}
+
+function compareThreadGroups(a, b) {
+  const aLast = a.messages[a.messages.length - 1].id;
+  const bLast = b.messages[b.messages.length - 1].id;
+  return bLast - aLast;
+}
+
+function getFilteredTasks() {
+  if (this.taskStatusFilter) return this.tasks;
+  return this.tasks.filter((task) => !CLOSED_TASK_STATUSES.has(task.status));
+}
+
+function getIntegrationCards() {
+  return [...(this.integrations || [])].sort((a, b) => {
+    const aStats = a.taskStats || {};
+    const bStats = b.taskStats || {};
+    const openDiff = (bStats.openTasks || 0) - (aStats.openTasks || 0);
+    if (openDiff !== 0) return openDiff;
+    const waitingDiff = (bStats.waitingTasks || 0) - (aStats.waitingTasks || 0);
+    if (waitingDiff !== 0) return waitingDiff;
+    return String(a.name || "").localeCompare(String(b.name || ""));
+  });
+}
+
+function getChannelCards() {
+  return [...(this.channels || [])].sort((a, b) => {
+    const healthRank = { error: 0, warning: 1, ok: 2 };
+    const aHealth = a.targetHealth?.status || "ok";
+    const bHealth = b.targetHealth?.status || "ok";
+    const healthDiff = (healthRank[aHealth] ?? 2) - (healthRank[bHealth] ?? 2);
+    if (healthDiff !== 0) return healthDiff;
+    const readyDiff = Number(Boolean(b.ready)) - Number(Boolean(a.ready));
+    if (readyDiff !== 0) return readyDiff;
+    const statusDiff = String(a.status || "").localeCompare(String(b.status || ""));
+    if (statusDiff !== 0) return statusDiff;
+    return String(a.name || "").localeCompare(String(b.name || ""));
+  });
+}
+
+function getConnectorCards() {
+  return [...(this.connectors || [])].sort((a, b) => {
+    const statusRank = { error: 0, warn: 1, unknown: 2, ok: 3 };
+    const aStatus = a.runtime?.status || "unknown";
+    const bStatus = b.runtime?.status || "unknown";
+    const statusDiff = (statusRank[aStatus] ?? 2) - (statusRank[bStatus] ?? 2);
+    if (statusDiff !== 0) return statusDiff;
+    return String(a.displayName || a.id || "").localeCompare(String(b.displayName || b.id || ""));
+  });
+}
+
+function getOpenPairCount() {
+  return (this.pairs || []).filter((pair) => pair?.status === "active" || pair?.status === "pending").length;
+}
+
+function getComposeAgents() {
+  const list = visibleAgents(this);
+  return this.showOffline ? list : list.filter((agent) => agent.status !== "offline");
+}
+
+function getUniqueLabels() {
+  return [...new Set(visibleAgents(this).filter((agent) => agent.label).map((agent) => agent.label))];
+}
+
+function getUniqueCaps() {
+  return [...new Set(visibleAgents(this).flatMap((agent) => agent.capabilities || []))];
+}
+
+function getUniqueTags() {
+  return [...new Set(visibleAgents(this).flatMap((agent) => agent.tags || []))];
+}
+
+function applyAgentPreset(vm, list) {
+  switch (vm.agentPresetFilter) {
+    case "active":
+      return list.filter((agent) => agent.status !== "offline");
+    case "offline_stale":
+      return list.filter((agent) => agent.status === "offline" || isAgentStale(vm, agent));
+    case "claude":
+    case "codex":
+      return list.filter((agent) => agentType(agent) === vm.agentPresetFilter);
+    case "paired":
+      return list.filter((agent) => Boolean(vm.agentPair(agent)));
+    case "unpaired":
+      return list.filter((agent) => !vm.agentPair(agent));
+    case "waiting":
+      return list.filter((agent) => vm.agentAttention(agent).total > 0);
+    case "claimable":
+      return list.filter((agent) => vm.agentAttention(agent).claimableTasks > 0);
+    case "errors":
+      return list.filter((agent) => agent.status === "offline" || (agent.status !== "offline" && !agent.ready) || isAgentStale(vm, agent));
+    default:
+      return list;
+  }
+}
+
+function getHealthIssues() {
+  return (this.health?.checks || []).filter((check) => check.status !== "ok");
+}
+
+function getHealthDiagnostics() {
+  return this.healthIssues.map((check) => {
+    const base = {
+      name: check.name,
+      status: check.status,
+      detail: check.detail || check.name,
+      impact: healthImpact(check),
+      actions: [
+        { label: "Inspect logs", icon: "ti-file-search", copy: "agent-relay daemon logs" },
+        { label: "Restart daemon", icon: "ti-refresh", copy: "agent-relay daemon restart" },
+        { label: "Copy env", icon: "ti-copy", copy: "agent-relay doctor" },
+      ],
+    };
+    if (check.name === "stale-live-agents") {
+      base.actions.unshift(
+        { label: "Run reaper", icon: "ti-broom", api: "POST", path: "/system/reap" },
+        { label: "Show stale", icon: "ti-filter", view: "agents", preset: "offline_stale" }
+      );
+    } else if (check.name === "channel-delivery-targets") {
+      base.actions.unshift(
+        { label: "Open channels", icon: "ti-messages", view: "channels" },
+        { label: "Run reaper", icon: "ti-broom", api: "POST", path: "/system/reap" }
+      );
+    } else if (check.name === "expired-message-claims" || check.name === "expired-task-claims" || check.name === "offline-claimed-tasks") {
+      base.actions.unshift(
+        { label: "Run reaper", icon: "ti-broom", api: "POST", path: "/system/reap" },
+        { label: "Open work", icon: "ti-list-check", view: "work" }
+      );
+    }
+    return base;
+  });
+}
+
+function healthImpact(check) {
+  if (check.name === "database") return "Relay persistence is unavailable; messages, state, and audit writes may fail.";
+  if (check.name === "stale-live-agents") return "Agents may look online even though their heartbeat has stopped.";
+  if (check.name === "expired-message-claims") return "Claimable messages may be stuck until the reaper releases expired claims.";
+  if (check.name === "expired-task-claims") return "Tasks can appear owned by agents that no longer hold a live lease.";
+  if (check.name === "offline-claimed-tasks") return "Offline agents are still shown as owners for active work.";
+  if (check.name === "channel-delivery-targets") return "Inbound channel messages may be accepted but routed to no live delivery agent.";
+  return "Relay health is degraded for this check.";
+}
+
+function getCommandPaletteItems() {
+  const query = this.commandQuery.trim().toLowerCase();
+  const commands = [
+    commandItem("open-inbox", "Open inbox", "Human console", "ti-inbox", "openView", { view: "inbox" }),
+    commandItem("open-work", "Open work queue", "Claimable messages and tasks", "ti-list-check", "openView", { view: "work" }),
+    commandItem("show-stale-agents", "Show stale agents", "Filter agents to offline or stale heartbeat", "ti-filter", "agentPreset", { preset: "offline_stale" }),
+    commandItem("copy-relay-url", "Copy relay URL", baseUrl(), "ti-copy", "copy", { value: baseUrl() }),
+    commandItem("export-timeline-md", "Export full timeline as Markdown", "Activity audit trace", "ti-file-export", "exportActivity", { format: "markdown" }),
+    commandItem("export-timeline-json", "Export full timeline as JSON", "Activity audit trace", "ti-braces", "exportActivity", { format: "json" }),
+    ...this.composeAgents.slice(0, 12).map((agent) =>
+      commandItem("message-" + agent.id, "Message agent: " + this.displayName(agent), agent.id, "ti-send", "messageAgent", { agentId: agent.id })
+    ),
+    ...this.composeAgents.filter((agent) => agentType(agent) === "codex").slice(0, 8).map((agent) =>
+      commandItem("pair-codex-" + agent.id, "Pair Codex: " + this.displayName(agent), agent.id, "ti-link-plus", "pairAgent", { agentId: agent.id })
+    ),
+    ...this.uniqueTags.map((tag) =>
+      commandItem("filter-tag-" + tag, "Filter tag: " + tag, "#" + tag, "ti-tag", "filterTag", { tag })
+    ),
+  ];
+  if (!query) return commands.slice(0, 24);
+  return commands.filter((command) => command.search.includes(query)).slice(0, 24);
+}
+
+function commandItem(id, title, subtitle, icon, action, payload) {
+  return {
+    id,
+    title,
+    subtitle,
+    icon,
+    action,
+    payload: payload || {},
+    search: `${title}\n${subtitle || ""}\n${action}`.toLowerCase(),
+  };
+}
+
+function compareAgents(vm, a, b) {
+  if (vm.agentSort === "status") {
+    const attentionDelta = vm.agentAttention(b).score - vm.agentAttention(a).score;
+    if (attentionDelta !== 0) return attentionDelta;
+  }
+  switch (vm.agentSort) {
+    case "name":
+      return vm.displayName(a).localeCompare(vm.displayName(b));
+    case "status":
+      return (STATUS_SORT_ORDER[a.status] ?? 9) - (STATUS_SORT_ORDER[b.status] ?? 9);
+    case "lastSeen":
+      return new Date(b.lastSeen) - new Date(a.lastSeen);
+    case "created":
+      return new Date(b.createdAt) - new Date(a.createdAt);
+    default:
+      return 0;
+  }
+}
+
+function getOnlineOrchestratorCount() {
+  return this.orchestrators.filter((o) => o.status === "online").length;
+}
+
+function getReadyChannelCount() {
+  return this.channelCards.filter((item) => item.ready).length;
+}