arp-tui 0.0.1 → 0.0.3

package/dist/index.js

@@ -5,7 +5,7 @@ import { parseArgs as nodeParseArgs } from "util";
 import { render } from "ink";
 
 // src/app.tsx
-import { Box as Box6, Text as Text8, useApp, useInput, useStdin } from "ink";
+import { Box as Box8, Text as Text10, useApp, useInput, useStdin } from "ink";
 import { useEffect, useSyncExternalStore } from "react";
 
 // src/state/store.ts
@@ -180,7 +180,9 @@ Profiles defined: ${Object.keys(profiles).join(", ")}. Fix "profile" or add the
     profile: requested,
     profiles,
     lastChannelId: typeof cfg["lastChannelId"] === "string" ? cfg["lastChannelId"] : void 0,
-    lastSeq: cfg["lastSeq"] && typeof cfg["lastSeq"] === "object" ? cfg["lastSeq"] : {}
+    lastSeq: cfg["lastSeq"] && typeof cfg["lastSeq"] === "object" ? cfg["lastSeq"] : {},
+    unread: cfg["unread"] && typeof cfg["unread"] === "object" ? cfg["unread"] : {},
+    lastSeen: cfg["lastSeen"] && typeof cfg["lastSeen"] === "object" ? cfg["lastSeen"] : {}
   };
 }
 function resolveProfile(cfg, overrides) {
@@ -205,6 +207,61 @@ function resolveProfile(cfg, overrides) {
 function saveConfig(cfg) {
   writeFileAtomic0600(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n");
 }
+var PROFILE_NAME_RE = /^[A-Za-z0-9._-]+$/;
+function assertValidProfileName(name) {
+  if (!PROFILE_NAME_RE.test(name)) {
+    throw new ConfigError(
+      `invalid profile name "${name}" \u2014 use letters, digits, dot, dash or underscore only.`
+    );
+  }
+}
+function listProfiles() {
+  const cfg = loadConfig();
+  return { active: cfg.profile, profiles: cfg.profiles };
+}
+function addProfile(name, raw) {
+  assertValidProfileName(name);
+  const cfg = loadConfig();
+  if (Object.hasOwn(cfg.profiles, name)) {
+    throw new ConfigError(
+      `profile "${name}" already exists (${cfg.profiles[name].relayUrl}).
+Remove it first (arp-tui profile remove ${name}) or choose another name.`
+    );
+  }
+  const profile = normalizeProfile(name, raw);
+  cfg.profiles[name] = profile;
+  saveConfig(cfg);
+  return profile;
+}
+function switchProfile(name) {
+  const cfg = loadConfig();
+  if (!Object.hasOwn(cfg.profiles, name)) {
+    throw new ConfigError(
+      `profile "${name}" does not exist. Defined: ${Object.keys(cfg.profiles).join(", ")}.`
+    );
+  }
+  cfg.profile = name;
+  saveConfig(cfg);
+  return cfg.profiles[name];
+}
+function removeProfile(name) {
+  const cfg = loadConfig();
+  if (!Object.hasOwn(cfg.profiles, name)) {
+    throw new ConfigError(
+      `profile "${name}" does not exist. Defined: ${Object.keys(cfg.profiles).join(", ")}.`
+    );
+  }
+  if (Object.keys(cfg.profiles).length === 1) {
+    throw new ConfigError(`cannot remove the only profile "${name}".`);
+  }
+  if (cfg.profile === name) {
+    throw new ConfigError(
+      `cannot remove the active profile "${name}" \u2014 switch to another first (arp-tui profile switch <name>).`
+    );
+  }
+  delete cfg.profiles[name];
+  saveConfig(cfg);
+}
 function assertStorePerms() {
   ensureDir0700(CONFIG_DIR);
   const problems = [
@@ -724,8 +781,6 @@ async function logout(instance2, log = console.error) {
 }
 
 // src/api/clerkRefresh.ts
-var DEFAULT_CLERK_FAPI = "https://generous-fish-48.clerk.accounts.dev";
-var DEFAULT_JWT_TEMPLATE = "arp";
 var CACHE_TTL_MS = 45e3;
 var FAPI_TIMEOUT_MS = 1e4;
 var ClerkRefreshError = class extends Error {
@@ -734,9 +789,9 @@ var ClerkRefreshError = class extends Error {
     this.name = "ClerkRefreshError";
   }
 };
-function createClerkTokenSupplier(clientToken, opts = {}) {
-  const fapi = (opts.fapiUrl ?? process.env["ARP_TUI_CLERK_FAPI"] ?? DEFAULT_CLERK_FAPI).replace(/\/$/, "");
-  const template = opts.template ?? DEFAULT_JWT_TEMPLATE;
+function createClerkTokenSupplier(clientToken, opts) {
+  const fapi = opts.fapiUrl.replace(/\/$/, "");
+  const template = opts.template;
   let cached = null;
   let sessionId = null;
   async function fapiFetch(path3, method) {
@@ -893,8 +948,121 @@ var RelayRest = class {
   async setPresence(status) {
     await this.req("POST", "/presence", { status });
   }
+  /** GET /attention — cross-channel unacked attention summaries (best-effort caller) */
+  async getAttention() {
+    const data = await this.req("GET", "/attention");
+    return data.attention ?? [];
+  }
+  /** GET /notifications — human-only; newest-first, <=50 */
+  async getNotifications() {
+    const data = await this.req("GET", "/notifications");
+    return data.notifications ?? [];
+  }
+  /** POST /notifications/read-all */
+  async markAllNotificationsRead() {
+    await this.req("POST", "/notifications/read-all", {});
+  }
+  /** POST /notifications/{id}/dismiss — archives one; 404 for not-yours/nonexistent (G3) */
+  async dismissNotification(id) {
+    await this.req("POST", `/notifications/${encodeURIComponent(id)}/dismiss`, {});
+  }
 };
 
+// src/state/activityFold.ts
+function eventTs(e) {
+  return typeof e.ts === "number" && Number.isFinite(e.ts) ? e.ts : 0;
+}
+function supersedes(nextTs, nextOrder, prevTs, prevOrder) {
+  if (nextTs !== prevTs) return nextTs > prevTs;
+  return nextOrder >= prevOrder;
+}
+function foldActivityEvents(events) {
+  const turns = /* @__PURE__ */ new Map();
+  events.forEach((e, idx) => {
+    if (!e.turnId || !e.toolCallId) return;
+    let turn = turns.get(e.turnId);
+    if (!turn) {
+      turn = { order: [], calls: /* @__PURE__ */ new Map() };
+      turns.set(e.turnId, turn);
+    }
+    const ts = eventTs(e);
+    const existing = turn.calls.get(e.toolCallId);
+    if (!existing) {
+      turn.order.push(e.toolCallId);
+      turn.calls.set(e.toolCallId, {
+        toolCallId: e.toolCallId,
+        turnId: e.turnId,
+        agentId: e.agentId,
+        kind: e.kind,
+        title: e.title,
+        status: e.status,
+        locations: e.locations,
+        ts,
+        _winTs: ts,
+        _winOrder: idx
+      });
+      return;
+    }
+    if (supersedes(ts, idx, existing._winTs, existing._winOrder)) {
+      if (e.kind !== void 0) existing.kind = e.kind;
+      if (e.title !== void 0) existing.title = e.title;
+      if (e.status !== void 0) existing.status = e.status;
+      if (e.locations !== void 0) existing.locations = e.locations;
+      if (e.agentId) existing.agentId = e.agentId;
+      existing.ts = ts;
+      existing._winTs = ts;
+      existing._winOrder = idx;
+    } else {
+      if (existing.kind === void 0 && e.kind !== void 0) existing.kind = e.kind;
+      if (existing.title === void 0 && e.title !== void 0) existing.title = e.title;
+      if (existing.status === void 0 && e.status !== void 0) existing.status = e.status;
+      if (existing.locations === void 0 && e.locations !== void 0) existing.locations = e.locations;
+    }
+  });
+  const out = /* @__PURE__ */ new Map();
+  for (const [turnId, turn] of turns) {
+    out.set(
+      turnId,
+      turn.order.map((tcId) => {
+        const c = turn.calls.get(tcId);
+        const { _winTs, _winOrder, ...pub } = c;
+        void _winTs;
+        void _winOrder;
+        return pub;
+      })
+    );
+  }
+  return out;
+}
+
+// src/state/priority.ts
+function channelPriority(cid, p) {
+  const level = p.attention[cid]?.highestLevel;
+  if (level === "critical") return 0;
+  if (level === "action_required") return 1;
+  if (level === "info") return 2;
+  if ((p.unread[cid] ?? 0) > 0) return 3;
+  return 4;
+}
+function sortChannelsByPriority(channels, p) {
+  return channels.map((c, i) => ({ c, pri: channelPriority(c.id, p), i })).sort((a, b) => a.pri - b.pri || a.i - b.i).map((x) => x.c);
+}
+function nextActiveChannel(channels, activeId, p) {
+  const ordered = sortChannelsByPriority(
+    channels.filter((c) => channelPriority(c.id, p) < 4),
+    p
+  );
+  if (ordered.length === 0) return null;
+  const idx = ordered.findIndex((c) => c.id === activeId);
+  if (idx === -1) {
+    return ordered[0] ?? null;
+  }
+  const next = ordered[(idx + 1) % ordered.length];
+  if (!next) return null;
+  if (next.id === activeId) return null;
+  return next;
+}
+
 // src/api/ws.ts
 import { appendFileSync } from "fs";
 import WebSocket from "ws";
@@ -1134,6 +1302,10 @@ var IDLE_CHECK_MS = 3e4;
 var TICK_MS = 1e4;
 var ACTIVITY_AUTOCLEAR_MS = 6e4;
 var RENDER_THROTTLE_MS = 250;
+var MAX_ACTIVITY_TURNS = 8;
+var MAX_TOOL_CALLS_PER_TURN = 50;
+var MAX_RAW_EVENTS_PER_TURN = 200;
+var ACTIVITY_SETTLE_MS = 4e3;
 function createStore(opts) {
   const instance2 = opts.instance;
   const relayUrl = instance2.relayUrl;
@@ -1166,7 +1338,16 @@ function createStore(opts) {
     // "on" only once it actually mints (getToken flips it)
     clerkRefresh: creds?.clerkClientToken && creds.tokenType !== "oauth" ? "on" : "off",
     tokenPrompt: "",
-    tokenPromptReason: null
+    tokenPromptReason: null,
+    unread: { ...config.unread ?? {} },
+    unreadCapNotice: null,
+    attention: {},
+    notifications: [],
+    notifSelected: 0,
+    activityByTurn: {},
+    plansByTurn: {},
+    activityPinned: false,
+    activityIdleSince: null
   };
   let lastNotifyAt = 0;
   let notifyTimer = null;
@@ -1345,6 +1526,75 @@ function createStore(opts) {
     });
     return fresh.length;
   }
+  const WS_SUB_CAP = 256;
+  function bumpUnread(channelId) {
+    if (channelId === state.activeChannelId) return;
+    const next = (state.unread[channelId] ?? 0) + 1;
+    const unread = { ...state.unread, [channelId]: next };
+    config = { ...config, unread };
+    saveConfigSoon();
+    setThrottled({ unread });
+  }
+  function clearUnread(channelId) {
+    const lastSeen = { ...config.lastSeen ?? {}, [channelId]: (/* @__PURE__ */ new Date()).toISOString() };
+    const unread = { ...state.unread };
+    delete unread[channelId];
+    config = { ...config, unread, lastSeen };
+    saveConfigSoon();
+    set({ unread });
+  }
+  const ATTENTION_POLL_MS = 3e4;
+  const NOTIF_POLL_MS = 6e4;
+  let attentionTimer = null;
+  let notifTimer = null;
+  async function pollAttention() {
+    try {
+      const list = await rest.getAttention();
+      const map = {};
+      for (const a of list) map[a.channelId] = a;
+      setThrottled({ attention: map });
+    } catch {
+    }
+  }
+  async function pollNotifications() {
+    try {
+      setThrottled({ notifications: await rest.getNotifications() });
+    } catch {
+    }
+  }
+  async function dismissNotification(id) {
+    const prev = state.notifications;
+    const prevSel = state.notifSelected;
+    const next = prev.filter((n) => n.id !== id);
+    const clampedSel = Math.max(0, Math.min(prevSel, next.length - 1));
+    setThrottled({ notifications: next, notifSelected: clampedSel });
+    try {
+      await rest.dismissNotification(id);
+    } catch {
+      setThrottled({ notifications: prev, notifSelected: prevSel });
+    }
+  }
+  async function markAllNotificationsRead() {
+    const stamped = state.notifications.map((n) => ({
+      ...n,
+      readAt: n.readAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    setThrottled({ notifications: stamped });
+    try {
+      await rest.markAllNotificationsRead();
+    } catch {
+      void pollNotifications();
+    }
+  }
+  function moveNotifSelection(delta) {
+    const len = state.notifications.length;
+    if (len === 0) {
+      set({ notifSelected: 0 });
+      return;
+    }
+    const next = Math.max(0, Math.min(state.notifSelected + delta, len - 1));
+    set({ notifSelected: next });
+  }
   function seedPresence(members) {
     const presence = {};
     for (const m of members) presence[m.id] = m.status === "online" ? "active" : m.status;
@@ -1416,6 +1666,42 @@ function createStore(opts) {
       scheduleActivitySweep();
     }
   }
+  let rawActivityByTurn = /* @__PURE__ */ new Map();
+  let activitySettleTimer = null;
+  function activityIsLive() {
+    for (const rows of Object.values(state.activityByTurn))
+      for (const r of rows) if (r.status === "pending" || r.status === "in_progress") return true;
+    for (const entries of Object.values(state.plansByTurn))
+      for (const e of entries) if (e.status !== "completed") return true;
+    return false;
+  }
+  function evictOldestTurns(rec) {
+    const keys = Object.keys(rec);
+    if (keys.length <= MAX_ACTIVITY_TURNS) return rec;
+    const drop = keys.slice(0, keys.length - MAX_ACTIVITY_TURNS);
+    const next = { ...rec };
+    for (const k of drop) delete next[k];
+    return next;
+  }
+  function reconcileActivitySettle() {
+    if (activityIsLive()) {
+      if (activitySettleTimer) {
+        clearTimeout(activitySettleTimer);
+        activitySettleTimer = null;
+      }
+      if (state.activityIdleSince !== null) setThrottled({ activityIdleSince: null });
+      return;
+    }
+    if (state.activityIdleSince === null) setThrottled({ activityIdleSince: Date.now() });
+    if (activitySettleTimer) return;
+    activitySettleTimer = setTimeout(() => {
+      activitySettleTimer = null;
+      setThrottled({});
+    }, ACTIVITY_SETTLE_MS);
+  }
+  function togglePin() {
+    set({ activityPinned: !state.activityPinned });
+  }
   let countdownTimer = null;
   function syncCountdown(s) {
     if (s === "reconnecting" && !countdownTimer) {
@@ -1438,6 +1724,8 @@ function createStore(opts) {
     if (isReconnect) {
       pendingGapCursor = config.lastSeq?.[state.activeChannelId ?? ""] ?? null;
       void gapFill();
+      void pollAttention();
+      void pollNotifications();
     }
   });
   ws.onFrame((frame) => {
@@ -1459,8 +1747,12 @@ function createStore(opts) {
         appendMessages(frame.channelId, frame.messages ?? []);
         return;
       }
-      case "new_message": {
-        if (frame.channelId !== state.activeChannelId) return;
+      case "new_message":
+      case "flow_message": {
+        if (frame.channelId !== state.activeChannelId) {
+          bumpUnread(frame.channelId);
+          return;
+        }
         appendMessages(frame.channelId, [frame.message]);
         const senderId = frame.message.agentId;
         removeActivity(
@@ -1500,13 +1792,53 @@ function createStore(opts) {
         return;
       }
       case "subscribe_error": {
-        set({ error: `subscribe failed for ${frame.channelId}: ${frame.error}` });
+        if (frame.error === "limit") {
+          set({ unreadCapNotice: "hit the channel-subscription cap \u2014 some channels are attention-only" });
+        } else {
+          set({ error: `subscribe failed for ${frame.channelId}: ${frame.error}` });
+        }
         return;
       }
       case "channel_archived": {
         pushDivider("channel archived");
         return;
       }
+      case "activity_event": {
+        if (frame.channelId !== state.activeChannelId) return;
+        if (!frame.turnId || !frame.toolCallId) return;
+        const ev = {
+          turnId: frame.turnId,
+          toolCallId: frame.toolCallId,
+          agentId: frame.agentId,
+          kind: frame.kind,
+          title: frame.title,
+          status: frame.status,
+          locations: frame.locations,
+          ts: frame.ts
+        };
+        const list = [...rawActivityByTurn.get(frame.turnId) ?? [], ev];
+        if (list.length > MAX_RAW_EVENTS_PER_TURN) list.splice(0, list.length - MAX_RAW_EVENTS_PER_TURN);
+        rawActivityByTurn.set(frame.turnId, list);
+        while (rawActivityByTurn.size > MAX_ACTIVITY_TURNS) {
+          const oldest = rawActivityByTurn.keys().next().value;
+          rawActivityByTurn.delete(oldest);
+        }
+        const foldedMap = foldActivityEvents(Array.from(rawActivityByTurn.values()).flat());
+        let activityByTurn = {};
+        for (const [tid, rows] of foldedMap) activityByTurn[tid] = rows.slice(0, MAX_TOOL_CALLS_PER_TURN);
+        activityByTurn = evictOldestTurns(activityByTurn);
+        setThrottled({ activityByTurn });
+        reconcileActivitySettle();
+        return;
+      }
+      case "plan_update": {
+        if (frame.channelId !== state.activeChannelId) return;
+        if (!frame.turnId) return;
+        const plansByTurn = evictOldestTurns({ ...state.plansByTurn, [frame.turnId]: frame.entries ?? [] });
+        setThrottled({ plansByTurn });
+        reconcileActivitySettle();
+        return;
+      }
       default:
         return;
     }
@@ -1624,7 +1956,19 @@ function createStore(opts) {
     }
     initialized = true;
     set({ channels });
+    const toSub = channels.slice(0, WS_SUB_CAP);
+    for (const c of toSub) ws.subscribe(c.id);
+    if (channels.length > WS_SUB_CAP)
+      set({ unreadCapNotice: `unread tracked for ${WS_SUB_CAP} of ${channels.length} channels (attention still covers the rest)` });
     ws.connect();
+    void pollAttention();
+    void pollNotifications();
+    if (!attentionTimer) {
+      attentionTimer = setInterval(() => void pollAttention(), ATTENTION_POLL_MS);
+    }
+    if (!notifTimer) {
+      notifTimer = setInterval(() => void pollNotifications(), NOTIF_POLL_MS);
+    }
     reportPresence("active");
     if (!idleTimer) {
       idleTimer = setInterval(() => {
@@ -1645,7 +1989,6 @@ function createStore(opts) {
       set({ mode: "normal" });
       return;
     }
-    if (state.activeChannelId) ws.unsubscribe(state.activeChannelId);
     const ch = state.channels.find((c) => c.id === channelId);
     const members = ch?.members ?? [];
     pushDivider(`${channelSigil(ch?.kind)}${ch?.name ?? channelId}`);
@@ -1657,8 +2000,17 @@ function createStore(opts) {
       mode: "normal",
       switcherFilter: "",
       lastSeq: config.lastSeq?.[channelId] ?? null,
-      error: null
+      error: null,
+      activityByTurn: {},
+      plansByTurn: {},
+      activityIdleSince: null
     });
+    rawActivityByTurn = /* @__PURE__ */ new Map();
+    if (activitySettleTimer) {
+      clearTimeout(activitySettleTimer);
+      activitySettleTimer = null;
+    }
+    clearUnread(channelId);
     ws.subscribe(channelId);
     config = { ...config, lastChannelId: channelId };
     saveConfigSoon();
@@ -1693,7 +2045,19 @@ function createStore(opts) {
     if (idleTimer) clearInterval(idleTimer);
     if (tickTimer) clearInterval(tickTimer);
     if (activitySweep) clearTimeout(activitySweep);
+    if (activitySettleTimer) {
+      clearTimeout(activitySettleTimer);
+      activitySettleTimer = null;
+    }
     if (countdownTimer) clearInterval(countdownTimer);
+    if (attentionTimer) {
+      clearInterval(attentionTimer);
+      attentionTimer = null;
+    }
+    if (notifTimer) {
+      clearInterval(notifTimer);
+      notifTimer = null;
+    }
     if (notifyTimer) {
       clearTimeout(notifyTimer);
       notifyTimer = null;
@@ -1718,6 +2082,15 @@ function createStore(opts) {
     sendDraft: () => void sendDraft(),
     reconnectNow: () => ws.reconnectNow(),
     noteUserActivity,
+    dismissNotification: (id) => void dismissNotification(id),
+    markAllNotificationsRead: () => void markAllNotificationsRead(),
+    moveNotifSelection,
+    jumpNextActive: () => {
+      const s = state;
+      const target = nextActiveChannel(s.channels, s.activeChannelId, { attention: s.attention, unread: s.unread });
+      if (target) openChannel(target.id);
+    },
+    toggleActivityPin: () => togglePin(),
     quit
   };
 }
@@ -1755,79 +2128,206 @@ function ActivityLine({ activities }) {
   ] });
 }
 
-// src/ui/ChannelSwitcher.tsx
+// src/ui/ActivitySurface.tsx
 import { Box, Text as Text2 } from "ink";
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function statusGlyph(status) {
+  switch (status) {
+    case "completed":
+      return "\u2713";
+    case "failed":
+      return "\u2717";
+    case "in_progress":
+      return "\u22EF";
+    case "pending":
+      return "\u25CB";
+    default:
+      return "\xB7";
+  }
+}
+function kindGlyph(kind) {
+  switch (kind) {
+    case "read":
+      return "r";
+    case "edit":
+      return "e";
+    case "write":
+      return "w";
+    case "run":
+      return "\u25B6";
+    case "search":
+      return "s";
+    case "fetch":
+      return "f";
+    case "task":
+      return "t";
+    default:
+      return "\xB7";
+  }
+}
+function planGlyph(status) {
+  switch (status) {
+    case "completed":
+      return "[x]";
+    case "in_progress":
+      return "[~]";
+    default:
+      return "[ ]";
+  }
+}
+function fallbackTitle(call) {
+  if (call.title) return call.title;
+  if (call.kind) return call.kind.charAt(0).toUpperCase() + call.kind.slice(1);
+  return "Tool call";
+}
+function ActivitySurface(props) {
+  const { toolCalls, plan, visible, pinned } = props;
+  if (!visible) return null;
+  if (toolCalls.length === 0 && plan.length === 0) {
+    return /* @__PURE__ */ jsx2(Box, { paddingLeft: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "no activity yet" }) });
+  }
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", paddingLeft: 1, children: [
+    toolCalls.length > 0 && /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "tool calls \xB7 only you can see this" }),
+      toolCalls.map((call) => /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs2(Text2, { children: [
+          statusGlyph(call.status),
+          " ",
+          kindGlyph(call.kind),
+          " ",
+          sanitizeLabel(fallbackTitle(call), 48)
+        ] }),
+        pinned && call.locations && call.locations.length > 0 && /* @__PURE__ */ jsx2(Box, { flexDirection: "column", paddingLeft: 2, children: call.locations.map((loc, i) => /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          sanitizeLabel(loc.path, 60),
+          loc.line != null ? `:${loc.line}` : ""
+        ] }, i)) })
+      ] }, call.toolCallId))
+    ] }),
+    plan.length > 0 && /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "plan \xB7 shared with the channel" }),
+      plan.map((entry, i) => /* @__PURE__ */ jsxs2(Text2, { dimColor: entry.status === "completed", children: [
+        planGlyph(entry.status),
+        " ",
+        sanitizeForTty(entry.content)
+      ] }, i))
+    ] })
+  ] });
+}
+
+// src/ui/ChannelSwitcher.tsx
+import { Box as Box2, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function channelLabel(ch) {
   return `${channelSigil(ch.kind)}${sanitizeLabel(ch.name)}`;
 }
+function ChannelBadge({
+  channelId,
+  activeChannelId,
+  attention,
+  unread
+}) {
+  if (channelId === activeChannelId) return null;
+  const att = attention[channelId];
+  if (att) {
+    const color = att.highestLevel === "critical" ? "red" : att.highestLevel === "action_required" ? "yellow" : "cyan";
+    const sigil = att.highestLevel === "critical" ? "!" : att.highestLevel === "action_required" ? "\u25B2" : "\u2022";
+    return /* @__PURE__ */ jsxs3(Text3, { color, children: [
+      " ",
+      "[",
+      sigil,
+      att.totalCount,
+      "]"
+    ] });
+  }
+  const count = unread[channelId] ?? 0;
+  if (count > 0) {
+    return /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      " (",
+      count,
+      ")"
+    ] });
+  }
+  return null;
+}
 function ChannelSwitcher({
   channels,
   activeChannelId,
-  filter
+  filter,
+  attention,
+  unread
 }) {
   const filtered = filterChannels(channels, filter);
-  const visible = filtered.slice(0, 9);
-  const hidden = filtered.length - visible.length;
-  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs2(Text2, { bold: true, children: [
+  const sorted = sortChannelsByPriority(filtered, { attention, unread });
+  const visible = sorted.slice(0, 9);
+  const hidden = sorted.length - visible.length;
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
       "channels",
       " ",
-      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
         "(",
-        filtered.length,
+        sorted.length,
         "/",
         channels.length,
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "filter: " }),
-      /* @__PURE__ */ jsx2(Text2, { children: sanitizeLabel(filter, 40) }),
-      /* @__PURE__ */ jsx2(Text2, { inverse: true, children: " " })
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "filter: " }),
+      /* @__PURE__ */ jsx3(Text3, { children: sanitizeLabel(filter, 40) }),
+      /* @__PURE__ */ jsx3(Text3, { inverse: true, children: " " })
     ] }),
