@cplieger/web-terminal-ui 3.1.0 → 3.3.0

package/README.md

@@ -85,26 +85,33 @@ render/connection/scroll modules are single-instance per page (tabs multiplex
 sessions over the one kernel). `scaffold/index.html` is a complete reference page
 to copy and adapt.
 
-Three presets are provided (import from `@cplieger/web-terminal-ui/presets`); each
+Four presets are provided (import from `@cplieger/web-terminal-ui/presets`); each
 is a plain feature-array factory, so you can spread and edit it, or hand-pick
 individual features instead:
 
 - `presetSingle()` — single-pane desktop UI (context menu, clipboard,
   scroll-to-bottom, predictive echo, connection banner).
 - `presetTouch()` — `presetSingle()` plus the mobile key toolbar.
-- `presetTabbed()` — the full reference UI: `presetTouch()` plus tabs, the
-  activity monitor, and animations. Requires a server that speaks the session
-  API (`/api/sessions`, the status SSE, and `/ws?session=`), such as
-  `web-terminal-server` or `vibecli`.
+- `presetTabbed()` — the generic tabbed UI: `presetTouch()` plus tabs and
+  animations. Tabs are label-only (no activity dots); each tab's title follows
+  the process window title (OSC 0/2) when the program sets one and keeps it
+  updated, otherwise the last command submitted. Requires a server that speaks
+  the session API (`/api/sessions` and `/ws?session=`), such as
+  `web-terminal-server`.
+- `presetAgentTabbed()` — `presetTabbed()` plus the activity monitor, so each
+  tab carries a live status dot (idle / working / done / needs-input) from the
+  server's status SSE. Same title behavior as `presetTabbed`. For an agent shell
+  such as `vibecli`.
 
 ### Options
 
-| Option      | Default                    | Purpose                                                                                                                                                      |
-| ----------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `features`  | _(none — bare kernel)_     | The feature list. Omitted or empty builds only the terminal (no chrome). Use a preset from `./presets` or a hand-picked array.                               |
-| `wsPath`    | `"/ws"`                    | WebSocket endpoint path the engine connects to.                                                                                                              |
-| `fontReady` | `'14px "MonaspiceNe NFM"'` | CSS font shorthand awaited before the first resize, so the server is sized against the real web font's cell metrics rather than a fallback.                  |
-| `loading`   | _(none)_                   | A pre-JS loading overlay element (kept in your served HTML so it paints before this module loads); it is faded out and removed once the first frame renders. |
+| Option      | Default                    | Purpose                                                                                                                                                               |
+| ----------- | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `features`  | _(none — bare kernel)_     | The feature list. Omitted or empty builds only the terminal (no chrome). Use a preset from `./presets` or a hand-picked array.                                        |
+| `wsPath`    | `"/ws"`                    | WebSocket endpoint path the engine connects to.                                                                                                                       |
+| `fontReady` | `'14px "MonaspiceNe NFM"'` | CSS font shorthand awaited before the first resize, so the server is sized against the real web font's cell metrics rather than a fallback.                           |
+| `loading`   | _(none)_                   | A pre-JS loading overlay element (kept in your served HTML so it paints before this module loads); it is faded out and removed once the first frame renders.          |
+| `theme`     | _(none)_                   | Theme overrides (CSS custom properties on the terminal root): `--accent`, `--tab-hover-bg`, `--tab-active-bg`, `--tab-active-fg`. The library ships neutral defaults. |
 
 `createTerminal()` returns a handle: `focus()` re-focuses the terminal input
 (and opens the soft keyboard on touch), and `destroy()` tears every feature down

package/css/05-tabs.css

@@ -231,12 +231,13 @@
    per section 12 / WCAG 1.4.1. The one .wt-status-dot vocabulary is shared by
    the desktop strip, the mobile switcher, and the overview sheet rows.
 
