claude-threads 0.48.14 → 0.48.16

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.48.16] - 2026-01-09
+
+### Added
+- **Scrollable logs panel** - Logs are now scrollable with keyboard navigation (↑↓ arrows, g/G for top/bottom). Press `[l]` to focus logs panel for scrolling (#146)
+- **Section headings** - Added clear section headings (Platforms, Logs, Threads) with counts
+- **Numbered platforms and threads** - Each platform and thread now shows its number for quick reference
+- **Clear screen at startup** - Terminal clears at startup for a clean UI
+
+### Changed
+- **StatusLine pinned to bottom** - Status bar now stays at the bottom of the terminal
+- **Dynamic log height** - Logs section uses available terminal space
+
+## [0.48.15] - 2026-01-09
+
+### Fixed
+- **Clean screen on normal shutdown** - Screen now clears on Ctrl+C / quit, not just on update restart (#145)
+
 ## [0.48.14] - 2026-01-09
 
 ### Fixed

package/dist/index.js

@@ -42039,6 +42039,233 @@ var require_cjs = __commonJS((exports, module) => {
   module.exports = deepmerge_1;
 });
 
+// node_modules/react/cjs/react-jsx-runtime.development.js
+var require_react_jsx_runtime_development = __commonJS((exports) => {
+  var React28 = __toESM(require_react());
+  (function() {
+    function getComponentNameFromType(type) {
+      if (type == null)
+        return null;
+      if (typeof type === "function")
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if (typeof type === "string")
+        return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if (typeof type === "object")
+        switch (typeof type.tag === "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {}
+        }
+      return null;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE)
+        return "<>";
+      if (typeof type === "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return dispatcher === null ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning)
+          return false;
+      }
+      return config.key !== undefined;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return componentName !== undefined ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      (refProp !== undefined ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+      var children = config.children;
+      if (children !== undefined)
+        if (isStaticChildren)
+          if (isArrayImpl(children)) {
+            for (isStaticChildren = 0;isStaticChildren < children.length; isStaticChildren++)
+              validateChildKeys(children[isStaticChildren]);
+            Object.freeze && Object.freeze(children);
+          } else
+            console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+        else
+          validateChildKeys(children);
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function(k) {
+          return k !== "key";
+        });
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = true);
+      }
+      children = null;
+      maybeKey !== undefined && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          propName !== "key" && (maybeKey[propName] = config[propName]);
+      } else
+        maybeKey = config;
+      children && defineKeyPropWarningGetter(maybeKey, typeof type === "function" ? type.displayName || type.name || "Unknown" : type);
+      return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask);
+    }
+    function validateChildKeys(node) {
+      isValidElement2(node) ? node._store && (node._store.validated = 1) : typeof node === "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement2(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement2(object) {
+      return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React28.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    React28 = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = React28.react_stack_bottom_frame.bind(React28, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutKeySpread = {};
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.jsx = function(type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(type, config, maybeKey, false, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+    exports.jsxs = function(type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(type, config, maybeKey, true, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+  })();
+});
+
+// node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS((exports, module) => {
+  var react_jsx_runtime_development = __toESM(require_react_jsx_runtime_development());
+  if (false) {} else {
+    module.exports = react_jsx_runtime_development;
+  }
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -54471,7 +54698,7 @@ class SessionManager extends EventEmitter4 {
   }
 }
 // src/ui/index.ts
-var import_react59 = __toESM(require_react(), 1);
+var import_react62 = __toESM(require_react(), 1);
 
 // node_modules/ink/build/render.js
 import { Stream } from "stream";
@@ -59583,25 +59810,6 @@ var getInstance = (stdout, createInstance2) => {
 };
 // node_modules/ink/build/components/Static.js
 var import_react14 = __toESM(require_react(), 1);
-function Static(props) {
-  const { items, children: render2, style: customStyle } = props;
-  const [index, setIndex] = import_react14.useState(0);
-  const itemsToRender = import_react14.useMemo(() => {
-    return items.slice(index);
-  }, [items, index]);
-  import_react14.useLayoutEffect(() => {
-    setIndex(items.length);
-  }, [items.length]);
-  const children = itemsToRender.map((item, itemIndex) => {
-    return render2(item, index + itemIndex);
-  });
-  const style = import_react14.useMemo(() => ({
-    position: "absolute",
-    flexDirection: "column",
-    ...customStyle
-  }), [customStyle]);
-  return import_react14.default.createElement("ink-box", { internal_static: true, style }, children);
-}
 // node_modules/ink/build/components/Transform.js
 var import_react15 = __toESM(require_react(), 1);
 // node_modules/ink/build/components/Newline.js
@@ -59871,8 +60079,14 @@ var import_react23 = __toESM(require_react(), 1);
 var import_react24 = __toESM(require_react(), 1);
 // node_modules/ink/build/hooks/use-is-screen-reader-enabled.js
 var import_react25 = __toESM(require_react(), 1);
+// node_modules/ink/build/measure-element.js
+var measureElement = (node) => ({
+  width: node.yogaNode?.getComputedWidth() ?? 0,
+  height: node.yogaNode?.getComputedHeight() ?? 0
+});
+var measure_element_default = measureElement;
 // src/ui/App.tsx
-var import_react58 = __toESM(require_react(), 1);
+var import_react61 = __toESM(require_react(), 1);
 
 // src/ui/components/Header.tsx
 var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
@@ -62990,9 +63204,16 @@ function Platforms({ platforms }) {
   return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     flexDirection: "column",
     marginTop: 1,
-    children: Array.from(platforms.values()).map((platform2) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
+    children: Array.from(platforms.values()).map((platform2, index) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
       gap: 1,
       children: [
+        /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
+          dimColor: true,
+          children: [
+            index + 1,
+            "."
+          ]
+        }, undefined, true, undefined, this),
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
           children: getPlatformIcon(platform2.platformType || "mattermost")
         }, undefined, false, undefined, this),
@@ -63111,7 +63332,7 @@ function getStatusIndicator2(status) {
   }
 }
 function CollapsibleSession(props) {
-  const { session, logs, expanded } = props;
+  const { session, logs, expanded, sessionNumber } = props;
   const { icon, color } = getStatusIndicator2(session.status);
   const platformIcon = getPlatformIcon(session.platformType || "mattermost");
   const arrow = expanded ? "\u25BC" : "\u25B6";
@@ -63125,6 +63346,13 @@ function CollapsibleSession(props) {
       /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
         gap: 1,
         children: [
+          /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              sessionNumber,
+              "."
+            ]
+          }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
             children: platformIcon
           }, undefined, false, undefined, this),