-    visible.map((ch, i) => /* @__PURE__ */ jsxs2(Text2, { children: [
-      /* @__PURE__ */ jsxs2(Text2, { color: "cyan", children: [
+    visible.map((ch, i) => /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: "cyan", children: [
         i + 1,
         " "
       ] }),
-      /* @__PURE__ */ jsx2(Text2, { bold: ch.id === activeChannelId, children: channelLabel(ch) }),
-      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: ch.id === activeChannelId, children: channelLabel(ch) }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
         " \xB7 ",
         ch.members.length,
         " members"
-      ] })
+      ] }),
+      /* @__PURE__ */ jsx3(
+        ChannelBadge,
+        {
+          channelId: ch.id,
+          activeChannelId,
+          attention,
+          unread
+        }
+      )
     ] }, ch.id)),
-    hidden > 0 ? /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+    hidden > 0 ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
       "\u2026",
       hidden,
       " more \u2014 keep typing to narrow"
     ] }) : null,
-    filtered.length === 0 ? /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+    sorted.length === 0 ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
       'no channels match "',
       sanitizeLabel(filter, 20),
       '"'
     ] }) : null,
-    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: filter.length === 0 ? "type to filter \xB7 1\u20139 quick-select \xB7 Esc cancel" : "keep typing to narrow \xB7 Enter opens top match \xB7 Esc cancel" })
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: filter.length === 0 ? "type to filter \xB7 1\u20139 quick-select \xB7 n jump \xB7 Esc cancel" : "keep typing to narrow \xB7 Enter opens top match \xB7 Esc cancel" })
   ] });
 }
 
 // src/ui/Composer.tsx