-   Opt-in: the dot is hidden unless its container carries .wt-status, which the
-   tabs feature adds only when a status source (activityMonitor) is wired. A
-   generic bash/sh terminal has no activity concept, so its tabs read as clean
-   labels; the agent consumer (vibecli) supplies the monitor and gets the dots.
-   The element stays in the DOM either way (JS sets data-status regardless), so
-   revealing it is a pure CSS switch. */
+   Revealed PER TAB: the dot is hidden until its own session reports activity
+   (OSC 9;4 progress, or a classified OSC 9 notification), at which point the
+   tabs feature adds .wt-reports to that dot (paintStatusDot). A program that
+   emits no OSC 9 signal (a plain bash/sh) has no activity concept, so its tabs
+   stay clean, label-only; a progress-reporting agent (kiro-cli, Claude Code)
+   lights up. The element stays in the DOM either way (JS sets data-status
+   regardless), so revealing it is a pure CSS switch. */
 .wt-status-dot {
   display: none;
   width: 9px;
@@ -251,9 +252,10 @@
   border: 1.5px solid color-mix(in oklch, var(--text) 45%, transparent);
 }
 
-/* A status source is wired (the tabs feature marked the chrome .wt-status): show
-   the dots. Without this class the whole activity vocabulary stays invisible. */
-.wt-status .wt-status-dot {
+/* Reveal a dot only once its session has reported activity (the tabs feature
+   adds .wt-reports per dot; see paintStatusDot). Without it the dot — and the
+   whole activity vocabulary for that tab — stays invisible. */
+.wt-status-dot.wt-reports {
   display: block;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/web-terminal-ui",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "type": "module",
   "description": "Reference touch-first browser UI for @cplieger/web-terminal-engine: a composable kernel + feature modules (tabs, activity monitor, mobile toolbar, context menu, IME, predictive echo, viewport handling) and CSS. One createTerminal() call.",
   "license": "GPL-3.0-or-later",
@@ -25,7 +25,7 @@
     "verify": "bash scripts/verify.sh"
   },
   "peerDependencies": {
-    "@cplieger/web-terminal-engine": ">=2.0.0"
+    "@cplieger/web-terminal-engine": ">=2.2.0"
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",

package/src/features/tabs.ts

@@ -54,6 +54,10 @@ interface SessionInfo {
   title: string;
   createdAt: string;
   status: string;
+  /** Sticky: true once the session has emitted a genuine activity signal
+   *  (OSC 9;4 progress, or a classified OSC 9 notification). Gates whether the
+   *  per-tab activity dot is shown; see paintStatusDot / baseLabel. */
+  reportsActivity?: boolean;
 }
 
 interface Tab {
@@ -72,10 +76,18 @@ interface Tab {
   aria: TabHandle;
   scrollTop: number;
   following: boolean;
-  /** A title derived from the first line the user submitted into this tab, used
-   *  in preference to the process window title (kiro-cli's OSC 0 title is only
-   *  the cwd for a live session, so it never reflects the conversation).
-   *  Undefined until the first non-empty, non-slash submission. */
+  /** Sticky: true once this session emitted a genuine activity signal (OSC 9;4).
+   *  Its activity dot is shown only while true; a session that never reports
+   *  activity (a plain shell) keeps a clean, dot-less tab. Fed from the server's
+   *  reportsActivity via applyStatus. */
+  reports: boolean;
+  /** A fallback title derived from the LAST non-empty line the user submitted
+   *  into this tab (updated on every Enter). Used only when the process sets no
+   *  window title of its own: the OSC 0/2 title (`title` above) takes precedence
+   *  when present and keeps updating, and this is what the tab reads as when it
+   *  does not — a plain shell with no PROMPT_COMMAND title, or kiro-cli with its
+   *  cwd-only title disabled. Undefined until the first non-empty submission; see
+   *  baseLabel. */
   derived?: string;
 }
 
@@ -291,14 +303,14 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
       });
       swReserve.observe(swBar);
 
-      // Activity dots are opt-in: shown only when a status source
-      // (activityMonitor) is wired, so a generic bash/sh terminal gets clean,
-      // label-only tabs. CSS hides .wt-status-dot unless its container carries
-      // .wt-status; the agent consumer (vibecli) provides the monitor.
-      if (monitor) {
-        bar.classList.add("wt-status");
-        switcher.classList.add("wt-status");
-      }
+      // Activity dots are revealed PER TAB, not chrome-wide: each dot stays
+      // hidden (CSS: .wt-status-dot { display: none }) until its session reports
+      // activity (OSC 9;4 progress or a classified OSC 9 notification), at which
+      // point paintStatusDot adds .wt-reports to reveal it (see applyStatus /
+      // syncMobile / updateRow). A program that emits no OSC 9 signal (a plain
+      // bash/sh) keeps clean, label-only tabs; an agent's tabs light up. The
+      // monitor (below) is the live source; without it the poll fallback feeds
+      // the same reportsActivity flag.
 
       // Catching-up cue: a switched-into tab's cached screen is stale until its
       // resume delta lands, so it must not read as live (sections 12/13). Shown
@@ -354,19 +366,21 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
         window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 
       // baseLabel is a tab's label before de-duplication. Preference order: the
-      // title derived from the user's first submitted line (best for a chat like
-      // kiro-cli, whose OSC 0 title only ever reflects the cwd for a live
-      // session), then the process window title (OSC 0/2, e.g. a shell's), then a
-      // plain "New tab". fallback=true marks that last case so relabelAll leaves
+      // process window title (OSC 0/2, e.g. a shell's PROMPT_COMMAND title),
+      // which takes precedence whenever the program sets one and keeps updating
+      // as it changes (the status SSE re-pushes it); then a fallback derived from
+      // the last line the user submitted, for a program that sets no title (a
+      // bare shell, or kiro-cli with its cwd-only title disabled); then a plain
+      // "New tab". fallback=true marks that last case so relabelAll leaves
       // untitled tabs as "New tab" with no numeric suffix.
       function baseLabel(tab: Tab): { text: string; fallback: boolean } {
-        const real = tab.derived?.trim() ?? tab.title.trim();
+        const real = tab.title.trim() || (tab.derived?.trim() ?? "");
         return real ? { text: real, fallback: false } : { text: "New tab", fallback: true };
       }
 
       // relabelAll recomputes every tab's display label with de-duplication:
-      // when two tabs resolve to the same base label (e.g. two tabs whose first
-      // submitted line was identical, or two shells with the same window title),
+      // when two tabs resolve to the same base label (e.g. two shells with the
+      // same window title, or two tabs whose last submitted line was identical),
       // the second and later get a " (k)" suffix in creation order, so the strip
       // never shows two identical labels.
       function relabelAll(): void {
@@ -396,16 +410,17 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
         }
       }
 
