@gorlitzer-labs/apiary 1.13.3

package/dist/chunk-ED6ROH6B.js

@@ -0,0 +1,2021 @@
+import {
+  isAgentAlive,
+  listAgentSessions,
+  listRoomSessions,
+  loadConfig,
+  roomEmoji,
+  saveConfig,
+  saveRoomSession,
+  tmuxCapturePane,
+  tmuxInjectText,
+  tmuxSendEnter,
+  tmuxSessionExists
+} from "./chunk-CZHO4DBN.js";
+import {
+  extractToken
+} from "./chunk-AYQJIAR5.js";
+import {
+  randomName
+} from "./chunk-D7DXZQWT.js";
+import {
+  can
+} from "./chunk-QL66XSDB.js";
+
+// src/cli/join.ts
+import { randomUUID } from "crypto";
+import { createInterface } from "readline";
+
+// src/cli/tui.tsx
+import React, { useState, useEffect, useCallback, useMemo, useRef } from "react";
+import { render, Box, Text, Static, useStdout, useInput } from "ink";
+import { exec } from "child_process";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var C = {
+  cyan: "#00d4ff",
+  purple: "#8b5cf6",
+  orange: "#ff8c42",
+  pink: "#f472b6",
+  green: "#34d399",
+  yellow: "#fbbf24",
+  danger: "#f87171",
+  text: "#eceff4",
+  secondary: "#b0b7c4",
+  dim: "#7e8798",
+  muted: "#5b6679",
+  border: "#475264"
+};
+var AGENT_COLORS = [C.cyan, C.purple, C.orange, C.pink, C.green, C.yellow];
+var SIGILS = ["\u25C6", "\u25B2", "\u25CF", "\u25A0", "\u2605", "\u25C9", "\u25C8", "\u25B8"];
+var AMB = "#fbbf24";
+var WNG = "#e0e7ee";
+var BLK = "#3a3a4a";
+var BANNER = [
+  [
+    { text: "               _                      ", color: "#ffb347" },
+    { text: "\\ ", color: BLK },
+    { text: "\\  ", color: WNG }
+  ],
+  [
+    { text: "  ____ _____  (_)___ ________  __      ", color: "#ffa733" },
+    { text: "\\ ", color: WNG },
+    { text: "\\ ", color: BLK },
+    { text: "\\ ", color: WNG }
+  ],
+  [
+    { text: " / __ `/ __ \\/ / __ `/ ___/ / / /      ", color: "#ff9b1f" },
+    { text: "(o o)", color: AMB }
+  ],
+  [
+    { text: "/ /_/ / /_/ / / /_/ / /  / /_/ /       ", color: "#ff8f0b" },
+    { text: ")=BzZz=(", color: AMB }
+  ],
+  [
+    { text: "\\__,_/ .___/_/\\__,_/_/   \\__, /        ", color: "#f7a600" },
+    { text: "/ ", color: WNG },
+    { text: "/ ", color: BLK },
+    { text: "/ ", color: WNG }
+  ],
+  [
+    { text: "    /_/                 /____/        ", color: "#f0c000" },
+    { text: "/ ", color: BLK },
+    { text: "/ ", color: WNG },
+    { text: "/  ", color: BLK }
+  ]
+];
+var FIGHT_BANNER = [
+  [{ text: "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557", color: "#f87171" }],
+  [{ text: "\u2551", color: "#f87171" }, { text: "  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2557  ", color: "#ff4444" }, { text: "\u2551", color: "#f87171" }],
+  [{ text: "\u2551", color: "#f87171" }, { text: "  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2551\u2588\u2588\u2551  ", color: "#ff6b6b" }, { text: "\u2551", color: "#f87171" }],
+  [{ text: "\u2551", color: "#f87171" }, { text: "  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551  ", color: "#ff8888" }, { text: "\u2551", color: "#f87171" }],
+  [{ text: "\u2551", color: "#f87171" }, { text: "  \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   \u255A\u2550\u255D\u255A\u2550\u255D  ", color: "#ff6b6b" }, { text: "\u2551", color: "#f87171" }],
+  [{ text: "\u2551", color: "#f87171" }, { text: "  \u2588\u2588\u2551     \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2557\u2588\u2588\u2557  ", color: "#ff4444" }, { text: "\u2551", color: "#f87171" }],
+  [{ text: "\u2551", color: "#f87171" }, { text: "  \u255A\u2550\u255D     \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D\u255A\u2550\u255D  ", color: "#ff4444" }, { text: "\u2551", color: "#f87171" }],
+  [{ text: "\u2551", color: "#f87171" }, { text: "                                                  ", color: "#f87171" }, { text: "\u2551", color: "#f87171" }],
+  [{ text: "\u2551", color: "#f87171" }, { text: "     \u2694\uFE0F  NO MERCY  \xB7  NO RULES  \xB7  NO FILTER  \u2694\uFE0F   ", color: "#fbbf24" }, { text: "\u2551", color: "#f87171" }],
+  [{ text: "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D", color: "#f87171" }]
+];
+var FIGHT_HITS = ["POW!", "WHAM!", "K.O.!", "BAM!", "CRACK!", "BOOM!", "SLAM!", "ZAP!", "THWACK!", "KAPOW!", "HADOUKEN!", "FATALITY!", "COMBO!", "ULTRA!"];
+var FIGHT_COLORS = ["#ff4444", "#ff6b6b", "#fbbf24", "#ff8c42", "#f472b6", "#8b5cf6"];
+function pickFightHit(messageId) {
+  let h = 0;
+  for (let i = 0; i < messageId.length; i++) h = (h << 5) - h + messageId.charCodeAt(i) | 0;
+  const idx = Math.abs(h);
+  return {
+    word: FIGHT_HITS[idx % FIGHT_HITS.length],
+    color: FIGHT_COLORS[idx % FIGHT_COLORS.length]
+  };
+}
+var ENGAGEMENT_MODES = [
+  "everyone",
+  "people",
+  "agents",
+  "fight",
+  "standby-everyone",
+  "standby-people",
+  "standby-agents"
+];
+var SLASH_COMMANDS = [
+  { name: "/help", description: "Show commands" },
+  { name: "/who", description: "List participants" },
+  { name: "/rules", description: "Show the room rules" },
+  { name: "/watch", description: "Open an agent's terminal in a new window", params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/leave", description: "Disconnect and exit" },
+  { name: "/share", description: "Generate share links", op: "create_share_link" },
+  { name: "/kick", description: "Remove a participant", op: "kick", params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/mute", description: "Make read-only (guest)", op: "mute", params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/unmute", description: "Restore to member", op: "unmute", params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/setmode", description: "Set engagement mode", op: "set_mode_for", params: [
+    { label: "name", completions: "participants" },
+    { label: "mode", completions: ENGAGEMENT_MODES }
+  ] },
+  { name: "/promote", description: "Promote to product owner", op: "promote", params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/demote", description: "Demote product owner to member", op: "demote", params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/ping", description: "Ping a participant", op: "ping", params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/peek", description: "Show tmux command to view an agent's session", params: [
+    { label: "name", completions: "participants" }
+  ] },
+  { name: "/clear", description: "Wipe room history", op: "clear_history" },
+  { name: "/tunnel", description: "Start a cloudflared tunnel", op: "start_tunnel" },
+  { name: "/sound", description: "Toggle notification sounds" }
+];
+var CMD_DISPLAY_COL = 26;
+var OBSERVED_TTL_MS = 1e4;
+var INFERRED_DECAY_MS = OBSERVED_TTL_MS * 2;
+function shouldApplyAgentState(opts) {
+  if (opts.observed) return true;
+  if (opts.lastObservedAt === void 0) return true;
+  return opts.now - opts.lastObservedAt >= (opts.ttlMs ?? OBSERVED_TTL_MS);
+}
+function formatTokens(n) {
+  if (!Number.isFinite(n) || n < 0) return "0";
+  if (n < 1e3) return String(Math.round(n));
+  if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+  return `${(n / 1e6).toFixed(n < 1e7 ? 1 : 0)}M`;
+}
+function seedHash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) h = (h << 5) - h + s.charCodeAt(i) | 0;
+  return Math.abs(h);
+}
+function makeIdentityAssigner() {
+  const map = /* @__PURE__ */ new Map();
+  return (name) => {
+    if (!map.has(name)) {
+      const h = seedHash(name);
+      map.set(name, {
+        color: AGENT_COLORS[h % AGENT_COLORS.length],
+        sigil: SIGILS[Math.floor(h / AGENT_COLORS.length) % SIGILS.length]
+      });
+    }
+    return map.get(name);
+  };
+}
+var SHELL_MAX_OUTPUT_BYTES = 64 * 1024;
+var SHELL_TIMEOUT_MS = 6e4;
+function runLocalShell(cmd, push) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+  const startId = `sh-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  push({ id: `${startId}-cmd`, ts, kind: "system", content: `$ ${cmd}` });
+  exec(cmd, {
+    maxBuffer: SHELL_MAX_OUTPUT_BYTES,
+    timeout: SHELL_TIMEOUT_MS,
+    shell: process.env.SHELL || "/bin/sh"
+  }, (err, stdout, stderr) => {
+    const doneTs = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+    const out = (stdout || "").toString().replace(/\s+$/, "");
+    const errOut = (stderr || "").toString().replace(/\s+$/, "");
+    if (out) push({ id: `${startId}-out`, ts: doneTs, kind: "system", content: out });
+    if (errOut) push({ id: `${startId}-err`, ts: doneTs, kind: "system", content: errOut });
+    if (err) {
+      const code = err.code;
+      const exitCode = err.code;
+      const tag = code === "ETIMEDOUT" ? "timeout" : `exit ${exitCode ?? "?"}`;
+      push({ id: `${startId}-end`, ts: doneTs, kind: "system", content: `\u21B3 ${tag}` });
+    } else if (!out && !errOut) {
+      push({ id: `${startId}-end`, ts: doneTs, kind: "system", content: "\u21B3 (no output)" });
+    }
+  });
+}
+function wordWrap(text, width) {
+  if (width < 10) width = 10;
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    if (paragraph.length === 0) {
+      lines.push("");
+      continue;
+    }
+    let line = "";
+    for (const word of paragraph.split(/( +)/)) {
+      if (line.length + word.length > width && line.length > 0) {
+        lines.push(line);
+        line = word.replace(/^ +/, "");
+      } else {
+        line += word;
+      }
+    }
+    if (line.length > 0) lines.push(line);
+  }
+  if (lines.length === 0) lines.push("");
+  return lines;
+}
+function StyledContent({
+  text,
+  contentColor,
+  identify
+}) {
+  const parts = [];
+  const pattern = /@([a-zA-Z0-9_-]+)/g;
+  let lastIdx = 0;
+  let match;
+  let key = 0;
+  while ((match = pattern.exec(text)) !== null) {
+    if (match.index > lastIdx) {
+      parts.push(/* @__PURE__ */ jsx(Text, { color: contentColor, children: text.slice(lastIdx, match.index) }, key++));
+    }
+    const mentionName = match[1];
+    const { color } = identify(mentionName);
+    parts.push(/* @__PURE__ */ jsxs(Text, { color, bold: true, children: [
+      "@",
+      mentionName
+    ] }, key++));
+    lastIdx = match.index + match[0].length;
+  }
+  if (lastIdx < text.length) {
+    parts.push(/* @__PURE__ */ jsx(Text, { color: contentColor, children: text.slice(lastIdx) }, key++));
+  }
+  if (parts.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { color: contentColor, children: text });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: parts });
+}
+function EventLine({
+  event,
+  identify,
+  cols,
+  zebra,
+  fightMode
+}) {
+  const ts = /* @__PURE__ */ jsxs(Text, { color: C.muted, children: [
+    event.ts,
+    "  "
+  ] });
+  if (event.kind === "message") {
+    const { color, sigil } = identify(event.senderName);
+    const isSelf = event.isSelf;
+    const isFight = fightMode && !isSelf;
+    const nameColor = isSelf ? C.text : event.senderType === "agent" ? color : C.secondary;
+    const sigilColor = isSelf ? C.dim : event.senderType === "agent" ? color : C.dim;
+    const sigilChar = isSelf ? "\u203A" : isFight ? "\u2694" : event.senderType === "agent" ? sigil : "\xB7";
+    const contentColor = isSelf ? C.text : zebra ? "#d0d5de" : C.secondary;
+    const borderColor = isFight ? FIGHT_COLORS[Math.abs(seedHash(event.id)) % FIGHT_COLORS.length] : isSelf ? C.border : event.senderType === "agent" ? color : C.dim;
+    const borderStyle = isFight ? "double" : "round";
+    const boxChrome = 4;
+    const innerWidth = Math.max(10, cols - 2 - boxChrome);
+    const wrapped = wordWrap(event.content, innerWidth);
+    const hit = isFight ? pickFightHit(event.id) : null;
+    const replyTag = event.replyToName ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { color: C.dim, children: "  \u21A9 " }),
+      /* @__PURE__ */ jsx(Text, { color: C.secondary, children: event.replyToName })
+    ] }) : null;
+    return /* @__PURE__ */ jsx(Box, { paddingX: 1, flexDirection: "column", children: /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle,
+        borderColor,
+        paddingX: 1,
+        width: cols - 2,
+        children: [
+          /* @__PURE__ */ jsxs(Box, { children: [
+            ts,
+            /* @__PURE__ */ jsxs(Text, { color: sigilColor, children: [
+              sigilChar,
+              " "
+            ] }),
+            /* @__PURE__ */ jsx(Text, { color: nameColor, bold: isSelf || isFight, children: event.senderName }),
+            replyTag,
+            hit && /* @__PURE__ */ jsx(Text, { color: hit.color, bold: true, children: `  \xAB ${hit.word} \xBB` })
+          ] }),
+          wrapped.map((line, i) => /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: /* @__PURE__ */ jsx(StyledContent, { text: line, contentColor: isFight ? C.text : contentColor, identify }) }) }, i))
+        ]
+      }
+    ) }) });
+  }
+  if (event.kind === "join") {
+    const isAgent = event.participantType === "agent";
+    const { color, sigil } = isAgent ? identify(event.name) : { color: C.dim, sigil: "\xB7" };
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      ts,
+      /* @__PURE__ */ jsxs(Text, { color: isAgent ? color : C.dim, children: [
+        sigil,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: isAgent ? color : C.dim, children: event.name }),
+      /* @__PURE__ */ jsx(Text, { color: C.green, children: " joined" })
+    ] });
+  }
+  if (event.kind === "leave") {
+    const isAgent = event.participantType === "agent";
+    const { color: nameColor } = isAgent ? identify(event.name) : { color: C.muted };
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      ts,
+      /* @__PURE__ */ jsx(Text, { color: C.muted, children: "\xB7 " }),
+      /* @__PURE__ */ jsx(Text, { color: nameColor, children: event.name }),
+      /* @__PURE__ */ jsx(Text, { color: C.danger, children: " left" })
+    ] });
+  }
+  if (event.kind === "mode") {
+    if (event.mode === "fight") {
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { children: " " }) }),
+        FIGHT_BANNER.map((segments, i) => /* @__PURE__ */ jsx(Text, { children: segments.map((s, j) => /* @__PURE__ */ jsx(Text, { color: s.color, bold: true, children: s.text }, j)) }, i)),
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { children: " " }) })
+      ] });
+    }
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      ts,
+      /* @__PURE__ */ jsx(Text, { color: C.dim, children: "mode \u2192 " }),
+      /* @__PURE__ */ jsx(Text, { color: C.yellow, bold: true, children: event.mode })
+    ] });
+  }
+  if (event.kind === "ping") {
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      ts,
+      /* @__PURE__ */ jsx(Text, { color: C.yellow, children: "\u{1F514} " }),
+      /* @__PURE__ */ jsx(Text, { color: C.yellow, bold: true, children: event.pingerName }),
+      /* @__PURE__ */ jsx(Text, { color: C.yellow, children: " pinged you." })
+    ] });
+  }
+  if (event.kind === "system") {
+    return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      ts,
+      /* @__PURE__ */ jsx(Text, { color: C.dim, children: "  " }),
+      /* @__PURE__ */ jsx(Text, { color: C.secondary, children: event.content })
+    ] });
+  }
+  return null;
+}
+function App({
+  roomName,
+  onSend,
+  onCtrlC,
+  onWatchAgent,
+  onReady,
+  readOnly,
+  authority,
+  initialSound = true
+}) {
+  const [events, setEvents] = useState([]);
+  const [agentNames, setAgentNames] = useState([]);
+  const [participants, setParticipants] = useState([]);
+  const [input, setInput] = useState("");
+  const [cursorPos, setCursorPos] = useState(0);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [soundEnabled, setSoundEnabled] = useState(initialSound);
+  const [agentStates, setAgentStatesMap] = useState(/* @__PURE__ */ new Map());
+  const [agentActivities, setAgentActivitiesMap] = useState(/* @__PURE__ */ new Map());
+  const [agentMetrics, setAgentMetricsMap] = useState(/* @__PURE__ */ new Map());
+  const [, setStaleTick] = useState(0);
+  useEffect(() => {
+    const t = setInterval(() => setStaleTick((n) => n + 1), 5e3);
+    return () => clearInterval(t);
+  }, []);
+  const [fightMode, setFightMode] = useState(false);
+  const fightModeRef = useRef(false);
+  const soundRef = useRef(initialSound);
+  const stateRef = useRef(/* @__PURE__ */ new Map());
+  const activityRef = useRef(/* @__PURE__ */ new Map());
+  const metricsRef = useRef(/* @__PURE__ */ new Map());
+  const decayTimers = useRef(/* @__PURE__ */ new Map());
+  const { stdout } = useStdout();
+  const identify = useMemo(makeIdentityAssigner, []);
+  const setInputAt = useCallback((newInput, newPos) => {
+    setInput(newInput);
+    setCursorPos(Math.max(0, Math.min(newPos, newInput.length)));
+  }, []);
+  useEffect(() => {
+    setCursorPos((p) => Math.min(p, input.length));
+  }, [input]);
+  const eventBuffer = useRef([]);
+  const eventFlushTimer = useRef(null);
+  const MAX_EVENTS = 5e3;
+  const push = useCallback((event) => {
+    const shouldBell = event.kind === "ping" || event.kind === "message" && !event.isSelf;
+    if (shouldBell && soundRef.current && stdout.isTTY) stdout.write("\x07");
+    if (event.kind === "mode") {
+      const entering = event.mode === "fight";
+      setFightMode(entering);
+      fightModeRef.current = entering;
+    }
+    eventBuffer.current.push(event);
+    if (!eventFlushTimer.current) {
+      eventFlushTimer.current = setTimeout(() => {
+        eventFlushTimer.current = null;
+        const batch = eventBuffer.current.splice(0);
+        if (batch.length > 0) {
+          setEvents((prev) => {
+            const next = [...prev, ...batch];
+            return next.length > MAX_EVENTS ? next.slice(next.length - MAX_EVENTS) : next;
+          });
+        }
+      }, 80);
+    }
+  }, [stdout]);
+  const clear = useCallback(() => {
+    if (eventFlushTimer.current) {
+      clearTimeout(eventFlushTimer.current);
+      eventFlushTimer.current = null;
+    }
+    eventBuffer.current.length = 0;
+    setEvents([]);
+    if (stdout.isTTY) stdout.write("\x1B[2J\x1B[H");
+  }, [stdout]);
+  const toggleSound = useCallback(() => {
+    const next = !soundRef.current;
+    soundRef.current = next;
+    setSoundEnabled(next);
+    return next;
+  }, []);
+  const observedAtRef = React.useRef(/* @__PURE__ */ new Map());
+  const [stateSource, setStateSource] = useState(/* @__PURE__ */ new Map());
+  const DEFAULT_WORKING_DECAY_MS = INFERRED_DECAY_MS;
+  const PENDING_STALL_MS = 3e4;
+  const setAgentState = useCallback(
+    (name, state, opts) => {
+      const observed = opts?.observed === true;
+      if (!shouldApplyAgentState({
+        observed,
+        lastObservedAt: observedAtRef.current.get(name),
+        now: Date.now()
+      })) return;
+      if (observed) observedAtRef.current.set(name, Date.now());
+      setStateSource((prev) => {
+        const next = new Map(prev);
+        next.set(name, observed ? "reported" : "inferred");
+        return next;
+      });
+      const existing = decayTimers.current.get(name);
+      if (existing) {
+        clearTimeout(existing);
+        decayTimers.current.delete(name);
+      }
+      stateRef.current.set(name, state);
+      setAgentStatesMap(new Map(stateRef.current));
+      if (state === "working") {
+        const ms = opts?.decayMs ?? DEFAULT_WORKING_DECAY_MS;
+        decayTimers.current.set(name, setTimeout(() => {
+          if (stateRef.current.get(name) === "working") {
+            stateRef.current.set(name, "unknown");
+            setAgentStatesMap(new Map(stateRef.current));
+          }
+          decayTimers.current.delete(name);
+        }, ms));
+      } else if (state === "pending") {
+        decayTimers.current.set(name, setTimeout(() => {
+          if (stateRef.current.get(name) === "pending") {
+            stateRef.current.set(name, "stalled");
+            setAgentStatesMap(new Map(stateRef.current));
+          }
+          decayTimers.current.delete(name);
+        }, PENDING_STALL_MS));
+      }
+    },
+    []
+  );
+  const setAgentActivity = useCallback((name, label) => {
+    if (label && label.trim()) {
+      activityRef.current.set(name, { label: label.trim(), updatedAt: Date.now() });
+    } else {
+      activityRef.current.delete(name);
+    }
+    setAgentActivitiesMap(new Map(activityRef.current));
+  }, []);
+  const setAgentMetrics = useCallback((name, m) => {
+    metricsRef.current.set(name, m);
+    setAgentMetricsMap(new Map(metricsRef.current));
+  }, []);
+  useEffect(() => {
+    onReady({ push, clear, setAgentNames, setParticipants, toggleSound, setAgentState, setAgentActivity, setAgentMetrics });
+    return () => {
+      if (eventFlushTimer.current) clearTimeout(eventFlushTimer.current);
+      for (const t of decayTimers.current.values()) clearTimeout(t);
+      decayTimers.current.clear();
+    };
+  }, []);
+  useEffect(() => {
+    fightModeRef.current = fightMode;
+  }, [fightMode]);
+  const suggestionState = useMemo(() => {
+    const textBeforeCursor = input.slice(0, cursorPos);
+    const mentionMatch = textBeforeCursor.match(/@([a-zA-Z0-9_-]*)$/);
+    if (mentionMatch && participants.length > 0) {
+      const prefix = mentionMatch[1].toLowerCase();
+      const candidates = ["all", ...participants.filter((p) => p.toLowerCase() !== "all")];
+      const filtered2 = candidates.filter((p) => p.toLowerCase().startsWith(prefix));
+      if (filtered2.length > 0) {
+        const before = input.slice(0, mentionMatch.index);
+        const after = input.slice(cursorPos);
+        const items2 = filtered2.map((p) => ({
+          kind: "mention",
+          value: p,
+          insert: before + "@" + p + " " + after
+        }));
+        const ghostHint2 = prefix.length === 0 ? "" : filtered2[0].slice(prefix.length);
+        return { items: items2, ghostHint: ghostHint2 };
+      }
+    }
+    if (!input.startsWith("/")) return { items: [], ghostHint: "" };
+    const spaceIdx = input.indexOf(" ");
+    if (spaceIdx === -1) {
+      const prefix = input.toLowerCase();
+      const items2 = SLASH_COMMANDS.filter((cmd2) => {
+        if (cmd2.op && !can(authority, cmd2.op)) return false;
+        return cmd2.name.startsWith(prefix);
+      }).map((cmd2) => ({
+        kind: "command",
+        cmd: cmd2,
+        insert: cmd2.name + " "
+      }));
+      return { items: items2, ghostHint: "" };
+    }
+    const cmdName = input.slice(0, spaceIdx).toLowerCase();
+    const cmd = SLASH_COMMANDS.find((c) => c.name === cmdName && (!c.op || can(authority, c.op)));
+    if (!cmd?.params) return { items: [], ghostHint: "" };
+    const rest = input.slice(spaceIdx + 1);
+    const words = rest.split(/\s+/);
+    const hasTrailingSpace = rest.endsWith(" ") || rest === "";
+    const completedCount = hasTrailingSpace ? words.filter(Boolean).length : Math.max(0, words.length - 1);
+    const currentPrefix = hasTrailingSpace ? "" : (words[words.length - 1] ?? "").toLowerCase();
+    const paramIdx = completedCount;
+    if (paramIdx >= cmd.params.length) return { items: [], ghostHint: "" };
+    const param = cmd.params[paramIdx];
+    const ghostStart = currentPrefix ? paramIdx + 1 : paramIdx;
+    const ghostHint = cmd.params.slice(ghostStart).map((p) => `<${p.label}>`).join(" ");
+    if (!param.completions) return { items: [], ghostHint };
+    const values = param.completions === "participants" ? participants : param.completions;
+    const filtered = currentPrefix ? values.filter((v) => v.toLowerCase().startsWith(currentPrefix)) : values;
+    const completedWords = words.slice(0, completedCount).filter(Boolean);
+    const base = cmdName + (completedWords.length ? " " + completedWords.join(" ") : "") + " ";
+    const items = filtered.map((v) => ({
+      kind: "param",
+      value: v,
+      insert: base + v + " "
+    }));
+    return { items, ghostHint };
+  }, [input, cursorPos, authority, participants]);
+  const suggestions = suggestionState.items;
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [input]);
+  useInput((char, key) => {
+    if (key.ctrl && char === "c") {
+      onCtrlC?.();
+      return;
+    }
+    if (key.ctrl && char >= "1" && char <= "9") {
+      const idx = Number(char) - 1;
+      const target = agentNames[idx];
+      if (target) onWatchAgent?.(target);
+      return;
+    }
+    if (readOnly || !onSend) return;
+    if (suggestions.length > 0) {
+      if (key.downArrow) {
+        setSelectedIndex((i) => Math.min(i + 1, suggestions.length - 1));
+        return;
+      }
+      if (key.upArrow) {
+        setSelectedIndex((i) => Math.max(i - 1, 0));
+        return;
+      }
+      if (key.return || key.tab) {
+        const picked = suggestions[selectedIndex];
+        if (!picked) return;
+        if (key.return && picked.kind === "command" && !picked.cmd.params) {
+          onSend(picked.cmd.name);
+          setInputAt("", 0);
+          return;
+        }
+        setInputAt(picked.insert, picked.insert.length);
+        return;
+      }
+      if (key.escape) {
+        setInputAt("", 0);
+        return;
+      }
+    }
+    if (key.leftArrow) {
+      setCursorPos((p) => Math.max(0, p - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursorPos((p) => Math.min(p + 1, input.length));
+      return;
+    }
+    if (key.ctrl && char === "a") {
+      setCursorPos(0);
+      return;
+    }
+    if (key.ctrl && char === "e") {
+      setCursorPos(input.length);
+      return;
+    }
+    if (key.ctrl && char === "w") {
+      if (cursorPos === 0) return;
+      let pos = cursorPos - 1;
+      while (pos > 0 && input[pos] === " ") pos--;
+      while (pos > 0 && input[pos - 1] !== " ") pos--;
+      setInputAt(input.slice(0, pos) + input.slice(cursorPos), pos);
+      return;
+    }
+    if (key.return && key.meta) {
+      setInputAt(input.slice(0, cursorPos) + "\n" + input.slice(cursorPos), cursorPos + 1);
+      return;
+    }
+    if (key.return) {
+      const content = input.trim();
+      if (!content) {
+        setInputAt("", 0);
+        return;
+      }
+      if (content.startsWith("!")) {
+        const cmd = content.slice(1).trim();
+        setInputAt("", 0);
+        if (cmd) runLocalShell(cmd, push);
+        return;
+      }
+      onSend(content);
+      setInputAt("", 0);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      if (cursorPos > 0) {
+        setInputAt(input.slice(0, cursorPos - 1) + input.slice(cursorPos), cursorPos - 1);
+      }
+      return;
+    }
+    if (key.ctrl || key.meta || key.escape || key.tab || key.upArrow || key.downArrow) {
+      return;
+    }
+    if (char) {
+      const normalized = char.replace(/\r\n?/g, "\n");
+      setInputAt(
+        input.slice(0, cursorPos) + normalized + input.slice(cursorPos),
+        cursorPos + normalized.length
+      );
+    }
+  });
+  const cols = stdout.columns ?? 80;
+  const entries = useMemo(() => {
+    let msgIdx = 0;
+    return [{ id: "__banner__" }, ...events.map((e) => {
+      const isMsg = e.kind === "message" && !e.isSelf;
+      const entry = { id: e.id, event: e, zebra: isMsg ? msgIdx % 2 === 1 : void 0 };
+      if (isMsg) msgIdx++;
+      return entry;
+    })];
+  }, [events]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Static, { items: entries, children: (entry) => {
+      if (!entry.event) {
+        return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 2, paddingTop: 1, paddingBottom: 1, children: [
+          BANNER.map((segments, i) => /* @__PURE__ */ jsx(Text, { children: segments.map((s, j) => /* @__PURE__ */ jsx(Text, { color: s.color, children: s.text }, j)) }, i)),
+          /* @__PURE__ */ jsx(Text, { color: C.muted, italic: true, children: "  ah \u2014 it's not a sad alien, it's a bee" }),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { color: C.dim, children: "  room  " }),
+            /* @__PURE__ */ jsx(Text, { color: C.cyan, bold: true, children: roomName })
+          ] })
+        ] }, entry.id);
+      }
+      return /* @__PURE__ */ jsx(EventLine, { event: entry.event, identify, cols, zebra: entry.zebra, fightMode }, entry.id);
+    } }),
+    fightMode ? /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: "#f87171", bold: true, children: "\u2550" }),
+      /* @__PURE__ */ jsx(Text, { color: "#ff4444", children: "\u2550".repeat(Math.max(0, cols - 4)) }),
+      /* @__PURE__ */ jsx(Text, { color: "#f87171", bold: true, children: "\u2550" })
+    ] }) : /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: C.orange, children: "\u2500" }),
+      /* @__PURE__ */ jsx(Text, { color: C.border, children: "\u2500".repeat(Math.max(0, cols - 4)) }),
+      /* @__PURE__ */ jsx(Text, { color: C.yellow, children: "\u2500" })
+    ] }),
+    agentMetrics.size > 0 && (() => {
+      let totalCtx = 0;
+      for (const m of agentMetrics.values()) {
+        totalCtx += m.ctxTokens;
+      }
+      return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+        /* @__PURE__ */ jsx(Text, { color: C.muted, children: "  room  " }),
+        /* @__PURE__ */ jsx(Text, { color: C.muted, children: `${formatTokens(totalCtx)} ctx total` })
+      ] });
+    })(),
+    agentNames.length > 0 && /* @__PURE__ */ jsx(Box, { paddingX: 1, flexWrap: "wrap", children: agentNames.map((name, i) => {
+      const { color, sigil } = identify(name);
+      const state = agentStates.get(name) ?? "unknown";
+      const activity = agentActivities.get(name);
+      const metrics = agentMetrics.get(name);
+      const stateSuffix = (() => {
+        switch (state) {
+          case "pending":
+            return { glyph: " \u23F3 booting", color: C.yellow };
+          case "stalled":
+            return { glyph: " \u26A0 stalled", color: C.danger };
+          case "idle":
+            return { glyph: " \u2713", color: C.green };
+          case "blocked":
+            return { glyph: " \u23F8 needs you", color: C.orange };
+          case "working":
+            return { glyph: " \u2026", color: C.yellow };
+          case "unresponsive":
+            return { glyph: " \u26A0", color: C.danger };
+          case "unknown":
+          default:
+            return { glyph: " zzz", color: C.muted };
+        }
+      })();
+      const inferred = stateSource.get(name) === "inferred";
+      const glyphColor = inferred ? C.muted : stateSuffix.color;
+      const STALE_MS = 3e4;
+      const fresh = activity && Date.now() - activity.updatedAt <= STALE_MS;
+      const metricsText = metrics ? ` ${formatTokens(metrics.ctxTokens)}` : "";
+      return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+        i > 0 && /* @__PURE__ */ jsx(Text, { color: C.border, children: " \xB7 " }),
+        /* @__PURE__ */ jsxs(Text, { color, children: [
+          sigil,
+          " ",
+          name
+        ] }),
+        /* @__PURE__ */ jsx(Text, { color: glyphColor, children: stateSuffix.glyph }),
+        i < 9 && /* @__PURE__ */ jsx(Text, { color: C.border, children: ` \u29C9${i + 1}` }),
+        fresh && /* @__PURE__ */ jsxs(Text, { color: C.yellow, children: [
+          " ",
+          activity.label
+        ] }),
+        metricsText && /* @__PURE__ */ jsx(Text, { color: C.muted, children: metricsText })
+      ] }, name);
+    }) }),
+    readOnly || !onSend ? /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: C.muted, children: "  watching as guest" }) }) : /* @__PURE__ */ jsx(Box, { paddingX: 1, flexDirection: "column", children: (() => {
+      const MAX_INPUT_LINES = 6;
+      const lines = (input || "").split("\n");
+      let charsSoFar = 0;
+      let cursorLine = lines.length - 1;
+      let cursorCol = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const lineEnd = charsSoFar + lines[i].length;
+        if (cursorPos <= lineEnd) {
+          cursorLine = i;
+          cursorCol = cursorPos - charsSoFar;
+          break;
+        }
+        charsSoFar += lines[i].length + 1;
+      }
+      let scrollTop = 0;
+      if (lines.length > MAX_INPUT_LINES) {
+        scrollTop = Math.min(
+          Math.max(0, cursorLine - Math.floor(MAX_INPUT_LINES / 2)),
+          lines.length - MAX_INPUT_LINES
+        );
+      }
+      const visibleLines = lines.slice(scrollTop, scrollTop + MAX_INPUT_LINES);
+      const hasMore = lines.length > MAX_INPUT_LINES;
+      return /* @__PURE__ */ jsxs(Fragment, { children: [
+        hasMore && scrollTop > 0 && /* @__PURE__ */ jsx(Box, { width: Math.max(0, cols - 2), children: /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+          "  \u2191 ",
+          scrollTop,
+          " more line",
+          scrollTop > 1 ? "s" : ""
+        ] }) }),
+        visibleLines.map((line, vi) => {
+          const i = scrollTop + vi;
+          return /* @__PURE__ */ jsxs(Box, { width: Math.max(0, cols - 2), children: [
+            /* @__PURE__ */ jsx(Text, { color: fightMode ? "#f87171" : C.cyan, bold: true, children: i === 0 ? fightMode ? "\u2694 " : "\u203A " : "  " }),
+            /* @__PURE__ */ jsxs(Text, { wrap: "wrap", children: [
+              i === cursorLine ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(Text, { children: line.slice(0, cursorCol) }),
+                /* @__PURE__ */ jsx(Text, { inverse: true, children: cursorCol < line.length ? line[cursorCol] : " " }),
+                /* @__PURE__ */ jsx(Text, { children: cursorCol < line.length ? line.slice(cursorCol + 1) : "" })
+              ] }) : line,
+              i === lines.length - 1 && cursorPos === input.length && suggestionState.ghostHint !== "" && /* @__PURE__ */ jsx(Text, { color: C.muted, children: suggestionState.ghostHint })
+            ] })
+          ] }, i);
+        }),
+        hasMore && scrollTop + MAX_INPUT_LINES < lines.length && /* @__PURE__ */ jsx(Box, { width: Math.max(0, cols - 2), children: /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+          "  \u2193 ",
+          lines.length - scrollTop - MAX_INPUT_LINES,
+          " more line",
+          lines.length - scrollTop - MAX_INPUT_LINES > 1 ? "s" : ""
+        ] }) })
+      ] });
+    })() }),
+    suggestions.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 1, children: suggestions.map((s, i) => {
+      const selected = i === selectedIndex;
+      if (s.kind === "command") {
+        const paramHint = s.cmd.params ? " " + s.cmd.params.map((p) => `<${p.label}>`).join(" ") : "";
+        const display = s.cmd.name + paramHint;
+        return /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: selected ? C.cyan : C.muted, children: selected ? "\u203A " : "  " }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { color: selected ? C.cyan : C.secondary, bold: selected, children: s.cmd.name }),
+            /* @__PURE__ */ jsx(Text, { color: C.muted, children: paramHint.padEnd(CMD_DISPLAY_COL - display.length + paramHint.length) })
+          ] }),
+          /* @__PURE__ */ jsx(Text, { color: C.dim, children: s.cmd.description })
+        ] }, s.cmd.name);
+      }
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: selected ? C.cyan : C.muted, children: selected ? "\u203A " : "  " }),
+        s.kind === "mention" && /* @__PURE__ */ jsx(Text, { color: C.dim, children: "@" }),
+        /* @__PURE__ */ jsx(Text, { color: selected ? C.cyan : C.secondary, bold: selected, children: s.value })
+      ] }, s.value);
+    }) })
+  ] });
+}
+function startTUI(opts) {
+  let handle = null;
+  const queue = [];
+  const onReady = (h) => {
+    handle = h;
+    for (const event of queue.splice(0)) h.push(event);
+  };
+  const { unmount } = render(
+    /* @__PURE__ */ jsx(
+      App,
+      {
+        roomName: opts.roomName,
+        onSend: opts.onSend,
+        onCtrlC: opts.onCtrlC,
+        onWatchAgent: opts.onWatchAgent,
+        onReady,
+        readOnly: opts.readOnly,
+        authority: opts.authority,
+        initialSound: opts.soundEnabled ?? true
+      }
+    ),
+    { exitOnCtrlC: false }
+  );
+  return {
+    push(event) {
+      if (handle) handle.push(event);
+      else queue.push(event);
+    },
+    clear() {
+      handle?.clear();
+    },
+    setAgentNames(names) {
+      handle?.setAgentNames(names);
+    },
+    setParticipants(names) {
+      handle?.setParticipants(names);
+    },
+    toggleSound() {
+      return handle?.toggleSound() ?? false;
+    },
+    setAgentState(name, state, opts2) {
+      handle?.setAgentState(name, state, opts2);
+    },
+    setAgentActivity(name, label) {
+      handle?.setAgentActivity(name, label);
+    },
+    setAgentMetrics(name, m) {
+      handle?.setAgentMetrics(name, m);
+    },
+    stop() {
+      unmount();
+    }
+  };
+}
+
+// src/cli/watch.ts
+import { execFileSync, spawn } from "child_process";
+import { existsSync } from "fs";
+function resolveTmuxPath(env = process.env) {
+  try {
+    const found = execFileSync("which", ["tmux"], { encoding: "utf-8", env }).trim();
+    if (found) return found;
+  } catch {
+  }
+  for (const candidate of ["/opt/homebrew/bin/tmux", "/usr/local/bin/tmux", "/usr/bin/tmux"]) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function osaQuote(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+var LAUNCHERS = [
+  {
+    kind: "iterm",
+    available: (env) => env.TERM_PROGRAM === "iTerm.app" || existsSync("/Applications/iTerm.app"),
+    argv: (command) => [
+      "osascript",
+      "-e",
+      `tell application "iTerm"
+  create window with default profile command "${osaQuote(command)}"
+  activate
+end tell`
+    ]
+  },
+  {
+    kind: "ghostty",
+    available: (env) => env.TERM_PROGRAM === "ghostty" || existsSync("/Applications/Ghostty.app"),
+    argv: (command) => ["open", "-na", "Ghostty", "--args", "-e", command]
+  },
+  {
+    kind: "wezterm",
+    available: () => commandExists("wezterm"),
+    argv: (command) => ["wezterm", "start", "--", "sh", "-c", command]
+  },
+  {
+    kind: "kitty",
+    available: () => commandExists("kitty"),
+    argv: (command) => ["kitty", "sh", "-c", command]
+  },
+  {
+    kind: "alacritty",
+    available: () => commandExists("alacritty"),
+    argv: (command) => ["alacritty", "-e", "sh", "-c", command]
+  },
+  {
+    // Last resort: every mac has it, but it steals focus and ignores profiles.
+    kind: "apple-terminal",
+    available: () => existsSync("/System/Applications/Utilities/Terminal.app") || existsSync("/Applications/Utilities/Terminal.app"),
+    argv: (command) => [
+      "osascript",
+      "-e",
+      `tell application "Terminal"
+  do script "${osaQuote(command)}"
+  activate
+end tell`
+    ]
+  }
+];
+function commandExists(bin) {
+  try {
+    execFileSync("which", [bin], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pickTerminal(env = process.env, launchers = LAUNCHERS) {
+  const current = launchers.find((l) => l.kind === terminalFromEnv(env));
+  if (current?.available(env)) return current;
+  return launchers.find((l) => l.available(env)) ?? null;
+}
+function terminalFromEnv(env = process.env) {
+  switch (env.TERM_PROGRAM) {
+    case "iTerm.app":
+      return "iterm";
+    case "Apple_Terminal":
+      return "apple-terminal";
+    case "ghostty":
+      return "ghostty";
+    case "WezTerm":
+      return "wezterm";
+    default:
+      break;
+  }
+  if (env.KITTY_WINDOW_ID) return "kitty";
+  if (env.ALACRITTY_WINDOW_ID) return "alacritty";
+  return null;
+}
+function watchCommand(tmuxPath, tmuxSession, opts) {
+  const flags = opts?.control ? ["attach"] : ["attach", "-r"];
+  return [tmuxPath, ...flags, "-t", tmuxSession].join(" ");
+}
+function openAgentWatcher(tmuxSession, opts) {
+  const env = opts?.env ?? process.env;
+  const tmuxPath = resolveTmuxPath(env);
+  if (!tmuxPath) return { ok: false, reason: "tmux not found" };
+  const launcher = pickTerminal(env);
+  if (!launcher) return { ok: false, reason: "no supported terminal found" };
+  const [bin, ...args] = launcher.argv(watchCommand(tmuxPath, tmuxSession, opts));
+  try {
+    const child = spawn(bin, args, { detached: true, stdio: "ignore" });
+    child.unref();
+  } catch {
+    return { ok: false, reason: `could not launch ${launcher.kind}` };
+  }
+  return { ok: true, terminal: launcher.kind, readOnly: !opts?.control };
+}
+
+// src/cli/join.ts
+function formatTimestamp(date) {
+  const h = String(date.getHours()).padStart(2, "0");
+  const m = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  return `${h}:${m}:${s}`;
+}
+var HEADLESS_READY = "apiary: ready";
+function persistAgentModel(roomName, alias, model) {
+  const session = listRoomSessions().find((s) => s.roomName === roomName);
+  if (!session?.participants) return;
+  const p = session.participants.find((x) => x.alias === alias);
+  if (!p) return;
+  p.model = model;
+  saveRoomSession(session);
+}
+function sendSlashToAgent(session, slashCommand) {
+  tmuxInjectText(session, slashCommand);
+  tmuxSendEnter(session);
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 80);
+  tmuxSendEnter(session);
+}
+function findAgentTmuxSession(agentName) {
+  const wanted = agentName.toLowerCase();
+  for (const runtime of ["claude", "codex"]) {
+    for (const s of listAgentSessions(runtime)) {
+      if (s.agentName.toLowerCase() !== wanted) continue;
+      if (!isAgentAlive(s)) return null;
+      return s.tmuxSession ?? `apiary_${s.agentName}`;
+    }
+  }
+  return null;
+}
+async function join(options) {
+  const token = extractToken(options.server);
+  let serverUrl;
+  try {
+    const parsed = new URL(options.server);
+    parsed.search = "";
+    serverUrl = parsed.toString().replace(/\/$/, "");
+  } catch {
+    serverUrl = options.server.replace(/\/$/, "");
+  }
+  const name = options.name ?? randomName();
+  const isGuest = options.guest ?? false;
+  let sessionToken;
+  let participantId;
+  let roomName;
+  let authority;
+  let participants;
+  try {
+    const joinBody = {};
+    if (token) {
+      joinBody.token = token;
+      joinBody.type = "human";
+      joinBody.name = name;
+    } else if (isGuest) {
+      joinBody.type = "guest";
+    } else {
+      joinBody.type = "human";
+      joinBody.name = name;
+    }
+    const res = await fetch(`${serverUrl}/join`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(joinBody)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      console.error(`Failed to join: ${err}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    sessionToken = String(data.sessionToken ?? "");
+    participantId = String(data.participantId);
+    roomName = String(data.roomName);
+    authority = data.authority ?? "member";
+    participants = data.participants ?? [];
+  } catch (err) {
+    console.error(`Cannot reach apiary server at ${serverUrl}. Is it running?`);
+    console.error(`  Error: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+  let disconnected = false;
+  let cleanupStream = null;
+  const disconnect = async () => {
+    if (disconnected) return;
+    disconnected = true;
+    cleanupStream?.();
+    try {
+      await fetch(`${serverUrl}/disconnect`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` },
+        body: JSON.stringify({})
+      });
+    } catch {
+    }
+  };
+  if (options.headless) {
+    const sseController = new AbortController();
+    const cleanup = async () => {
+      sseController.abort();
+      await disconnect();
+    };
+    process.on("SIGINT", async () => {
+      await cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      await cleanup();
+      process.exit(0);
+    });
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    rl.on("line", async (line) => {
+      const content = line.trim();
+      if (!content || authority === "guest") return;
+      try {
+        await fetch(`${serverUrl}/message`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` },
+          body: JSON.stringify({ content })
+        });
+      } catch {
+      }
+    });
+    try {
+      const res = await fetch(`${serverUrl}/events`, {
+        method: "POST",
+        headers: { Accept: "text/event-stream", Authorization: `Bearer ${sessionToken}` },
+        signal: sseController.signal
+      });
+      if (!res.ok || !res.body) {
+        process.stderr.write("Failed to connect event stream\n");
+        await cleanup();
+        process.exit(1);
+      }
+      process.stderr.write(`${HEADLESS_READY} ${roomName}
+`);
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buf = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        const parts = buf.split("\n\n");
+        buf = parts.pop();
+        for (const part of parts) {
+          const dataLine = part.split("\n").find((l) => l.startsWith("data: "));
+          if (!dataLine) continue;
+          try {
+            const event = JSON.parse(dataLine.slice(6));
+            process.stdout.write(JSON.stringify(event) + "\n");
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    if (!disconnected) {
+      await cleanup();
+    }
+    process.exit(0);
+  }
+  const isReadOnly = authority === "guest" || isGuest;
+  function systemEvent(content) {
+    tui.push({
+      id: randomUUID(),
+      ts: formatTimestamp(/* @__PURE__ */ new Date()),
+      kind: "system",
+      content
+    });
+  }
+  async function resolveParticipant(name2) {
+    try {
+      const res = await fetch(`${serverUrl}/participants`, { headers: { Authorization: `Bearer ${sessionToken}` } });
+      if (!res.ok) {
+        systemEvent("Failed to get participant list.");
+        return null;
+      }
+      const data = await res.json();
+      const target = data.participants.find((p) => p.name.toLowerCase() === name2.toLowerCase());
+      if (!target) {
+        systemEvent(`Participant "${name2}" not found.`);
+        return null;
+      }
+      return target;
+    } catch {
+      systemEvent("Failed to reach server.");
+      return null;
+    }
+  }
+  async function participantAction(opts) {
+    try {
+      const res = await fetch(`${serverUrl}${opts.path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` },
+        body: JSON.stringify(opts.body)
+      });
+      if (!res.ok) {
+        systemEvent(`Failed to ${opts.failVerb}: ${await res.text()}`);
+        return;
+      }
+      systemEvent(opts.success);
+    } catch {
+      systemEvent("Failed to reach server.");
+    }
+  }
+  async function handleSlashCommand(input) {
+    const parts = input.slice(1).split(/\s+/);
+    const cmd = parts[0]?.toLowerCase();
+    const args = parts.slice(1);
+    switch (cmd) {
+      // ── /help ─────────────────────────────────────────────────────
+      case "help": {
+        const lines = [
+          "/who              list participants",
+          "/ping <name>      ping for a status check",
+          "/peek <name>      show how to view an agent's tmux session",
+          "/share            generate share links",
+          "/sound            toggle notification sounds",
+          "/leave            disconnect"
+        ];
+        if (authority === "product_owner") {
+          lines.push(
+            "",
+            "/mute <name>      demote to guest",
+            "/unmute <name>    restore to member",
+            "/setmode <n> <m>  set engagement mode"
+          );
+        }
+        if (authority === "admin") {
+          lines.push(
+            "",
+            "/promote <name>   promote to product owner",
+            "/demote <name>    demote to member",
+            "/kick <name>      remove a participant",
+            "/mute <name>      demote to guest",
+            "/unmute <name>    restore to member",
+            "/setmode <n> <m>  set engagement mode",
+            "/clear            wipe room history",
+            "/clear <name>     clear an agent's claude context",
+            "/model <n> <id>   swap an agent's model (sonnet/opus/haiku)",
+            "/tunnel           start cloudflared tunnel"
+          );
+        }
+        systemEvent(lines.join("\n"));
+        return;
+      }
+      // ── /watch ────────────────────────────────────────────────────
+      // Opens the agent's tmux session in a NEW terminal window. The room TUI
+      // is untouched and stays usable — this attaches a second client rather
+      // than moving the agent's pane anywhere.
+      case "watch": {
+        const target = args[0];
+        if (!target) {
+          systemEvent("Usage: /watch <agent> [--control]   (read-only unless --control)");
+          return;
+        }
+        const control = args.includes("--control");
+        const session = findAgentTmuxSession(target);
+        if (!session) {
+          systemEvent(
+            `No local tmux session for "${target}". /watch only works for agents started on this machine by apiary claude/codex.`
+          );
+          return;
+        }
+        const res = openAgentWatcher(session, { control });
+        systemEvent(
+          res.ok ? `Opened ${target} in a new ${res.terminal} window (${res.readOnly ? "read-only" : "INTERACTIVE \u2014 your keystrokes go to the agent"}).` : `Could not open a window for ${target}: ${res.reason}`
+        );
+        return;
+      }
+      // ── /who ──────────────────────────────────────────────────────
+      case "who": {
+        try {
+          const res = await fetch(`${serverUrl}/participants`, { headers: { Authorization: `Bearer ${sessionToken}` } });
+          if (!res.ok) {
+            systemEvent("Failed to get participant list.");
+            return;
+          }
+          const data = await res.json();
+          const lines = data.participants.map((p) => {
+            const auth = p.authority ?? "member";
+            const label = auth === "product_owner" ? "owner" : auth;
+            return `  ${p.type === "agent" ? "agent" : "human"} ${p.name} (${label})`;
+          });
+          systemEvent(`Participants:
+${lines.join("\n")}`);
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      // ── /peek ─────────────────────────────────────────────────────
+      // Capture a snapshot of the agent's tmux pane and render it inline.
+      // For sustained interactive viewing the user can still `tmux attach`
+      // (hint printed below), but the common case — "what is this agent
+      // showing right now?" — is answered with a single keystroke.
+      case "peek": {
+        const name2 = args[0];
+        if (!name2) {
+          systemEvent("Usage: /peek <name>");
+          return;
+        }
+        const session = `apiary_${name2}`;
+        if (!tmuxSessionExists(session)) {
+          systemEvent(
+            `No local tmux session for "${name2}" (apiary_${name2} not found).
+This is normal for agents on another host \u2014 peek only works for local same-host agents.`
+          );
+          return;
+        }
+        const lines = tmuxCapturePane(session);
+        let lastIdx = lines.length - 1;
+        while (lastIdx >= 0 && lines[lastIdx].trim() === "") lastIdx--;
+        const tail = lines.slice(Math.max(0, lastIdx - 24), lastIdx + 1);
+        if (tail.length === 0) {
+          systemEvent(`Peek ${name2}: pane is empty.`);
+          return;
+        }
+        systemEvent(
+          `Peek ${name2} (last ${tail.length} lines):
+` + tail.map((l) => "\u2502 " + l).join("\n") + `
+For interactive view: detach apiary (Ctrl+C \xD72) then tmux attach -t ${session} (Ctrl+B D to leave the agent).`
+        );
+        return;
+      }
+      // ── /rules ────────────────────────────────────────────────────
+      // Read-only display of the room's current rules. Any participant
+      // (including guests) can view.
+      case "rules": {
+        try {
+          const res = await fetch(`${serverUrl}/rules`, { headers: { Authorization: `Bearer ${sessionToken}` } });
+          if (!res.ok) {
+            systemEvent("Failed to fetch rules.");
+            return;
+          }
+          const data = await res.json();
+          if (data.rules.length === 0) {
+            systemEvent("No rules set for this room.");
+            return;
+          }
+          const lines = ["Room rules:"];
+          data.rules.forEach((r, i) => lines.push(`  ${i + 1}. ${r}`));
+          systemEvent(lines.join("\n"));
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      // ── /leave ────────────────────────────────────────────────────
+      case "leave": {
+        await disconnect();
+        tui.stop();
+        process.exit(0);
+        return;
+      }
+      // ── /kick <name> (admin only) ─────────────────────────────────
+      case "kick": {
+        if (!can(authority, "kick")) {
+          systemEvent("Only admins can kick.");
+          return;
+        }
+        const targetName = args[0];
+        if (!targetName) {
+          systemEvent("Usage: /kick <name>");
+          return;
+        }
+        const target = await resolveParticipant(targetName);
+        if (!target) return;
+        await participantAction({
+          path: "/kick",
+          body: { participantId: target.id },
+          failVerb: "kick",
+          success: `Kicked ${targetName}.`
+        });
+        return;
+      }
+      // ── /mute <name> (admin or product_owner) — demote to guest ─────
+      case "mute": {
+        if (!can(authority, "mute")) {
+          systemEvent("Only admins and product owners can mute.");
+          return;
+        }
+        const targetName = args[0];
+        if (!targetName) {
+          systemEvent("Usage: /mute <name>");
+          return;
+        }
+        const target = await resolveParticipant(targetName);
+        if (!target) return;
+        await participantAction({
+          path: "/set-authority",
+          body: { participantId: target.id, authority: "guest" },
+          failVerb: "mute",
+          success: `Muted ${targetName} (guest).`
+        });
+        return;
+      }
+      // ── /unmute <name> (admin or product_owner) — restore to member ──
+      case "unmute": {
+        if (!can(authority, "unmute")) {
+          systemEvent("Only admins and product owners can unmute.");
+          return;
+        }
+        const targetName = args[0];
+        if (!targetName) {
+          systemEvent("Usage: /unmute <name>");
+          return;
+        }
+        const target = await resolveParticipant(targetName);
+        if (!target) return;
+        await participantAction({
+          path: "/set-authority",
+          body: { participantId: target.id, authority: "member" },
+          failVerb: "unmute",
+          success: `Unmuted ${targetName} (member).`
+        });
+        return;
+      }
+      // ── /setmode <name> <mode> (admin or product_owner) ──────────
+      case "setmode": {
+        if (!can(authority, "set_mode_for")) {
+          systemEvent("Only admins and product owners can set modes.");
+          return;
+        }
+        const targetName = args[0];
+        const mode = args[1];
+        if (!targetName || !mode) {
+          systemEvent("Usage: /setmode <name> <mode>");
+          return;
+        }
+        const target = await resolveParticipant(targetName);
+        if (!target) return;
+        await participantAction({
+          path: "/set-mode",
+          body: { participantId: target.id, mode },
+          failVerb: "set mode",
+          success: `Set ${targetName} to ${mode}.`
+        });
+        return;
+      }
+      // ── /promote <name> (admin only) — elevate to product_owner ──
+      case "promote": {
+        if (!can(authority, "promote")) {
+          systemEvent("Only admins can promote.");
+          return;
+        }
+        const targetName = args[0];
+        if (!targetName) {
+          systemEvent("Usage: /promote <name>");
+          return;
+        }
+        const target = await resolveParticipant(targetName);
+        if (!target) return;
+        await participantAction({
+          path: "/set-authority",
+          body: { participantId: target.id, authority: "product_owner" },
+          failVerb: "promote",
+          success: `${targetName} is now a product owner.`
+        });
+        return;
+      }
+      // ── /demote <name> (admin only) — restore product_owner to member ──
+      case "demote": {
+        if (!can(authority, "demote")) {
+          systemEvent("Only admins can demote.");
+          return;
+        }
+        const targetName = args[0];
+        if (!targetName) {
+          systemEvent("Usage: /demote <name>");
+          return;
+        }
+        const target = await resolveParticipant(targetName);
+        if (!target) return;
+        await participantAction({
+          path: "/set-authority",
+          body: { participantId: target.id, authority: "member" },
+          failVerb: "demote",
+          success: `${targetName} is now a member.`
+        });
+        return;
+      }
+      // ── /ping <name> ─────────────────────────────────────────────
+      case "ping": {
+        const targetName = args[0];
+        if (!targetName) {
+          systemEvent("Usage: /ping <name>");
+          return;
+        }
+        const target = await resolveParticipant(targetName);
+        if (!target) return;
+        await participantAction({
+          path: "/ping",
+          body: { participantId: target.id },
+          failVerb: "ping",
+          success: `Pinged ${targetName}.`
+        });
+        return;
+      }
+      // ── /share [--as <tier>] ──────────────────────────────────────
+      case "share": {
+        if (authority === "guest") {
+          systemEvent("Guests cannot create share links.");
+          return;
+        }
+        let targetAuthority;
+        if (args[0] === "--as" && args[1]) {
+          targetAuthority = args[1];
+        }
+        try {
+          const shareBody = {};
+          if (targetAuthority) shareBody.authority = targetAuthority;
+          const res = await fetch(`${serverUrl}/share`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` },
+            body: JSON.stringify(shareBody)
+          });
+          if (!res.ok) {
+            systemEvent(`Failed: ${await res.text()}`);
+            return;
+          }
+          const data = await res.json();
+          const lines = Object.entries(data.links).map(
+            ([tier, url]) => `  ${tier}: apiary join ${url}`
+          );
+          systemEvent(`Share links:
+${lines.join("\n")}`);
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      // ── /sound — toggle notification sounds ───────────────────────
+      case "sound": {
+        const enabled = tui.toggleSound();
+        const cfg = loadConfig();
+        cfg.sound = enabled;
+        saveConfig(cfg);
+        systemEvent(`Sound ${enabled ? "on" : "off"} (saved for future rooms).`);
+        return;
+      }
+      // ── /clear — wipe room history OR a specific agent's claude context
+      // /clear              → admin: wipe room history (storage + all clients)
+      // /clear <agent-name> → admin: inject /clear into the agent's tmux pane,
+      //                        clearing claude's local conversation. Frees
+      //                        token budget mid-session without restart.
+      case "clear": {
+        if (!can(authority, "clear_history")) {
+          systemEvent("Only admins can clear.");
+          return;
+        }
+        const targetName = args[0];
+        if (targetName) {
+          const session = `apiary_${targetName}`;
+          if (!tmuxSessionExists(session)) {
+            systemEvent(
+              `No local tmux session for "${targetName}". /clear <name> only works for same-host agents.`
+            );
+            return;
+          }
+          try {
+            sendSlashToAgent(session, "/clear");
+            systemEvent(`Sent /clear to ${targetName}.`);
+          } catch (err) {
+            systemEvent(`Failed to send /clear: ${err.message}`);
+          }
+          return;
+        }
+        try {
+          const res = await fetch(`${serverUrl}/clear`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` }
+          });
+          if (!res.ok) {
+            systemEvent(`Failed to clear: ${await res.text()}`);
+            return;
+          }
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      // ── /model — swap an agent's claude model mid-session ───────────
+      // /model <agent-name> <model-id>  e.g. /model bf sonnet
+      // Injects claude's built-in /model command into the agent's tmux. No
+      // restart — conversation continues at the new model.
+      case "model": {
+        if (!can(authority, "clear_history")) {
+          systemEvent("Only admins can swap models.");
+          return;
+        }
+        const targetName = args[0];
+        const modelId = args[1];
+        if (!targetName || !modelId) {
+          systemEvent("Usage: /model <agent> <model-id>");
+          return;
+        }
+        const session = `apiary_${targetName}`;
+        if (!tmuxSessionExists(session)) {
+          systemEvent(`No local tmux session for "${targetName}".`);
+          return;
+        }
+        try {
+          sendSlashToAgent(session, `/model ${modelId}`);
+          persistAgentModel(roomName, targetName, modelId);
+          systemEvent(`Sent /model ${modelId} to ${targetName} (will persist on resume).`);
+        } catch (err) {
+          systemEvent(`Failed to swap model: ${err.message}`);
+        }
+        return;
+      }
+      // ── /tunnel — start cloudflared tunnel mid-session ────────────
+      case "tunnel": {
+        if (!can(authority, "start_tunnel")) {
+          systemEvent("Only admins can start tunnels.");
+          return;
+        }
+        try {
+          const res = await fetch(`${serverUrl}/tunnel`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` }
+          });
+          if (!res.ok) {
+            systemEvent(`Failed: ${(await res.json()).error}`);
+            return;
+          }
+          const data = await res.json();
+          if (data.alreadyRunning) {
+            systemEvent(`Tunnel already running: ${data.url}`);
+          } else {
+            systemEvent(`Tunnel started: ${data.url}
+Use /share to generate share links.`);
+          }
+        } catch {
+          systemEvent("Failed to reach server.");
+        }
+        return;
+      }
+      default:
+        systemEvent(`Unknown command: /${cmd}`);
+    }
+  }
+  process.stdout.write(`\x1B]0;${roomEmoji(`${roomName}\xB7${name}`)} ${roomName} \xB7 ${name}\x07`);
+  if (options.shareUrl) {
+    console.log();
+    console.log(`  \x1B[2mShare:\x1B[0m \x1B[33m${options.shareUrl}\x1B[0m`);
+    console.log();
+    console.log(`  \x1B[2mJoin:\x1B[0m   \x1B[36mapiary join\x1B[0m \x1B[2m<url>\x1B[0m`);
+    console.log(`  \x1B[2mAgent:\x1B[0m  \x1B[36mapiary claude\x1B[0m \x1B[2m<name>  \u2192 tell it the URL, it joins\x1B[0m`);
+    console.log();
+  }
+  const config = loadConfig();
+  const tui = startTUI({
+    roomName,
+    readOnly: isReadOnly,
+    authority,
+    soundEnabled: config.sound ?? true,
+    onSend: isReadOnly ? void 0 : async (content) => {
+      if (content.startsWith("/")) {
+        await handleSlashCommand(content);
+        return;
+      }
+      try {
+        await fetch(`${serverUrl}/message`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` },
+          body: JSON.stringify({ content })
+        });
+      } catch {
+      }
+    },
+    onWatchAgent: (agentName) => {
+      const session = findAgentTmuxSession(agentName);
+      if (!session) {
+        systemEvent(
+          `No local tmux session for "${agentName}". Watching only works for agents started on this machine by apiary claude/codex.`
+        );
+        return;
+      }
+      const res = openAgentWatcher(session);
+      systemEvent(
+        res.ok ? `Opened ${agentName} in a new ${res.terminal} window (read-only). Use "/watch ${agentName} --control" to type into it.` : `Could not open a window for ${agentName}: ${res.reason}`
+      );
+    },
+    onCtrlC: /* @__PURE__ */ (() => {
+      let lastPress = 0;
+      const CONFIRM_MS = 2e3;
+      return async () => {
+        const now = Date.now();
+        if (now - lastPress < CONFIRM_MS) {
+          await disconnect();
+          tui.stop();
+          process.exit(0);
+        }
+        lastPress = now;
+        systemEvent("Press Ctrl+C again within 2s to leave (server keeps running).");
+      };
+    })()
+  });
+  if (!isReadOnly) {
+    const hint = authority === "admin" ? "/help for commands (admin)" : "/help for commands";
+    systemEvent(hint);
+  }
+  const agentNames = participants.filter((p) => p.type === "agent").map((p) => p.name);
+  const pendingAgentSet = new Set(
+    (options.expectedAgents ?? []).filter((n) => !agentNames.includes(n))
+  );
+  const renderAgentList = (joined) => {
+    const merged = /* @__PURE__ */ new Set([...joined, ...pendingAgentSet]);
+    tui.setAgentNames([...merged]);
+  };
+  if (agentNames.length + pendingAgentSet.size > 0) {
+    renderAgentList(agentNames);
+    for (const n of pendingAgentSet) tui.setAgentState(n, "pending");
+  }
+  if (agentNames.length > 0) {
+    const INIT_FRESHNESS_MS = 5 * 6e4;
+    try {
+      const msgRes = await fetch(`${serverUrl}/messages?count=20`, {
+        headers: { Authorization: `Bearer ${sessionToken}` }
+      });
+      if (msgRes.ok) {
+        const { items: messages } = await msgRes.json();
+        const agentSet = new Set(agentNames);
+        const idleAgents = /* @__PURE__ */ new Set();
+        let humanMsg = null;
+        for (const msg of messages) {
+          const sType = participants.find((p) => p.id === msg.sender_id)?.type;
+          if (sType === "agent" && agentSet.has(msg.sender_name)) {
+            idleAgents.add(msg.sender_name);
+          } else if (sType === "human") {
+            humanMsg = msg;
+            break;
+          }
+        }
+        const fresh = humanMsg?.timestamp ? Date.now() - new Date(humanMsg.timestamp).getTime() < INIT_FRESHNESS_MS : false;
+        if (humanMsg && fresh) {
+          const targetedAgents = humanMsg.recipients && humanMsg.recipients.length > 0 ? new Set(
+            participants.filter((p) => p.type === "agent" && humanMsg.recipients.includes(p.id)).map((p) => p.name)
+          ) : agentSet;
+          for (const agent of agentSet) {
+            if (idleAgents.has(agent)) {
+              tui.setAgentState(agent, "idle");
+            } else if (targetedAgents.has(agent)) {
+              tui.setAgentState(agent, "working");
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const participantNames = new Set(
+    participants.filter((p) => p.id !== participantId).map((p) => p.name)
+  );
+  tui.setParticipants([...participantNames]);
+  {
+    const participantTypes = /* @__PURE__ */ new Map();
+    const participantNameById = /* @__PURE__ */ new Map();
+    for (const p of participants) {
+      participantTypes.set(p.id, p.type);
+      participantNameById.set(p.id, p.name);
+    }
+    const currentAgents = new Set(agentNames);
+    const PING_DECAY_MS = 1e4;
+    let sseController = null;
+    cleanupStream = () => {
+      if (sseController) {
+        sseController.abort();
+        sseController = null;
+      }
+    };
+    const connectSSE = async () => {
+      sseController = new AbortController();
+      try {
+        const res = await fetch(`${serverUrl}/events`, {
+          method: "POST",
+          headers: {
+            Accept: "text/event-stream",
+            Authorization: `Bearer ${sessionToken}`
+          },
+          signal: sseController.signal
+        });
+        if (!res.ok || !res.body) {
+          console.error("Failed to connect event stream");
+          await disconnect();
+          process.exit(1);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const parts = buffer.split("\n\n");
+          buffer = parts.pop();
+          for (const part of parts) {
+            const dataLine = part.split("\n").find((l) => l.startsWith("data: "));
+            if (!dataLine) continue;
+            try {
+              const event = JSON.parse(dataLine.slice(6));
+              if (event.type === "RoomCleared") {
+                tui.clear();
+                systemEvent(`Room cleared by ${event.cleared_by ?? "admin"}.`);
+                continue;
+              }
+              if (event.type === "ParticipantJoined") {
+                participantTypes.set(event.participant.id, event.participant.type);
+              }
+              const displayEvent = toDisplayEvent(event, participantId, participantTypes);
+              if (displayEvent) {
+                tui.push(displayEvent);
+              }
+              if (event.type === "ParticipantJoined") {
+                participantNameById.set(event.participant.id, event.participant.name);
+                if (event.participant.type === "agent") {
+                  currentAgents.add(event.participant.name);
+                  pendingAgentSet.delete(event.participant.name);
+                  renderAgentList(currentAgents);
+                  tui.setAgentState(event.participant.name, "idle");
+                }
+                if (event.participant.id !== participantId) {
+                  participantNames.add(event.participant.name);
+                  tui.setParticipants([...participantNames]);
+                }
+              }
+              if (event.type === "MessageSent") {
+                const senderType = participantTypes.get(event.message.sender_id);
+                if (senderType === "agent" && currentAgents.has(event.message.sender_name)) {
+                  tui.setAgentState(event.message.sender_name, "idle");
+                } else if (senderType === "human") {
+                  const recipients = event.message.recipients ?? [];
+                  if (recipients.length > 0) {
+                    for (const recipientId of recipients) {
+                      const name2 = participantNameById.get(recipientId);
+                      if (name2 && currentAgents.has(name2)) {
+                        tui.setAgentState(name2, "working");
+                      }
+                    }
+                  } else {
+                    for (const agent of currentAgents) tui.setAgentState(agent, "working");
+                  }
+                }
+              }
+              if (event.type === "Pinged") {
+                const pinged = event;
+                if (pinged.participant_id) {
+                  const name2 = participantNameById.get(pinged.participant_id);
+                  if (name2 && currentAgents.has(name2)) {
+                    tui.setAgentState(name2, "working", { decayMs: PING_DECAY_MS });
+                  }
+                }
+              }
+              if (event.type === "Activity" && event.action === "status_label") {
+                const detail = event.detail ?? {};
+                const name2 = typeof detail.participant_name === "string" ? detail.participant_name : void 0;
+                const label = typeof detail.label === "string" ? detail.label : null;
+                const observed = detail.state === "idle" || detail.state === "working" || detail.state === "blocked" ? detail.state : void 0;
+                if (name2 && currentAgents.has(name2)) {
+                  tui.setAgentActivity(name2, label);
+                  if (observed) tui.setAgentState(name2, observed, { observed: true });
+                }
+              }
+              if (event.type === "Activity" && event.action === "metrics") {
+                const detail = event.detail ?? {};
+                const name2 = typeof detail.participant_name === "string" ? detail.participant_name : void 0;
+                if (name2 && currentAgents.has(name2)) {
+                  tui.setAgentMetrics(name2, {
+                    ctxTokens: Number(detail.last_ctx_tokens) || 0,
+                    model: typeof detail.model === "string" ? detail.model : void 0
+                  });
+                }
+              }
+              if (event.type === "StatusChanged") {
+                const sc = event;
+                if (currentAgents.has(sc.name)) {
+                  if (sc.status === "unresponsive") {
+                    tui.setAgentState(sc.name, "unresponsive");
+                  } else if (sc.status === "online" && sc.previous_status === "unresponsive") {
+                    tui.setAgentState(sc.name, "idle");
+                  }
+                }
+              }
+              if (event.type === "ParticipantLeft" || event.type === "ParticipantKicked") {
+                if (event.participant.type === "agent") {
+                  currentAgents.delete(event.participant.name);
+                  renderAgentList(currentAgents);
+                }
+                participantTypes.delete(event.participant.id);
+                participantNameById.delete(event.participant.id);
+                participantNames.delete(event.participant.name);
+                tui.setParticipants([...participantNames]);
+              }
+            } catch {
+            }
+          }
+        }
+        if (!disconnected) {
+          tui.stop();
+          console.log("\nServer disconnected.");
+          process.exit(0);
+        }
+      } catch {
+        if (!disconnected) {
+          tui.stop();
+          console.log("\nServer disconnected.");
+          process.exit(0);
+        }
+      }
+    };
+    connectSSE();
+  }
+  process.on("SIGINT", async () => {
+    await disconnect();
+    tui.stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await disconnect();
+    tui.stop();
+    process.exit(0);
+  });
+}
+function toDisplayEvent(event, selfId, participantTypes) {
+  const ts = formatTimestamp(new Date(event.timestamp));
+  switch (event.type) {
+    case "MessageSent": {
+      const msg = event.message;
+      const senderType = participantTypes.get(msg.sender_id) ?? "human";
+      return {
+        id: msg.id,
+        ts,
+        kind: "message",
+        senderName: msg.sender_name,
+        senderType,
+        isSelf: msg.sender_id === selfId,
+        content: msg.content,
+        replyToName: event._replyToName ?? void 0
+      };
+    }
+    case "ParticipantJoined":
+      return {
+        id: randomUUID(),
+        ts,
+        kind: "join",
+        name: event.participant.name,
+        participantType: event.participant.type
+      };
+    case "ParticipantLeft":
+      return {
+        id: randomUUID(),
+        ts,
+        kind: "leave",
+        name: event.participant.name,
+        participantType: event.participant.type
+      };
+    case "ParticipantKicked":
+      return {
+        id: randomUUID(),
+        ts,
+        kind: "system",
+        content: `${event.participant.name} was kicked`
+      };
+    case "AuthorityChanged": {
+      const name = event.participant.name;
+      if (event.new_authority === "guest") {
+        return { id: randomUUID(), ts, kind: "system", content: `${name} was muted` };
+      }
+      if (event.new_authority === "member") {
+        return { id: randomUUID(), ts, kind: "system", content: `${name} was unmuted` };
+      }
+      if (event.new_authority === "product_owner") {
+        return { id: randomUUID(), ts, kind: "system", content: `${name} was promoted to product owner` };
+      }
+      return { id: randomUUID(), ts, kind: "system", content: `${name} \u2192 ${event.new_authority}` };
+    }
+    case "Pinged":
+      return {
+        id: randomUUID(),
+        ts,
+        kind: "ping",
+        pingerName: event.pinger_name ?? "someone"
+      };
+    case "Activity":
+      if (event.action === "mode_changed") {
+        return {
+          id: randomUUID(),
+          ts,
+          kind: "mode",
+          mode: String(event.detail?.mode ?? "")
+        };
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+
+export {
+  HEADLESS_READY,
+  join
+};
+//# sourceMappingURL=chunk-ED6ROH6B.js.map