-import { Box as Box2, Text as Text3 } from "ink";
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Box as Box3, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function Composer({ draft, focused }) {
   const width = Math.max((process.stdout.columns ?? 80) - 8, 20);
   const visible = draft.length > width ? "\u2026" + draft.slice(-(width - 1)) : draft;
-  return /* @__PURE__ */ jsx3(Box2, { borderStyle: "round", borderColor: focused ? "cyan" : "gray", paddingX: 1, width: "100%", children: /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate", children: [
-    /* @__PURE__ */ jsx3(Text3, { color: focused ? "cyan" : "gray", children: "> " }),
-    draft.length === 0 && !focused ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "i to compose" }) : /* @__PURE__ */ jsx3(Text3, { children: visible }),
-    focused ? /* @__PURE__ */ jsx3(Text3, { inverse: true, children: " " }) : null
+  return /* @__PURE__ */ jsx4(Box3, { borderStyle: "round", borderColor: focused ? "cyan" : "gray", paddingX: 1, width: "100%", children: /* @__PURE__ */ jsxs4(Text4, { wrap: "truncate", children: [
+    /* @__PURE__ */ jsx4(Text4, { color: focused ? "cyan" : "gray", children: "> " }),
+    draft.length === 0 && !focused ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "i to compose" }) : /* @__PURE__ */ jsx4(Text4, { children: visible }),
+    focused ? /* @__PURE__ */ jsx4(Text4, { inverse: true, children: " " }) : null
   ] }) });
 }
 
 // src/ui/Header.tsx