-      // --- Title derivation from the user's first submitted line ---
-      // kiro-cli's OSC 0 title is only the cwd for a live session (it reloads its
-      // session title just when the session id changes, not per turn), so the
-      // useful, updating title for a chat is the user's first message. The kernel
-      // routes input to the active session, so an input observer's bytes belong
-      // to activeId. A tiny line editor tracks the current input line (handling
-      // backspace and skipping the escape sequences arrow keys and bracketed
-      // paste emit) and locks the tab's title on the first non-empty, non-slash
-      // submission. Best-effort: an odd editing sequence just yields no derived
-      // title, falling back to the window title or "Tab N".
+      // --- Fallback title derivation from the user's submitted lines ---
+      // Used only when the process sets no OSC window title of its own (baseLabel
+      // prefers tab.title). A shell without a PROMPT_COMMAND title, or kiro-cli
+      // with its cwd-only title disabled, sets none — so the useful fallback is
+      // the last line the user submitted. The kernel routes input to the active
+      // session, so an input observer's bytes belong to activeId. A tiny line
+      // editor tracks the current input line (handling backspace and skipping
+      // the escape sequences arrow keys and bracketed paste emit) and updates the
+      // tab's derived title on every non-empty submission. Best-effort: an odd
+      // editing sequence just yields no derived title (the tab then reads "New
+      // tab" until the next submission).
       const MAX_DERIVED = 60;
       let lineBytes: number[] = [];
       let escState = 0; // 0 normal, 1 saw ESC, 2 in CSI, 3 in SS3 (one more byte)