@@ -63389,6 +63617,12 @@ function StatusLine({
                 label: "eep-alive",
                 enabled: toggles.keepAliveEnabled
               }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(ToggleKey, {
+                keyChar: "l",
+                label: "ogs",
+                enabled: toggles.logsFocused,
+                color: toggles.logsFocused ? "cyan" : "gray"
+              }, undefined, false, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime7.jsxDEV(Box_default, {
                 gap: 0,
                 children: [
@@ -63446,6 +63680,282 @@ function StatusLine({
     ]
   }, undefined, true, undefined, this);
 }
+// src/ui/components/LogPanel.tsx
+var import_react59 = __toESM(require_react(), 1);
+
+// node_modules/ink-scroll-view/dist/index.js
+var import_react57 = __toESM(require_react(), 1);
+var import_react58 = __toESM(require_react(), 1);
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
+var MeasurableItem = ({
+  children,
+  onMeasure,
+  index,
+  width,
+  measureKey
+}) => {
+  const ref = import_react58.useRef(null);
+  import_react58.useLayoutEffect(() => {
+    if (ref.current) {
+      const { height } = measure_element_default(ref.current);
+      onMeasure(index, height);
+    }
+  }, [index, onMeasure, width, measureKey, children]);
+  return /* @__PURE__ */ import_jsx_runtime.jsx(Box_default, { ref, flexShrink: 0, width: "100%", flexDirection: "column", children });
+};
+function useStateRef(initialValue) {
+  const [state, setStateInternal] = import_react58.useState(initialValue);
+  const ref = import_react58.useRef(initialValue);
+  const setState = import_react58.useCallback((update) => {
+    const nextValue = typeof update === "function" ? update(ref.current) : update;
+    ref.current = nextValue;
+    setStateInternal(nextValue);
+  }, []);
+  const getState = import_react58.useCallback(() => ref.current, []);
+  return [state, setState, getState];
+}
+var ControlledScrollView = import_react58.forwardRef(({
+  scrollOffset,
+  onViewportSizeChange,
+  onContentHeightChange,
+  onItemHeightChange,
+  debug = false,
+  children,
+  ...boxProps
+}, ref) => {
+  const [viewportSize, setViewportSize, getViewportSize] = useStateRef({
+    height: 0,
+    width: 0
+  });
+  const [contentHeight, setContentHeight, getContentHeight] = useStateRef(0);
+  const [itemMeasureKeys, setItemMeasureKeys] = import_react58.useState({});
+  const viewportRef = import_react58.useRef(null);
+  const contentRef = import_react58.useRef(null);
+  const prevContentHeightRef = import_react58.useRef(0);
+  import_react58.useLayoutEffect(() => {
+    if (contentHeight !== prevContentHeightRef.current) {
+      onContentHeightChange?.(contentHeight, prevContentHeightRef.current);
+      prevContentHeightRef.current = contentHeight;
+    }
+  }, [contentHeight, onContentHeightChange]);
+  const itemHeightsRef = import_react58.useRef({});
+  const itemKeysRef = import_react58.useRef([]);
+  const itemOffsetsRef = import_react58.useRef([]);
+  const firstInvalidOffsetIndexRef = import_react58.useRef(0);
+  const handleItemMeasure = import_react58.useCallback((index, height) => {
+    const key = itemKeysRef.current[index] || index;
+    if (itemHeightsRef.current[key] !== height) {
+      const previousHeight = itemHeightsRef.current[key] || 0;
+      itemHeightsRef.current = {
+        ...itemHeightsRef.current,
+        [key]: height
+      };
+      let newTotalHeight = 0;
+      for (const itemKey of itemKeysRef.current) {
+        newTotalHeight += itemHeightsRef.current[itemKey] || 0;
+      }
+      const currentHeight = getContentHeight();
+      if (newTotalHeight !== currentHeight) {
+        setContentHeight(newTotalHeight);
+      }
+      onItemHeightChange?.(index, height, previousHeight);
+      firstInvalidOffsetIndexRef.current = Math.min(firstInvalidOffsetIndexRef.current, index + 1);
+    }
+  }, [
+    onItemHeightChange,
+    onContentHeightChange,
+    getContentHeight,
+    setContentHeight
+  ]);
+  const measureViewport = import_react58.useCallback(() => {
+    if (viewportRef.current) {
+      const { width, height } = measure_element_default(viewportRef.current);
+      const currentSize = getViewportSize();
+      if (width !== currentSize.width || height !== currentSize.height) {
+        onViewportSizeChange?.({ width, height }, currentSize);
+        setViewportSize({ width, height });
+      }
+    }
+  }, [viewportRef, onViewportSizeChange, getViewportSize, setViewportSize]);
+  import_react58.useLayoutEffect(() => {
+    measureViewport();
+  });
+  const prevChildrenRef = import_react58.useRef(null);
+  if (prevChildrenRef.current !== children) {
+    prevChildrenRef.current = children;
+    const newItemKeys = [];
+    const newItemHeights = {};
+    import_react58.Children.forEach(children, (child, index) => {
+      if (!child)
+        return;
+      const key = import_react58.isValidElement(child) ? child.key : null;
+      const effectiveKey = key !== null ? key : index;
+      newItemKeys[index] = effectiveKey;
+      const itemHeight = itemHeightsRef.current[effectiveKey] || 0;
+      newItemHeights[effectiveKey] = itemHeight;
+    });
+    itemHeightsRef.current = newItemHeights;
+    itemKeysRef.current = newItemKeys;
+    itemOffsetsRef.current = new Array(newItemKeys.length).fill(0);
+    firstInvalidOffsetIndexRef.current = 0;
+    let newTotalHeight = 0;
+    newItemKeys.forEach((itemKey) => {
+      newTotalHeight += newItemHeights[itemKey] || 0;
+    });
+    const currentHeight = getContentHeight();
+    if (newTotalHeight !== currentHeight) {
+      setContentHeight(newTotalHeight);
+    }
+  }
+  import_react58.useImperativeHandle(ref, () => ({
+    getContentHeight,
+    getViewportHeight: () => getViewportSize().height,
+    getBottomOffset: () => Math.max(0, getContentHeight() - getViewportSize().height),
+    getItemHeight: (index) => {
+      const key = itemKeysRef.current[index] || index;
+      return itemHeightsRef.current[key] || 0;
+    },
+    remeasure: measureViewport,
+    remeasureItem: (index) => setItemMeasureKeys((prev) => ({
+      ...prev,
+      [index]: (prev[index] || 0) + 1
+    })),
+    getItemPosition: (index) => {
+      if (index < 0 || index >= itemKeysRef.current.length) {
+        return null;
+      }
+      if (index >= firstInvalidOffsetIndexRef.current) {
+        let currentOffset = 0;
+        let startIndex = 0;
+        if (firstInvalidOffsetIndexRef.current > 0) {
+          startIndex = firstInvalidOffsetIndexRef.current;
+          const prevIndex = startIndex - 1;
+          const prevKey = itemKeysRef.current[prevIndex] || prevIndex;
+          const prevHeight = itemHeightsRef.current[prevKey] || 0;
+          currentOffset = (itemOffsetsRef.current[prevIndex] ?? 0) + prevHeight;
+        }
+        for (let i = startIndex;i <= index; i++) {
+          itemOffsetsRef.current[i] = currentOffset;
+          const key2 = itemKeysRef.current[i] || i;
+          const height2 = itemHeightsRef.current[key2] || 0;
+          currentOffset += height2;
+        }
+        firstInvalidOffsetIndexRef.current = index + 1;
+      }
+      const top = itemOffsetsRef.current[index] ?? 0;
+      const key = itemKeysRef.current[index] || index;
+      const height = itemHeightsRef.current[key] || 0;
+      return { top, height };
+    }
+  }), []);
+  return /* @__PURE__ */ import_jsx_runtime.jsx(Box_default, { ...boxProps, children: /* @__PURE__ */ import_jsx_runtime.jsx(Box_default, { ref: viewportRef, width: "100%", children: /* @__PURE__ */ import_jsx_runtime.jsx(Box_default, { overflow: debug ? undefined : "hidden", width: "100%", children: /* @__PURE__ */ import_jsx_runtime.jsx(Box_default, {
+    ref: contentRef,
+    width: "100%",
+    flexDirection: "column",
+    marginTop: -scrollOffset,
+    children: import_react58.Children.map(children, (child, index) => {
+      if (!child)
+        return null;
+      return /* @__PURE__ */ import_jsx_runtime.jsx(MeasurableItem, {
+        index,
+        width: viewportSize.width,
+        onMeasure: handleItemMeasure,
+        measureKey: itemMeasureKeys[index],
+        children: child
+      }, import_react58.isValidElement(child) ? child.key || index : index);
+    })
+  }) }) }) });
+});
+function useStateRef2(initialValue) {
+  const [state, setStateInternal] = import_react57.useState(initialValue);
+  const ref = import_react57.useRef(initialValue);
+  const setState = import_react57.useCallback((update) => {
+    const nextValue = typeof update === "function" ? update(ref.current) : update;
+    ref.current = nextValue;
+    setStateInternal(nextValue);
+  }, []);
+  const getState = import_react57.useCallback(() => ref.current, []);
+  return [state, setState, getState];
+}
+var ScrollView = import_react57.forwardRef(({
+  onScroll,
+  onViewportSizeChange,
+  onContentHeightChange,
+  onItemHeightChange,
+  debug = false,
+  children,
+  ...boxProps
+}, ref) => {
+  const [scrollOffset, setScrollOffset, getScrollOffset] = useStateRef2(0);
+  const innerRef = import_react57.useRef(null);
+  const contentHeightRef = import_react57.useRef(0);
+  const handleContentHeightChange = import_react57.useCallback((height, previousHeight) => {
+    contentHeightRef.current = height;
+    onContentHeightChange?.(height, previousHeight);
+    if (getScrollOffset() > height) {
+      setScrollOffset(height);
+      onScroll?.(height);
+    }
+  }, [onContentHeightChange, onScroll, getScrollOffset, setScrollOffset]);
+  const getBottomOffset = import_react57.useCallback(() => Math.max(0, contentHeightRef.current - (innerRef.current?.getViewportHeight() || 0)), []);
+  import_react57.useImperativeHandle(ref, () => ({
+    scrollTo: (offset) => {
+      if (typeof offset !== "number" || isNaN(offset)) {
+        return;
+      }
+      const currentContentHeight = contentHeightRef.current;
+      const newScrollTop = Math.max(0, Math.min(offset, currentContentHeight));
+      if (newScrollTop !== getScrollOffset()) {
+        setScrollOffset(newScrollTop);
+        onScroll?.(newScrollTop);
+      }
+    },
+    scrollBy: (delta) => {
+      if (typeof delta !== "number" || isNaN(delta)) {
+        return;
+      }
+      const currentContentHeight = contentHeightRef.current;
+      const newScrollTop = Math.max(0, Math.min(getScrollOffset() + delta, currentContentHeight));
+      if (newScrollTop !== getScrollOffset()) {
+        setScrollOffset(newScrollTop);
+        onScroll?.(newScrollTop);
+      }
+    },
+    scrollToTop: () => {
+      if (getScrollOffset() !== 0) {
+        setScrollOffset(0);
+        onScroll?.(0);
+      }
+    },
+    scrollToBottom: () => {
+      const bottomOffset = getBottomOffset();
+      if (getScrollOffset() !== bottomOffset) {
+        setScrollOffset(bottomOffset);
+        onScroll?.(bottomOffset);
+      }
+    },
+    getScrollOffset,
+    getContentHeight: () => contentHeightRef.current,
+    getViewportHeight: () => innerRef.current?.getViewportHeight() || 0,
+    getBottomOffset,
+    getItemHeight: (index) => innerRef.current?.getItemHeight(index) || 0,
+    getItemPosition: (index) => innerRef.current?.getItemPosition(index) || null,
+    remeasure: () => innerRef.current?.remeasure(),
+    remeasureItem: (index) => innerRef.current?.remeasureItem(index)
+  }), [onScroll, getBottomOffset, getScrollOffset, setScrollOffset]);
+  return /* @__PURE__ */ import_jsx_runtime2.jsx(ControlledScrollView, {
+    ref: innerRef,
+    scrollOffset,
+    onViewportSizeChange,
+    onContentHeightChange: handleContentHeightChange,
+    onItemHeightChange,
+    debug,
+    children,
+    ...boxProps
+  });
+});
+
 // src/ui/components/LogPanel.tsx
 var jsx_dev_runtime8 = __toESM(require_jsx_dev_runtime(), 1);
 function getLevelColor(level) {
@@ -63464,34 +63974,70 @@ var COMPONENT_WIDTH2 = 10;
 function padComponent2(name) {
   return name.padEnd(COMPONENT_WIDTH2);
 }
-function LogPanel({ logs, maxLines = 10 }) {
+function LogPanel({ logs, maxLines = 10, focused = false }) {
+  const scrollRef = import_react59.default.useRef(null);
+  const { stdout } = use_stdout_default();
   const isDebug = process.env.DEBUG === "1";
-  const displayLogs = logs.filter((log19) => isDebug || log19.level !== "debug").slice(-maxLines);
-  if (displayLogs.length === 0) {
+  const displayLogs = logs.filter((log19) => isDebug || log19.level !== "debug");
+  const visibleLogs = displayLogs.slice(-Math.max(maxLines * 3, 100));
+  import_react59.default.useEffect(() => {
+    const handleResize = () => scrollRef.current?.remeasure();
+    stdout?.on("resize", handleResize);
+    return () => {
+      stdout?.off("resize", handleResize);
+    };
+  }, [stdout]);
+  import_react59.default.useEffect(() => {
+    if (!focused && scrollRef.current) {
+      scrollRef.current.scrollToBottom();
+    }
+  }, [displayLogs.length, focused]);
+  use_input_default((input, key) => {
+    if (!focused)
+      return;
+    if (key.upArrow) {
+      scrollRef.current?.scrollBy(-1);
+    } else if (key.downArrow) {
+      scrollRef.current?.scrollBy(1);
+    } else if (key.pageUp) {
+      scrollRef.current?.scrollBy(-5);
+    } else if (key.pageDown) {
+      scrollRef.current?.scrollBy(5);
+    } else if (input === "g") {
+      scrollRef.current?.scrollToTop();
+    } else if (input === "G") {
+      scrollRef.current?.scrollToBottom();
+    }
+  }, { isActive: focused });
+  if (visibleLogs.length === 0) {
     return null;
   }
   return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
     flexDirection: "column",
-    marginTop: 1,
-    children: displayLogs.map((log19) => /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
-      children: [
-        /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
-          dimColor: true,
-          children: [
-            "[",
-            padComponent2(log19.component),
-            "]"
-          ]
-        }, undefined, true, undefined, this),
-        /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
-          color: getLevelColor(log19.level),
-          children: [
-            " ",
-            log19.message
-          ]
-        }, undefined, true, undefined, this)
-      ]
-    }, log19.id, true, undefined, this))
+    height: maxLines,
+    overflow: "hidden",
+    children: /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(ScrollView, {
+      ref: scrollRef,
+      children: visibleLogs.map((log19) => /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Box_default, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              "[",
+              padComponent2(log19.component),
+              "]"
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime8.jsxDEV(Text, {
+            color: getLevelColor(log19.level),
+            children: [
+              " ",
+              log19.message
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, log19.id, true, undefined, this))
+    }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
 // src/ui/components/Modal.tsx
@@ -63676,10 +64222,10 @@ function UpdateModal({ state }) {
   }, undefined, true, undefined, this);
 }
 // src/ui/hooks/useAppState.ts
-var import_react57 = __toESM(require_react(), 1);
+var import_react60 = __toESM(require_react(), 1);
 var logIdCounter = 0;
 function useAppState(initialConfig) {
-  const [state, setState] = import_react57.useState({
+  const [state, setState] = import_react60.useState({
     config: initialConfig,
     platforms: new Map,
     sessions: new Map,
@@ -63688,13 +64234,13 @@ function useAppState(initialConfig) {
     ready: false,
     shuttingDown: false
   });
-  const setReady = import_react57.useCallback(() => {
+  const setReady = import_react60.useCallback(() => {
     setState((prev) => ({ ...prev, ready: true }));
   }, []);
-  const setShuttingDown2 = import_react57.useCallback(() => {
+  const setShuttingDown2 = import_react60.useCallback(() => {
     setState((prev) => ({ ...prev, shuttingDown: true }));
   }, []);
-  const addSession = import_react57.useCallback((session) => {
+  const addSession = import_react60.useCallback((session) => {
     setState((prev) => {
       const sessions = new Map(prev.sessions);
       sessions.set(session.id, session);
@@ -63705,7 +64251,7 @@ function useAppState(initialConfig) {
       return { ...prev, sessions, expandedSessions };
     });
   }, []);
-  const updateSession = import_react57.useCallback((sessionId, updates) => {
+  const updateSession = import_react60.useCallback((sessionId, updates) => {
     setState((prev) => {
       const sessions = new Map(prev.sessions);
       const session = sessions.get(sessionId);
@@ -63715,7 +64261,7 @@ function useAppState(initialConfig) {
       return { ...prev, sessions };
     });
   }, []);
-  const removeSession = import_react57.useCallback((sessionId) => {
+  const removeSession = import_react60.useCallback((sessionId) => {
     setState((prev) => {
       const sessions = new Map(prev.sessions);
       sessions.delete(sessionId);
@@ -63724,7 +64270,7 @@ function useAppState(initialConfig) {
       return { ...prev, sessions, expandedSessions };
     });
   }, []);
-  const addLog = import_react57.useCallback((entry) => {
+  const addLog = import_react60.useCallback((entry) => {
     const newEntry = {
       ...entry,
       id: `log-${++logIdCounter}`,
@@ -63735,7 +64281,7 @@ function useAppState(initialConfig) {
       return { ...prev, logs };
     });
   }, []);
-  const toggleSession = import_react57.useCallback((sessionId) => {
+  const toggleSession = import_react60.useCallback((sessionId) => {
     setState((prev) => {
       const expandedSessions = new Set(prev.expandedSessions);
       if (expandedSessions.has(sessionId)) {
@@ -63746,7 +64292,7 @@ function useAppState(initialConfig) {
       return { ...prev, expandedSessions };
     });
   }, []);
-  const setPlatformStatus = import_react57.useCallback((platformId, status) => {
+  const setPlatformStatus = import_react60.useCallback((platformId, status) => {
     setState((prev) => {
       const platforms = new Map(prev.platforms);
       const current = platforms.get(platformId) || {
@@ -63763,13 +64309,13 @@ function useAppState(initialConfig) {
       return { ...prev, platforms };
     });
   }, []);
-  const getLogsForSession = import_react57.useCallback((sessionId) => {
+  const getLogsForSession = import_react60.useCallback((sessionId) => {
     return state.logs.filter((log19) => log19.sessionId === sessionId);
   }, [state.logs]);
-  const getGlobalLogs = import_react57.useCallback(() => {
+  const getGlobalLogs = import_react60.useCallback(() => {
     return state.logs.filter((log19) => !log19.sessionId);
   }, [state.logs]);
-  const togglePlatformEnabled = import_react57.useCallback((platformId) => {
+  const togglePlatformEnabled = import_react60.useCallback((platformId) => {
     let newEnabled = false;
     setState((prev) => {
       const platforms = new Map(prev.platforms);
@@ -63821,13 +64367,21 @@ function useKeyboard({
   onChromeToggle,
   onKeepAliveToggle,
   onUpdateModalToggle,
+  onLogsFocusToggle,
   onForceUpdate,
-  updateModalVisible
+  updateModalVisible,
+  logsFocused
 }) {
   use_input_default((input, key) => {
-    if (key.escape && updateModalVisible) {
-      onUpdateModalToggle?.();
-      return;
+    if (key.escape) {
+      if (updateModalVisible) {
+        onUpdateModalToggle?.();
+        return;
+      }
+      if (logsFocused) {
+        onLogsFocusToggle?.();
+        return;
+      }
     }
     if (input === "\x03" || input === "c" && key.ctrl) {
       if (onQuit) {
@@ -63870,6 +64424,9 @@ function useKeyboard({
       case "u":
         onUpdateModalToggle?.();
         break;
+      case "l":
+        onLogsFocusToggle?.();
+        break;
       case "q":
         onQuit?.();
         break;
@@ -63879,6 +64436,14 @@ function useKeyboard({
 
 // src/ui/App.tsx
 var jsx_dev_runtime11 = __toESM(require_jsx_dev_runtime(), 1);
+var SEPARATOR = "\u2500".repeat(50);
+var Separator = import_react61.default.memo(() => /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
+  marginTop: 1,
+  children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+    dimColor: true,
+    children: SEPARATOR
+  }, undefined, false, undefined, this)
+}, undefined, false, undefined, this));
 function App2({ config, onStateReady, onResizeReady, onQuit, toggleCallbacks }) {
   const {
     state,
@@ -63894,19 +64459,22 @@ function App2({ config, onStateReady, onResizeReady, onQuit, toggleCallbacks })
     getLogsForSession,
     getGlobalLogs
   } = useAppState(config);
-  const [resizeCount, setResizeCount] = import_react58.default.useState(0);
-  const [toggles, setToggles] = import_react58.default.useState({
+  const [resizeCount, setResizeCount] = import_react61.default.useState(0);
+  const { stdout } = use_stdout_default();
+  const terminalRows = stdout?.rows ?? 24;
+  const [toggles, setToggles] = import_react61.default.useState({
     debugMode: process.env.DEBUG === "1",
     skipPermissions: config.skipPermissions,
     chromeEnabled: config.chromeEnabled,
     keepAliveEnabled: config.keepAliveEnabled,
-    updateModalVisible: false
+    updateModalVisible: false,
+    logsFocused: false
   });
-  const [updateState, setUpdateState] = import_react58.default.useState({
+  const [updateState, setUpdateState] = import_react61.default.useState({
     status: "idle",
     currentVersion: config.version
   });
-  const handleDebugToggle = import_react58.default.useCallback(() => {
+  const handleDebugToggle = import_react61.default.useCallback(() => {
     setToggles((prev) => {
       const newValue = !prev.debugMode;
       process.env.DEBUG = newValue ? "1" : "";
@@ -63914,36 +64482,39 @@ function App2({ config, onStateReady, onResizeReady, onQuit, toggleCallbacks })
       return { ...prev, debugMode: newValue };
     });
   }, [toggleCallbacks]);
-  const handlePermissionsToggle = import_react58.default.useCallback(() => {
+  const handlePermissionsToggle = import_react61.default.useCallback(() => {
     setToggles((prev) => {
       const newValue = !prev.skipPermissions;
       toggleCallbacks?.onPermissionsToggle?.(newValue);
       return { ...prev, skipPermissions: newValue };
     });
   }, [toggleCallbacks]);
-  const handleChromeToggle = import_react58.default.useCallback(() => {
+  const handleChromeToggle = import_react61.default.useCallback(() => {
     setToggles((prev) => {
       const newValue = !prev.chromeEnabled;
       toggleCallbacks?.onChromeToggle?.(newValue);
       return { ...prev, chromeEnabled: newValue };
     });
   }, [toggleCallbacks]);
-  const handleKeepAliveToggle = import_react58.default.useCallback(() => {
+  const handleKeepAliveToggle = import_react61.default.useCallback(() => {
     setToggles((prev) => {
       const newValue = !prev.keepAliveEnabled;
       toggleCallbacks?.onKeepAliveToggle?.(newValue);
       return { ...prev, keepAliveEnabled: newValue };
     });
   }, [toggleCallbacks]);
-  const handleUpdateModalToggle = import_react58.default.useCallback(() => {
+  const handleUpdateModalToggle = import_react61.default.useCallback(() => {
     setToggles((prev) => ({ ...prev, updateModalVisible: !prev.updateModalVisible }));
   }, []);
-  const handlePlatformToggle = import_react58.default.useCallback((platformId) => {
+  const handleLogsFocusToggle = import_react61.default.useCallback(() => {
+    setToggles((prev) => ({ ...prev, logsFocused: !prev.logsFocused }));
+  }, []);
+  const handlePlatformToggle = import_react61.default.useCallback((platformId) => {
     const newEnabled = togglePlatformEnabled(platformId);
     toggleCallbacks?.onPlatformToggle?.(platformId, newEnabled);
   }, [togglePlatformEnabled, toggleCallbacks]);
-  const getToggles = import_react58.default.useCallback(() => toggles, [toggles]);
-  import_react58.default.useEffect(() => {
+  const getToggles = import_react61.default.useCallback(() => toggles, [toggles]);
+  import_react61.default.useEffect(() => {
     onStateReady({
       setReady,
       setShuttingDown: setShuttingDown2,
@@ -63956,7 +64527,7 @@ function App2({ config, onStateReady, onResizeReady, onQuit, toggleCallbacks })
       getToggles
     });
   }, [onStateReady, setReady, setShuttingDown2, addSession, updateSession, removeSession, addLog, setPlatformStatus, setUpdateState, getToggles]);
-  import_react58.default.useEffect(() => {
+  import_react61.default.useEffect(() => {
     if (onResizeReady) {
       onResizeReady(() => setResizeCount((c) => c + 1));
     }
@@ -63974,82 +64545,108 @@ function App2({ config, onStateReady, onResizeReady, onQuit, toggleCallbacks })
     onChromeToggle: handleChromeToggle,
     onKeepAliveToggle: handleKeepAliveToggle,
     onUpdateModalToggle: handleUpdateModalToggle,
+    onLogsFocusToggle: handleLogsFocusToggle,
     onForceUpdate: toggleCallbacks?.onForceUpdate,
-    updateModalVisible: toggles.updateModalVisible
+    updateModalVisible: toggles.updateModalVisible,
+    logsFocused: toggles.logsFocused
   });
-  const staticContent = import_react58.default.useMemo(() => [
-    { id: `header-${resizeCount}`, element: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Header, {
-      version: config.version
-    }, undefined, false, undefined, this) },
-    { id: `config-${resizeCount}`, element: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(ConfigSummary, {
-      config
-    }, undefined, false, undefined, this) }
-  ], [config, resizeCount]);
   const globalLogs = getGlobalLogs();
   const hasLogs = globalLogs.length > 0;
   const hasSessions = state.sessions.size > 0;
+  const platformCount = Math.max(1, state.platforms.size);
+  const sessionCount = Math.max(1, state.sessions.size);
+  const fixedOverhead = 5 + 4 + 3 + platformCount + 3 + 3 + sessionCount + 3;
+  const logHeight = Math.max(3, terminalRows - fixedOverhead);
   return /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
     flexDirection: "column",
+    height: terminalRows,
     children: [
-      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Static, {
-        items: staticContent,
-        children: (item) => /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
-          children: item.element
-        }, item.id, false, undefined, this)
+      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Header, {
+        version: config.version
       }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(ConfigSummary, {
+        config
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Separator, {}, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            dimColor: true,
+            bold: true,
+            children: "Platforms"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              " (",
+              state.platforms.size,
+              ")"
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Platforms, {
         platforms: state.platforms
       }, undefined, false, undefined, this),
-      hasLogs && /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(jsx_dev_runtime11.Fragment, {
+      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Separator, {}, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
         children: [
-          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
-            marginTop: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
-              dimColor: true,
-              children: "\u2500".repeat(50)
-            }, undefined, false, undefined, this)
+          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            dimColor: true,
+            bold: toggles.logsFocused,
+            color: toggles.logsFocused ? "cyan" : undefined,
+            children: "Logs"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(LogPanel, {
-            logs: globalLogs,
-            maxLines: 10
+          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              " (",
+              globalLogs.length,
+              ")"
+            ]
+          }, undefined, true, undefined, this),
+          toggles.logsFocused && /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            dimColor: true,
+            children: " - \u2191\u2193 scroll, g/G top/bottom, [l] unfocus"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      hasSessions && /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(jsx_dev_runtime11.Fragment, {
+      hasLogs ? /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(LogPanel, {
+        logs: globalLogs,
+        maxLines: logHeight,
+        focused: toggles.logsFocused
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+        dimColor: true,
+        italic: true,
+        children: "  No logs yet"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Separator, {}, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
         children: [
-          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
-            marginTop: 1,
-            children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
-              dimColor: true,
-              children: "\u2500".repeat(50)
-            }, undefined, false, undefined, this)
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
-            marginTop: 0,
-            children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
-              dimColor: true,
-              children: [
-                "Sessions (",
-                state.sessions.size,
-                ")"
-              ]
-            }, undefined, true, undefined, this)
+          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            dimColor: true,
+            bold: true,
+            children: "Threads"
           }, undefined, false, undefined, this),
-          Array.from(state.sessions.entries()).map(([id, session], index) => /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(CollapsibleSession, {
-            session,
-            logs: getLogsForSession(id),
-            expanded: state.expandedSessions.has(id),
-            sessionNumber: index + 1
-          }, id, false, undefined, this))
+          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              " (",
+              state.sessions.size,
+              ")"
+            ]
+          }, undefined, true, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(StatusLine, {
-        ready: state.ready,
-        shuttingDown: state.shuttingDown,
-        sessionCount: state.sessions.size,
-        toggles,
-        platforms: state.platforms,
-        updateState
+      hasSessions ? Array.from(state.sessions.entries()).map(([id, session], index) => /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(CollapsibleSession, {
+        session,
+        logs: getLogsForSession(id),
+        expanded: state.expandedSessions.has(id),
+        sessionNumber: index + 1
+      }, id, false, undefined, this)) : /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+        dimColor: true,
+        italic: true,
+        children: "  No active threads"
       }, undefined, false, undefined, this),
       toggles.updateModalVisible && /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
         marginTop: 1,
@@ -64057,6 +64654,14 @@ function App2({ config, onStateReady, onResizeReady, onQuit, toggleCallbacks })
         children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(UpdateModal, {
           state: updateState
         }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(StatusLine, {
+        ready: state.ready,
+        shuttingDown: state.shuttingDown,
+        sessionCount: state.sessions.size,
+        toggles,
+        platforms: state.platforms,
+        updateState
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
@@ -64073,7 +64678,7 @@ async function startUI(options) {
     resolveHandlers = resolve6;
   });
   let onResize = null;
-  const { waitUntilExit } = render_default(import_react59.default.createElement(App2, {
+  const { waitUntilExit } = render_default(import_react62.default.createElement(App2, {
     config,
     onStateReady: (handlers2) => resolveHandlers(handlers2),
     onResizeReady: (handler) => {
@@ -65064,6 +65669,7 @@ function hasRequiredCliArgs(args) {
   return !!(args.url && args.token && args.channel);
 }
 async function main() {
+  process.stdout.write("\x1B[2J\x1B[H");
   const shouldUseAutoRestart = async () => {
     if (opts.autoRestart === false)
       return false;
@@ -65397,6 +66003,8 @@ async function main() {
     for (const client of platforms.values()) {
       client.disconnect();
     }
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write("\x1B[?25h");
   };
   triggerShutdown = () => {
     shutdown("Ctrl+C").finally(() => process.exit(0));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "0.48.14",
+  "version": "0.48.16",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",
@@ -67,6 +67,7 @@
     "commander": "^14.0.2",
     "diff": "^8.0.2",
     "ink": "^6.6.0",
+    "ink-scroll-view": "^0.3.5",
     "prompts": "^2.4.2",
     "react": "^19.2.3",
     "react-devtools-core": "^7.0.1",