-import { Box as Box3, Text as Text4 } from "ink";
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Box as Box4, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var STATUS_DOT = {
   online: { glyph: "\u25CF", color: "green" },
   away: { glyph: "\u25D0", color: "yellow" },
@@ -1844,32 +2344,32 @@ function Header({
   members,
   presence
 }) {
-  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs4(Box3, { justifyContent: "space-between", children: [
-      /* @__PURE__ */ jsxs4(Text4, { children: [
-        /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "arp-tui" }),
-        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " \u25B8 " }),
-        /* @__PURE__ */ jsxs4(Text4, { bold: true, children: [
+  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs5(Box4, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: "cyan", bold: true, children: "arp-tui" }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " \u25B8 " }),
+        /* @__PURE__ */ jsxs5(Text5, { bold: true, children: [
           channelSigil(channelKind),
           sanitizeLabel(channelName)
         ] })
       ] }),
-      /* @__PURE__ */ jsx4(Text4, { children: members.map((m) => {
+      /* @__PURE__ */ jsx5(Text5, { children: members.map((m) => {
         const dot = STATUS_DOT[effectiveStatus(m, presence)];
-        return /* @__PURE__ */ jsxs4(Text4, { children: [
-          /* @__PURE__ */ jsxs4(Text4, { color: dot.color, children: [
+        return /* @__PURE__ */ jsxs5(Text5, { children: [
+          /* @__PURE__ */ jsxs5(Text5, { color: dot.color, children: [
             dot.glyph,
             " "
           ] }),
-          /* @__PURE__ */ jsxs4(Text4, { dimColor: effectiveStatus(m, presence) === "offline", children: [
+          /* @__PURE__ */ jsxs5(Text5, { dimColor: effectiveStatus(m, presence) === "offline", children: [
             m.type === "bot" ? "\u2699" : "",
             sanitizeLabel(m.name, 20)
           ] }),
-          /* @__PURE__ */ jsx4(Text4, { children: "  " })
+          /* @__PURE__ */ jsx5(Text5, { children: "  " })
         ] }, m.id);
       }) })
     ] }),
-    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2500".repeat(Math.min(process.stdout.columns ?? 80, 100)) })
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2500".repeat(Math.min(process.stdout.columns ?? 80, 100)) })
   ] });
 }
 
@@ -1877,8 +2377,8 @@ function Header({
 import { Static } from "ink";
 
 // src/ui/MessageRow.tsx
-import { Box as Box4, Text as Text5 } from "ink";
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Box as Box5, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function hhmm(rfc3339) {
   const d = new Date(rfc3339);
   return isNaN(d.getTime()) ? "--:--" : `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
@@ -1891,7 +2391,7 @@ function TokenChip({ message }) {
   if (message.messageType !== "agent" || !message.tokensUsed) return null;
   const parts = [`${formatTokens(message.tokensUsed)} tok`];
   if (message.model) parts.push(sanitizeLabel(message.model, 16));
-  return /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
     message.verified ? "\u2713 " : "",
     parts.join(" \xB7 ")
   ] });
@@ -1901,46 +2401,102 @@ function MessageRow({ message }) {
   const isSystem = message.messageType === "system";
   const name = sanitizeLabel(message.agentName, 20);
   if (isSystem) {
-    return /* @__PURE__ */ jsx5(Box4, { children: /* @__PURE__ */ jsxs5(Text5, { dimColor: true, italic: true, children: [
+    return /* @__PURE__ */ jsx6(Box5, { children: /* @__PURE__ */ jsxs6(Text6, { dimColor: true, italic: true, children: [
       "       ",
       "\u2500\u2500 ",
       sanitizeForTty(message.content),
       " \u2500\u2500"
     ] }) });
   }
-  return /* @__PURE__ */ jsxs5(Box4, { justifyContent: "space-between", gap: 2, children: [
-    /* @__PURE__ */ jsx5(Box4, { flexShrink: 1, children: /* @__PURE__ */ jsxs5(Text5, { children: [
-      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs6(Box5, { justifyContent: "space-between", gap: 2, children: [
+    /* @__PURE__ */ jsx6(Box5, { flexShrink: 1, children: /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
         hhmm(message.createdAt),
         " "
       ] }),
-      /* @__PURE__ */ jsxs5(Text5, { color: isBot ? "magenta" : "cyan", bold: !isBot, children: [
+      /* @__PURE__ */ jsxs6(Text6, { color: isBot ? "magenta" : "cyan", bold: !isBot, children: [
         isBot ? "\u2699" : "",
         name.padEnd(12)
       ] }),
-      /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsxs6(Text6, { children: [
         " ",
         sanitizeForTty(message.content)
       ] })
     ] }) }),
-    /* @__PURE__ */ jsx5(Box4, { flexShrink: 0, children: /* @__PURE__ */ jsx5(TokenChip, { message }) })
+    /* @__PURE__ */ jsx6(Box5, { flexShrink: 0, children: /* @__PURE__ */ jsx6(TokenChip, { message }) })
   ] });
 }
 
 // src/ui/MessageList.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 function MessageList({ messages }) {
-  return /* @__PURE__ */ jsx6(Static, { items: messages, children: (m) => /* @__PURE__ */ jsx6(MessageRow, { message: m }, m.id) });
+  return /* @__PURE__ */ jsx7(Static, { items: messages, children: (m) => /* @__PURE__ */ jsx7(MessageRow, { message: m }, m.id) });
+}
+
+// src/ui/NotificationsPanel.tsx
+import { Box as Box6, Text as Text7 } from "ink";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function relativeAge(createdAt) {
+  const ms = Date.now() - new Date(createdAt).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return "\u2014";
+  if (ms < 1e4) return "just now";
+  if (ms < 9e4) return `${Math.round(ms / 1e3)}s`;
+  if (ms < 90 * 6e4) return `${Math.round(ms / 6e4)}m`;
+  if (ms < 48 * 36e5) return `${Math.round(ms / 36e5)}h`;
+  return `${Math.round(ms / 864e5)}d`;
+}
+function shortRef(entityRef) {
+  return sanitizeLabel(entityRef, 24);
+}
+function NotificationsPanel({
+  notifications,
+  notifSelected
+}) {
+  const unreadCount = notifications.filter((n) => !n.readAt).length;
+  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+      "alerts",
+      " ",
+      /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+        "(",
+        unreadCount,
+        " unread \xB7 ",
+        notifications.length,
+        " total)"
+      ] })
+    ] }),
+    notifications.length === 0 ? /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "no notifications" }) : notifications.map((n, i) => {
+      const isSelected = i === notifSelected;
+      const isUnread = n.readAt === null;
+      const type = sanitizeLabel(n.type, 20);
+      const ref = shortRef(sanitizeForTty(n.entityRef));
+      const age = relativeAge(n.createdAt);
+      return /* @__PURE__ */ jsxs7(Text7, { inverse: isSelected, children: [
+        isUnread ? /* @__PURE__ */ jsx8(Text7, { color: "yellow", children: "\u2022 " }) : /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "  " }),
+        /* @__PURE__ */ jsx8(Text7, { bold: isSelected, children: type }),
+        /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          " ",
+          ref
+        ] }),
+        /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          " ",
+          age
+        ] })
+      ] }, n.id);
+    }),
+    /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "J/K move \xB7 d dismiss \xB7 a mark all read \xB7 Esc close" })
+  ] });
 }
 
 // src/ui/StatusBar.tsx
-import { Text as Text6 } from "ink";
-import { Fragment, jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Text as Text8 } from "ink";
+import { Fragment, jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
 var MODE_LABEL = {
   normal: "NORMAL",
   insert: "INSERT",
   switcher: "CHANNELS",
-  token: "TOKEN"
+  token: "TOKEN",
+  notifications: "ALERTS"
 };
 function ageLabel(obtainedAt) {
   if (!obtainedAt) return "\u2014";
@@ -1971,6 +2527,7 @@ function StatusBar({
   tokenObtainedAt,
   tokenRefreshable,
   clerkRefresh,
+  notifCount,
   error
 }) {
   const connColor = connection === "connected" ? "green" : connection === "reconnecting" ? "yellow" : "red";
@@ -1990,37 +2547,41 @@ function StatusBar({
       color: stale ? "yellow" : "green"
     };
   }
-  return /* @__PURE__ */ jsxs6(Text6, { children: [
-    /* @__PURE__ */ jsxs6(Text6, { bold: true, color: mode === "insert" ? "cyan" : mode === "token" ? "yellow" : "white", children: [
+  return /* @__PURE__ */ jsxs8(Text8, { children: [
+    /* @__PURE__ */ jsxs8(Text8, { bold: true, color: mode === "insert" ? "cyan" : mode === "token" ? "yellow" : "white", children: [
       " ",
       MODE_LABEL[mode],
       " "
     ] }),
-    /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2502 " }),
-    /* @__PURE__ */ jsx7(Text6, { color: connColor, children: connectionLabel(connection, reconnectAt, reconnectAttempt) }),
-    /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: " \u2502 " }),
-    /* @__PURE__ */ jsx7(Text6, { color: tokenSeg.color, children: tokenSeg.text }),
-    /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+    /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "\u2502 " }),
+    /* @__PURE__ */ jsx9(Text8, { color: connColor, children: connectionLabel(connection, reconnectAt, reconnectAttempt) }),
+    /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: " \u2502 " }),
+    /* @__PURE__ */ jsx9(Text8, { color: tokenSeg.color, children: tokenSeg.text }),
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
       " \u2502 seq ",
       lastSeq ?? "\u2014"
     ] }),
+    notifCount > 0 ? /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+      " \u2502 alerts:",
+      notifCount
+    ] }) : null,
     error ? (
       // BL-222: an error replaces the full hint line but must never strand
       // the user — keep the exit hint visible alongside it
-      /* @__PURE__ */ jsxs6(Fragment, { children: [
-        /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
+      /* @__PURE__ */ jsxs8(Fragment, { children: [
+        /* @__PURE__ */ jsxs8(Text8, { color: "red", children: [
           " \u2502 ",
           sanitizeForTty(error)
         ] }),
-        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: " \u2502 q quit" })
+        /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: " \u2502 q quit" })
       ] })
-    ) : /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: " \u2502 c channels \xB7 i compose \xB7 r reconnect \xB7 Esc normal \xB7 q quit" })
+    ) : /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: " \u2502 c channels \xB7 a alerts \xB7 n next \xB7 v watch \xB7 i compose \xB7 r reconnect \xB7 Esc normal \xB7 q quit" })
   ] });
 }
 
 // src/ui/TokenPrompt.tsx
-import { Box as Box5, Text as Text7 } from "ink";
-import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Box as Box7, Text as Text9 } from "ink";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
 function TokenPrompt({
   value,
   reason,
@@ -2028,26 +2589,27 @@ function TokenPrompt({
   jwtTemplate
 }) {
   const masked = value.length === 0 ? "" : value.length <= 16 ? value : `${value.slice(0, 12)}\u2026 (${value.length} chars)`;
-  return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsx8(Text7, { bold: true, color: "yellow", children: "token needed" }),
-    reason ? /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: sanitizeForTty(reason) }) : null,
-    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx10(Text9, { bold: true, color: "yellow", children: "token needed" }),
+    reason ? /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: sanitizeForTty(reason) }) : null,
+    /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       "mint one: open ",
       webUrl,
       " logged in, browser console:"
     ] }),
-    /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: `  await window.Clerk.session.getToken({template:'${jwtTemplate}'})` }),
-    /* @__PURE__ */ jsxs7(Text7, { children: [
-      /* @__PURE__ */ jsx8(Text7, { color: "yellow", children: "> " }),
-      /* @__PURE__ */ jsx8(Text7, { children: masked }),
-      /* @__PURE__ */ jsx8(Text7, { inverse: true, children: " " })
+    /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: `  await window.Clerk.session.getToken({template:'${jwtTemplate}'})` }),
+    /* @__PURE__ */ jsxs9(Text9, { children: [
+      /* @__PURE__ */ jsx10(Text9, { color: "yellow", children: "> " }),
+      /* @__PURE__ */ jsx10(Text9, { children: masked }),
+      /* @__PURE__ */ jsx10(Text9, { inverse: true, children: " " })
     ] }),
-    /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "paste, then Enter \xB7 Ctrl+C quits" })
+    /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "paste, then Enter \xB7 Ctrl+C quits" })
   ] });
 }
 
 // src/app.tsx
-import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+var ACTIVITY_SETTLE_MS2 = 4e3;
 function cleanInput(input) {
   return input.replace(/\r\n|[\r\n]/g, " ").replace(/[\x00-\x1f\x7f]/g, "");
 }
@@ -2083,17 +2645,28 @@ function App({ store: store2 }) {
         else if (input) store2.setDraft(s.draft + cleanInput(input));
         return;
       }
+      if (s.mode === "notifications") {
+        if (key.escape) store2.setMode("normal");
+        else if (input === "j" || key.downArrow) store2.moveNotifSelection(1);
+        else if (input === "k" || key.upArrow) store2.moveNotifSelection(-1);
+        else if (input === "d" || key.return) {
+          const n = s.notifications[s.notifSelected];
+          if (n) store2.dismissNotification(n.id);
+        } else if (input === "a") store2.markAllNotificationsRead();
+        return;
+      }
       if (s.mode === "switcher") {
         const filtered = filterChannels(s.channels, s.switcherFilter);
+        const sorted = sortChannelsByPriority(filtered, { attention: s.attention, unread: s.unread });
         const filterEmpty = s.switcherFilter.length === 0;
         if (key.escape) store2.setMode("normal");
         else if (key.return) {
           if (filterEmpty) store2.setMode("normal");
-          else if (filtered[0]) store2.openChannel(filtered[0].id);
+          else if (sorted[0]) store2.openChannel(sorted[0].id);
         } else if (key.backspace || key.delete) {
           store2.setSwitcherFilter(s.switcherFilter.slice(0, -1));
         } else if (filterEmpty && /^[1-9]$/.test(input)) {
-          const ch = filtered[Number(input) - 1];
+          const ch = sorted[Number(input) - 1];
           if (ch) store2.openChannel(ch.id);
         } else if (input) {
           store2.setSwitcherFilter(s.switcherFilter + cleanInput(input));
@@ -2104,14 +2677,26 @@ function App({ store: store2 }) {
         store2.quit();
         exit();
       } else if (input === "c") store2.setMode("switcher");
+      else if (input === "a") store2.setMode("notifications");
       else if (input === "i" || key.return) store2.setMode("insert");
       else if (input === "r") store2.reconnectNow();
+      else if (input === "n") store2.jumpNextActive();
+      else if (input === "v") store2.toggleActivityPin();
     },
     { isActive: interactive }
   );
   const activeChannel = state.channels.find((c) => c.id === state.activeChannelId);
-  return /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx9(
+  const lastKey = (r) => {
+    const ks = Object.keys(r);
+    return ks[ks.length - 1];
+  };
+  const activityRows = state.activityByTurn[lastKey(state.activityByTurn) ?? ""] ?? [];
+  const activityPlan = state.plansByTurn[lastKey(state.plansByTurn) ?? ""] ?? [];
+  const activityLive = activityRows.some((r) => r.status === "pending" || r.status === "in_progress") || activityPlan.some((e) => e.status !== "completed");
+  const activityWithinSettle = state.activityIdleSince !== null && Date.now() - state.activityIdleSince < ACTIVITY_SETTLE_MS2;
+  const activityVisible = state.activityPinned || activityLive || activityWithinSettle;
+  return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(
       Header,
       {
         channelName: activeChannel?.name ?? "(connecting\u2026)",
@@ -2120,16 +2705,26 @@ function App({ store: store2 }) {
         presence: state.presence
       }
     ),
-    /* @__PURE__ */ jsx9(MessageList, { messages: state.messages }),
-    state.mode === "switcher" ? /* @__PURE__ */ jsx9(
+    /* @__PURE__ */ jsx11(MessageList, { messages: state.messages }),
+    /* @__PURE__ */ jsx11(ActivitySurface, { toolCalls: activityRows, plan: activityPlan, visible: activityVisible, pinned: state.activityPinned }),
+    state.mode === "switcher" ? /* @__PURE__ */ jsx11(
       ChannelSwitcher,
       {
         channels: state.channels,
         activeChannelId: state.activeChannelId,
-        filter: state.switcherFilter
+        filter: state.switcherFilter,
+        attention: state.attention,
+        unread: state.unread
+      }
+    ) : null,
+    state.mode === "notifications" ? /* @__PURE__ */ jsx11(
+      NotificationsPanel,
+      {
+        notifications: state.notifications,
+        notifSelected: state.notifSelected
       }
     ) : null,
-    state.mode === "token" ? /* @__PURE__ */ jsx9(
+    state.mode === "token" ? /* @__PURE__ */ jsx11(
       TokenPrompt,
       {
         value: state.tokenPrompt,
@@ -2138,9 +2733,9 @@ function App({ store: store2 }) {
         jwtTemplate: store2.instance.clerkJwtTemplate
       }
     ) : null,
-    /* @__PURE__ */ jsx9(ActivityLine, { activities: state.activities }),
-    /* @__PURE__ */ jsx9(Composer, { draft: state.draft, focused: state.mode === "insert" }),
-    /* @__PURE__ */ jsx9(
+    /* @__PURE__ */ jsx11(ActivityLine, { activities: state.activities }),
+    /* @__PURE__ */ jsx11(Composer, { draft: state.draft, focused: state.mode === "insert" }),
+    /* @__PURE__ */ jsx11(
       StatusBar,
       {
         mode: state.mode,
@@ -2152,15 +2747,95 @@ function App({ store: store2 }) {
         tokenObtainedAt: state.tokenObtainedAt,
         tokenRefreshable: state.tokenRefreshable,
         clerkRefresh: state.clerkRefresh,
+        notifCount: state.notifications.filter((n) => !n.readAt).length,
         error: state.error
       }
     ),
-    !interactive ? /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "(non-interactive terminal: keys disabled \u2014 tail is read-only here)" }) : null
+    !interactive ? /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "(non-interactive terminal: keys disabled \u2014 tail is read-only here)" }) : null
   ] });
 }
 
+// src/commands/profile.ts
+var USAGE = `usage: arp-tui profile <list|add|switch|remove> [...]
+
+  profile list [--json]
+      show every saved instance profile (the active one is marked *)
+
+  profile add <name> --relay <url> [--web <url>] [--clerk-fapi <url>]
+                     [--clerk-template <name>] [--clerk-oauth-client-id <id>]
+      define a new instance. --web and --clerk-fapi are required unless --relay
+      is the built-in dev relay. Does not change the active profile.
+
+  profile switch <name>
+      make <name> the active profile
+
+  profile remove <name>
+      delete a profile (not the active one, not the last one)`;
+function requireName(name, verb) {
+  if (!name) throw new Error(`profile ${verb} requires a profile name \u2014 see \`arp-tui profile\`.`);
+  return name;
+}
+function runProfileCommand(args2) {
+  try {
+    switch (args2.sub) {
+      case "list": {
+        const { active, profiles } = listProfiles();
+        if (args2.json) {
+          console.log(JSON.stringify({ active, profiles }, null, 2));
+        } else {
+          const names = Object.keys(profiles);
+          if (names.length === 0) {
+            console.log("(no profiles)");
+          } else {
+            for (const name of names) {
+              const mark = name === active ? "*" : " ";
+              console.log(`${mark} ${name.padEnd(16)} ${profiles[name].relayUrl}`);
+            }
+          }
+        }
+        process.exit(0);
+      }
+      case "add": {
+        const name = requireName(args2.name, "add");
+        if (!args2.relay) throw new Error("profile add requires --relay <url>.");
+        const raw = { relayUrl: args2.relay };
+        if (args2.web) raw["webUrl"] = args2.web;
+        if (args2.clerkFapi) raw["clerkFapiUrl"] = args2.clerkFapi;
+        if (args2.clerkTemplate) raw["clerkJwtTemplate"] = args2.clerkTemplate;
+        if (args2.clerkOAuthClientId) raw["clerkOAuthClientId"] = args2.clerkOAuthClientId;
+        const profile = addProfile(name, raw);
+        console.error(`\u2713 added profile "${name}" (${profile.relayUrl})`);
+        console.error(`  run \`arp-tui profile switch ${name}\` to make it active`);
+        process.exit(0);
+      }
+      case "switch": {
+        const name = requireName(args2.name, "switch");
+        const profile = switchProfile(name);
+        console.error(`\u2713 active profile is now "${name}" (${profile.relayUrl})`);
+        process.exit(0);
+      }
+      case "remove": {
+        const name = requireName(args2.name, "remove");
+        removeProfile(name);
+        console.error(`\u2713 removed profile "${name}"`);
+        console.error("  (stored credentials for its relay remain \u2014 `arp-tui logout` clears those)");
+        process.exit(0);
+      }
+      default: {
+        console.error(USAGE);
+        if (args2.sub) console.error(`
+unknown profile command "${args2.sub}".`);
+        process.exit(1);
+      }
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
 // src/index.tsx
-import { jsx as jsx10 } from "react/jsx-runtime";
+import { jsx as jsx12 } from "react/jsx-runtime";
 function helpText(profileName2, base2, effective) {
   const relayOverridden = effective.relayUrl !== base2.relayUrl;
   const overrideNote = relayOverridden ? `
@@ -2169,7 +2844,7 @@ function helpText(profileName2, base2, effective) {
                    instance \u2014 a JWT minted there will NOT work against the override)` : "";
   return `arp-tui \u2014 tail + post for Agent Relay Protocol channels (as the HUMAN)
 
-usage: arp-tui [tail|login|logout|status] [--profile <name>] [--relay <url>] [--token <jwt>]
+usage: arp-tui [tail|login|logout|status|profile] [--profile <name>] [--relay <url>] [--token <jwt>]
 
 commands:
   tail            live channel tail + post (default)
@@ -2177,6 +2852,7 @@ commands:
                   stores refreshable tokens in ~/.arp-tui/credentials.json
   logout          revoke the OAuth grant and delete this instance's stored tokens
   status          show the stored credential state for the active instance
+  profile         manage saved instances (list|add|switch|remove; run \`arp-tui profile\`)
 
 options:
   --profile <name> instance profile from ~/.arp-tui/config.json
@@ -2206,6 +2882,11 @@ function parseCliArgs(argv) {
         profile: { type: "string" },
         relay: { type: "string" },
         token: { type: "string" },
+        web: { type: "string" },
+        "clerk-fapi": { type: "string" },
+        "clerk-template": { type: "string" },
+        "clerk-oauth-client-id": { type: "string" },
+        json: { type: "boolean" },
         help: { type: "boolean", short: "h" }
       },
       allowPositionals: true
@@ -2216,9 +2897,16 @@ function parseCliArgs(argv) {
   }
   return {
     cmd: parsed.positionals[0] ?? "tail",
+    sub: parsed.positionals[1],
+    name: parsed.positionals[2],
     profile: parsed.values.profile,
     relay: parsed.values.relay,
     token: parsed.values.token,
+    web: parsed.values.web,
+    clerkFapi: parsed.values["clerk-fapi"],
+    clerkTemplate: parsed.values["clerk-template"],
+    clerkOAuthClientId: parsed.values["clerk-oauth-client-id"],
+    json: parsed.values.json === true,
     help: parsed.values.help === true
   };
 }
@@ -2246,6 +2934,18 @@ try {
   console.error(err instanceof Error ? err.message : String(err));
   process.exit(1);
 }
+if (args.cmd === "profile") {
+  runProfileCommand({
+    sub: args.sub,
+    name: args.name,
+    relay: args.relay,
+    web: args.web,
+    clerkFapi: args.clerkFapi,
+    clerkTemplate: args.clerkTemplate,
+    clerkOAuthClientId: args.clerkOAuthClientId,
+    json: args.json
+  });
+}
 var profileName;
 var base;
 var instance;
@@ -2330,4 +3030,4 @@ if (credentials?.tokenType === "dev-jwt" && credentials.token && !credentials.cl
   );
 }
 var store = createStore({ instance, credentials });
-render(/* @__PURE__ */ jsx10(App, { store }));
+render(/* @__PURE__ */ jsx12(App, { store }));