@@ -415,8 +430,8 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
       }
       function deriveTitleFromInput(bytes: Uint8Array): void {
         const t = tabList.find((x) => x.id === activeId);
-        if (!t || t.derived !== undefined) {
-          return; // no active tab, or its first submission is already captured
+        if (!t) {
+          return; // no active tab
         }
         for (const b of bytes) {
           if (escState === 1) {
@@ -438,10 +453,12 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
           } else if (b === 0x0d || b === 0x0a) {
             const line = new TextDecoder().decode(new Uint8Array(lineBytes)).trim();
             lineBytes = [];
-            if (line && !line.startsWith("/")) {
+            // Every non-empty submitted line updates the fallback title (the
+            // last one wins); a leading "/" counts, since it is a valid shell
+            // command path.
+            if (line) {
               t.derived = line.slice(0, MAX_DERIVED);
               syncChrome();
-              return;
             }
           } else if (b === 0x7f || b === 0x08) {
             // Backspace: drop one codepoint (pop UTF-8 continuation bytes + lead).
@@ -482,7 +499,7 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
         const idx = tabList.findIndex((t) => t.id === activeId);
         const active = idx >= 0 ? tabList[idx] : undefined;
         swLabel.textContent = active ? active.display : "";
-        swDot.dataset["status"] = active?.dot.dataset["status"] ?? "idle";
+        paintStatusDot(swDot, active?.dot.dataset["status"] ?? "idle", active?.reports ?? false);
         const bgInput = tabList.some(
           (t) => t.id !== activeId && t.dot.dataset["status"] === "input",
         );
@@ -512,7 +529,11 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
       }
       // updateRow refreshes a reused row's live bits (status dot + label).
       function updateRow(row: HTMLElement, t: Tab): void {
-        pick(row, ".wt-switcher-row-dot").dataset["status"] = t.dot.dataset["status"] ?? "idle";
+        paintStatusDot(
+          pick(row, ".wt-switcher-row-dot"),
+          t.dot.dataset["status"] ?? "idle",
+          t.reports,
+        );
         pick(row, ".wt-switcher-row-label").textContent = t.display;
       }
       // animateRowIn / animateRowOut give a listed tab an enter / leave motion:
@@ -813,7 +834,7 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
         if (!label || !dot || !close) {
           throw new Error("web-terminal-ui: tab chrome missing parts");
         }
-        dot.dataset["status"] = info.status || "idle";
+        paintStatusDot(dot, info.status, info.reportsActivity ?? false);
         const aria = tablist.registerTab(el);
         // Insert before the "+" button so it stays the last item in the strip.
         bar.insertBefore(el, newBtn);
@@ -839,6 +860,7 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
           aria,
           scrollTop: 0,
           following: true,
+          reports: info.reportsActivity ?? false,
         };
         // Set an initial label immediately (relabelAll refines it with de-dup
         // once the tab is in tabList and syncChrome runs).
@@ -1019,6 +1041,20 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
         clearCatchup();
       });
 
+      // Live window-title updates for the active session: the engine sends a
+      // TITLE frame on the live socket whenever the process changes its OSC 0/2
+      // title, which the kernel republishes as wire:title. baseLabel prefers the
+      // OSC title, so applying it here updates the active tab's label at once
+      // rather than waiting for the next status-SSE/poll sweep (background tabs,
+      // which have no live socket, still refresh their title from that sweep).
+      ctx.on("wire:title", ({ session, title }) => {
+        const t = tabList.find((x) => x.id === session);
+        if (t && title !== t.title) {
+          t.title = title;
+          syncChrome();
+        }
+      });
+
       // switchRelative moves delta tabs from the active one (swipe left = next).
       // The direction feeds the slide animation (next slides in from the right,
       // prev from the left).
@@ -1334,14 +1370,21 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
         ctx.toast("Swipe to switch terminals");
       }
 
-      // applyStatus updates one tab's dot + title from a status record (shared by
-      // the SSE monitor and the polling fallback).
-      function applyStatus(id: string, status: string, title: string | undefined): void {
+      // applyStatus updates one tab's dot (status + reveal) + title from a status
+      // record (shared by the SSE monitor and the polling fallback). reports is
+      // the server's sticky reportsActivity flag; it gates the dot's visibility.
+      function applyStatus(
+        id: string,
+        status: string,
+        title: string | undefined,
+        reports: boolean,
+      ): void {
         const t = tabList.find((tab) => tab.id === id);
         if (!t) {
           return;
         }
-        t.dot.dataset["status"] = status || "idle";
+        t.reports = reports;
+        paintStatusDot(t.dot, status, reports);
         // Record the raw server title; the displayed label (fallback + de-dup)
         // is recomputed by relabelAll via syncChrome, which the callers run
         // right after applyStatus.
@@ -1363,8 +1406,14 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
             return;
           }
           // Adopt a session created in another browser so all clients converge.
-          adoptSession({ id: s.id, title: s.title, createdAt: s.createdAt, status: s.status });
-          applyStatus(s.id, s.status, s.title);
+          adoptSession({
+            id: s.id,
+            title: s.title,
+            createdAt: s.createdAt,
+            status: s.status,
+            reportsActivity: s.reportsActivity ?? false,
+          });
+          applyStatus(s.id, s.status, s.title, s.reportsActivity ?? false);
           syncChrome();
         });
       } else {
@@ -1379,7 +1428,7 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
           const seen = new Set(list.map((s) => s.id));
           for (const info of list) {
             adoptSession(info); // add sessions created elsewhere (no local tab)
-            applyStatus(info.id, info.status, info.title);
+            applyStatus(info.id, info.status, info.title, info.reportsActivity ?? false);
           }
           // A tab the server no longer lists was reaped/closed elsewhere: drop it
           // locally (no DELETE — it is already gone).
@@ -1928,6 +1977,17 @@ export function tabs(opts: TabsOptions = {}): TerminalFeature<TabsApi> {
   };
 }
 
+// paintStatusDot applies a status dot's two orthogonal bits: data-status drives
+// its appearance (idle / working / done / input / exited via CSS), and the
+// .wt-reports class controls its visibility — the dot is hidden by default and
+// shown only once the session has reported activity (OSC 9;4 progress or a
+// classified OSC 9 notification), so a plain shell's tabs stay clean and
+// label-only while an agent's light up.
+function paintStatusDot(el: HTMLElement, status: string, reports: boolean): void {
+  el.dataset["status"] = status || "idle";
+  el.classList.toggle("wt-reports", reports);
+}
+
 // pick returns a required descendant element or throws (static chrome only).
 function pick(root: ParentNode, selector: string): HTMLElement {
   const el = root.querySelector<HTMLElement>(selector);

package/src/kernel/kernel.ts

@@ -156,6 +156,17 @@ export function createTerminal(
     if (!connection.sendBinary(out)) {
       return;
     }
+    // Classic-terminal behavior (GNOME/xterm): user input re-engages follow and
+    // snaps to the bottom, so typing while scrolled up jumps to the input line.
+    // Instant (not the jump-button's smooth scroll), so it isn't janky per
+    // keystroke. This is the ONLY thing that scrolls a held view down — program
+    // output never does (the scroll controller's follow/hold job is unchanged),
+    // so scrolling up to read while output streams is preserved. A no-op on the
+    // alt screen (no scrollback) and when already following. NOTE: every caller
+    // of sendBytes today is genuine user input (typed keys, paste, mobile
+    // toolbar); if mouse tracking is ever wired through ctx.send, its motion
+    // bytes must NOT come through here or the view would snap on every move.
+    scroll.scrollToBottom();
     for (const obs of inputObservers) {
       obs(out);
     }

package/src/presets.ts

@@ -4,11 +4,13 @@
 // lists (convenient, full UI); a consumer wanting a minimal footprint imports
 // individual features instead.
 //
-// The tabbed presets split by consumer: presetTabbed is the generic label-only
-// tabbed UI (a plain bash/sh terminal, the first-class experience); the derived
-// presetAgentTabbed layers the activity monitor on top, so an agent shell like
-// vibecli gets per-tab status dots. The split keeps agent semantics out of the
-// generic terminal (design "generic first, vibecli is a derivation").
+// The tabbed presets (presetTabbed / presetAgentTabbed) are now identical: both
+// include the activity monitor, because the per-tab activity dot reveals itself
+// only when a session reports activity (OSC 9;4 progress), so a plain shell
+// simply never shows one. The generic-vs-agent distinction is now purely
+// server-side — an agent server sets a status classifier that maps OSC 9
+// notifications to done/needs-input. presetAgentTabbed is kept as an alias for
+// its consumers (vibecli).
 
 import type { TerminalFeature } from "./kernel/types.js";
 import { clipboard } from "./features/clipboard.js";
@@ -19,7 +21,6 @@ import { connectionBanner } from "./features/connection-banner.js";
 import { mobileToolbar } from "./features/mobile-toolbar.js";
 import { tabs } from "./features/tabs.js";
 import { activityMonitor } from "./features/activity-monitor.js";
-import type { ActivityMonitorApi } from "./features/activity-monitor.js";
 import { animations } from "./features/animations.js";
 
 /** Single-pane desktop UI: context menu, clipboard, scroll-to-bottom, predictive
@@ -42,35 +43,41 @@ export function presetTouch(): TerminalFeature<unknown>[] {
   return [...presetSingle(), mobileToolbar()];
 }
 
-// buildTabbed composes the tabbed UI shared by both tabbed presets: the
-// single-pane touch features, an externally-driven mobile toolbar (its grid is
-// opened from a keyboard button in the tab bar, not its own toggle), tabs wired
-// to that toolbar, and animations. An optional activity monitor adds per-tab
-// status dots (the agent variant). The toolbar and monitor are ordered before
-// tabs because tabs reads their APIs via ctx.use.
-function buildTabbed(monitor?: TerminalFeature<ActivityMonitorApi>): TerminalFeature<unknown>[] {
+// buildTabbed composes the tabbed UI: the single-pane touch features, an
+// externally-driven mobile toolbar (its grid is opened from a keyboard button in
+// the tab bar, not its own toggle), the activity monitor (the status-SSE data
+// source), tabs wired to both, and animations. The activity dot reveals itself
+// per tab only when a session reports activity (OSC 9;4), so the monitor is
+// always included — a plain shell just never reveals a dot. The toolbar and
+// monitor are ordered before tabs because tabs reads their APIs via ctx.use.
+function buildTabbed(): TerminalFeature<unknown>[] {
   const kb = mobileToolbar({ externalToggle: true });
+  const monitor = activityMonitor();
   return [
     ...presetSingle(),
     kb,
-    ...(monitor ? [monitor] : []),
-    tabs({ keyboardToggle: kb, ...(monitor ? { activityMonitor: monitor } : {}) }),
+    monitor,
+    tabs({ keyboardToggle: kb, activityMonitor: monitor }),
     animations(),
   ];
 }
 
-/** Generic tabbed UI: touch features, label-only tabs, the mobile keyboard bar,
- *  and animations. No activity monitor, so tabs carry no status dots. This is
- *  the first-class experience for a plain terminal (bash/sh) where "agent
- *  activity" has no meaning. An agent shell wants presetAgentTabbed instead. */
+/** Tabbed UI: the touch features, tabs, the mobile keyboard bar, the activity
+ *  monitor, and animations. Requires a server that speaks the session API
+ *  (`/api/sessions`, `/ws?session=`, and the status SSE `/api/sessions/events`),
+ *  such as `web-terminal-server` or `vibecli`. Each tab's title follows the
+ *  process OSC 0/2 window title when the program sets one, else the last
+ *  submitted line; each tab's activity dot stays hidden until its session
+ *  reports activity via OSC 9;4 progress (kiro-cli, Claude Code, …), so a plain
+ *  bash/sh keeps clean, label-only tabs. */
 export function presetTabbed(): TerminalFeature<unknown>[] {
   return buildTabbed();
 }
 
-/** Agent-shell tabbed UI: presetTabbed plus the activity monitor, so each tab
- *  shows a live status dot (idle / working / done / needs-input) from the
- *  server's status SSE. vibecli composes this; a generic terminal composes
- *  presetTabbed. */
+/** Alias of presetTabbed, kept for the agent-shell consumer (vibecli). The UI is
+ *  identical — the generic-vs-agent distinction is now purely server-side: an
+ *  agent server sets a status classifier (mapping OSC 9 notifications to
+ *  done/needs-input), and each tab's dot reveals itself from OSC 9;4 either way. */
 export function presetAgentTabbed(): TerminalFeature<unknown>[] {
-  return buildTabbed(activityMonitor());
+  return buildTabbed();
 }