anima-core 0.3.0 → 1.0.0

data/lib/tui/app.rb

@@ -18,7 +18,8 @@ module TUI
       "q" => :quit
     }.freeze
 
-    MENU_LABELS = COMMAND_KEYS.map { |key, action| "[#{key}] #{action.to_s.tr("_", " ").capitalize}" }.freeze
+    MENU_LABELS = (COMMAND_KEYS.map { |key, action| "[#{key}] #{action.to_s.tr("_", " ").capitalize}" } +
+      ["[\u2191] Scroll chat", "[\u2193] Return to input"]).freeze
 
     SIDEBAR_WIDTH = 28
 
@@ -88,6 +89,9 @@ module TUI
       @command_mode = false
       @session_picker_active = false
       @session_picker_index = 0
+      @session_picker_page = 0
+      @session_picker_mode = :root
+      @session_picker_parent_id = nil
       @view_mode_picker_active = false
       @view_mode_picker_index = 0
       @token_setup_active = false
@@ -178,19 +182,30 @@ module TUI
       else "cyan"
       end
 
+      session_label = session[:name] || "##{session[:id]}"
+
       lines = [
         tui.line(spans: [
           tui.span(content: "Anima v#{Anima::VERSION}", style: tui.style(fg: "white"))
         ]),
         tui.line(spans: [tui.span(content: "")]),
-        tui.line(spans: [
-          tui.span(content: "Session ", style: tui.style(fg: "dark_gray")),
-          tui.span(content: "##{session[:id]}", style: tui.style(fg: "cyan", modifiers: [:bold]))
-        ]),
+        if session[:name]
+          tui.line(spans: [
+            tui.span(content: session_label, style: tui.style(fg: "cyan", modifiers: [:bold]))
+          ])
+        else
+          tui.line(spans: [
+            tui.span(content: "Session ", style: tui.style(fg: "dark_gray")),
+            tui.span(content: session_label, style: tui.style(fg: "cyan", modifiers: [:bold]))
+          ])
+        end,
         tui.line(spans: [
           tui.span(content: "Messages ", style: tui.style(fg: "dark_gray")),
           tui.span(content: session[:message_count].to_s, style: tui.style(fg: "cyan"))
         ]),
+        active_skills_line(tui, session),
+        active_workflow_line(tui, session),
+        goals_line(tui, session),
         tui.line(spans: [tui.span(content: "")]),
         tui.line(spans: [
           tui.span(content: "Mode ", style: tui.style(fg: "dark_gray")),
@@ -204,7 +219,7 @@ module TUI
           tui.span(content: "Ctrl+a", style: tui.style(fg: "cyan", modifiers: [:bold])),
           tui.span(content: " command mode", style: tui.style(fg: "dark_gray"))
         ])
-      ]
+      ].compact
 
       info = tui.paragraph(
         text: lines,
@@ -218,10 +233,65 @@ module TUI
       frame.render_widget(info, area)
     end
 
+    # Builds the active skills line for the info panel.
+    # Returns nil when no skills are active so the line is hidden entirely.
+    # @param tui [RatatuiRuby] TUI rendering context
+    # @param session [Hash] session info hash containing :active_skills array
+    # @return [RatatuiRuby::Widgets::Line, nil] styled skills line, or nil when empty
+    def active_skills_line(tui, session)
+      skills = session[:active_skills]
+      return if skills.nil? || skills.empty?
+
+      label = skills.join(", ")
+      tui.line(spans: [
+        tui.span(content: "\u{1F4DA} ", style: tui.style(fg: "dark_gray")),
+        tui.span(content: label, style: tui.style(fg: "yellow"))
+      ])
+    end
+
+    # Builds the active workflow line for the info panel.
+    # Returns nil when no workflow is active so the line is hidden entirely.
+    # @param tui [RatatuiRuby] TUI rendering context
+    # @param session [Hash] session info hash containing :active_workflow string
+    # @return [RatatuiRuby::Widgets::Line, nil] styled workflow line, or nil when empty
+    def active_workflow_line(tui, session)
+      workflow = session[:active_workflow]
+      return if workflow.nil? || workflow.empty?
+
+      tui.line(spans: [
+        tui.span(content: "\u{1F504} ", style: tui.style(fg: "dark_gray")),
+        tui.span(content: workflow, style: tui.style(fg: "magenta"))
+      ])
+    end
+
+    # Builds the active goals line for the info panel.
+    # Returns nil when no goals exist so the line is hidden entirely.
+    # Shows root goal count with active/completed breakdown.
+    # @param tui [RatatuiRuby] TUI rendering context
+    # @param session [Hash] session info hash containing :goals array
+    # @return [RatatuiRuby::Widgets::Line, nil] styled goals line, or nil when empty
+    def goals_line(tui, session)
+      goal_list = session[:goals]
+      return if goal_list.nil? || goal_list.empty?
+
+      active = goal_list.count { |g| g["status"] == "active" }
+      completed = goal_list.count { |g| g["status"] == "completed" }
+      label = "#{active} active"
+      label += ", #{completed} done" if completed > 0
+      tui.line(spans: [
+        tui.span(content: "\u{1F3AF} ", style: tui.style(fg: "dark_gray")),
+        tui.span(content: label, style: tui.style(fg: "green"))
+      ])
+    end
+
     # Builds the interaction state line for the info panel.
-    # Shows "Thinking..." during LLM processing.
+    # Shows "Scrolling" when chat pane is focused, or "Thinking..." during LLM processing.
     def interaction_state_line(tui)
-      if chat_loading?
+      if @screens[:chat].chat_focused
+        tui.line(spans: [
+          tui.span(content: "Scrolling", style: tui.style(fg: "yellow", modifiers: [:bold]))
+        ])
+      elsif chat_loading?
         tui.line(spans: [
           tui.span(content: "Thinking...", style: tui.style(fg: "magenta", modifiers: [:bold]))
         ])
@@ -278,6 +348,16 @@ module TUI
 
       return nil unless event.key?
 
+      if event.up?
+        @screens[:chat].focus_chat
+        return nil
+      end
+
+      if event.down?
+        @screens[:chat].unfocus_chat
+        return nil
+      end
+
       action = COMMAND_KEYS[event.code]
       case action
       when :quit
@@ -311,10 +391,30 @@ module TUI
         return nil
       end
 
+      if event.esc?
+        if @screens[:chat].chat_focused
+          @screens[:chat].unfocus_chat
+        else
+          return_to_parent_session
+        end
+        return nil
+      end
+
       delegate_to_screen(event)
       nil
     end
 
+    # Switches to the parent session when viewing a child (sub-agent) session.
+    # No-op if the current session is a root session.
+    #
+    # @return [void]
+    def return_to_parent_session
+      parent_id = @screens[:chat].parent_session_id
+      return unless parent_id
+
+      @screens[:chat].switch_session(parent_id)
+    end
+
     # Forwards an event to the active screen for handling
     def delegate_to_screen(event)
       screen = @screens[@current_screen]
@@ -365,71 +465,197 @@ module TUI
     end
 
     # Maps digit key codes to picker list indices.
-    # Keys 1-9 map to indices 0-8, key 0 maps to index 9.
+    # Keys 1-9 map to indices 0-8. Key 0 is reserved for Load More in paginated pickers.
     #
     # @param code [String] the key code
     # @return [Integer, nil] list index, or nil for non-digit keys
     def hotkey_to_index(code)
       return nil unless code.length == 1
 
-      case code
-      when "1".."9" then code.to_i - 1
-      when "0" then 9
-      end
+      code.to_i - 1 if ("1".."9").cover?(code)
     end
 
     # Returns the hotkey character for a given picker list position.
-    # Positions 0-8 get keys "1"-"9", position 9 gets "0".
+    # Positions 0-8 get keys "1"-"9". Positions beyond 8 get no hotkey.
     #
     # @param idx [Integer] zero-based list position
-    # @return [String, nil] hotkey character, or nil for positions beyond 9
+    # @return [String, nil] hotkey character, or nil for positions beyond 8
     def picker_hotkey(idx)
-      return (idx + 1).to_s if idx < 9
-      return "0" if idx == 9
-      nil
+      (idx + 1).to_s if idx >= 0 && idx < 9
     end
 
     # -- Session picker ------------------------------------------------
 
+    # Status indicators for child session state.
+    CHILD_STATUS_RUNNING = "\u27F3"   # ⟳
+    CHILD_STATUS_DONE = "\u2713"      # ✓
+    CHILDREN_ARROW = "\u25B8"         # ▸ shown next to sessions with children
+    UNNAMED_SUBAGENT_LABEL = "sub-agent"
+    SESSION_PICKER_PAGE_SIZE = 9
+    SESSION_PICKER_FETCH_LIMIT = 50
+    BACK_ARROW = "\u2190"             # ←
+
     # Requests the session list from the brain and opens the picker overlay.
+    # Fetches up to SESSION_PICKER_FETCH_LIMIT sessions for client-side pagination.
     # @return [void]
     def activate_session_picker
       @session_picker_active = true
       @session_picker_index = 0
-      @cable_client.list_sessions
+      @session_picker_page = 0
+      @session_picker_mode = :root
+      @session_picker_parent_id = nil
+      @cable_client.list_sessions(limit: SESSION_PICKER_FETCH_LIMIT)
     end
 
     # Dispatches keyboard events while the session picker overlay is open.
+    # Supports drill-down navigation: root sessions → children, with
+    # pagination via key 0 (Load More) at both levels.
     #
     # @param event [RatatuiRuby::Event] keyboard event
     # @return [nil]
     def handle_session_picker(event)
+      return nil unless event.key?
+
+      if event.esc?
+        handle_session_picker_escape
+        return nil
+      end
+
+      visible = session_picker_visible_items
+      return nil if visible.empty?
+
+      if event.up?
+        @session_picker_index = [@session_picker_index - 1, 0].max
+      elsif event.down?
+        @session_picker_index = [@session_picker_index + 1, visible.size - 1].min
+      elsif event.right?
+        drill_into_children(visible)
+      elsif event.left?
+        return_to_root_sessions
+      elsif event.enter?
+        select_session_picker_item(visible)
+      elsif event.code == "0" && session_picker_has_more?
+        load_more_sessions
+      else
+        idx = hotkey_to_index(event.code)
+        if idx && idx < visible.size
+          @session_picker_index = idx
+          select_session_picker_item(visible)
+        end
+      end
+
+      nil
+    end
+
+    # Returns the raw items for the current picker mode (root sessions or children).
+    #
+    # @return [Array<Hash>] session or child hashes from the sessions list
+    def session_picker_all_items_for_mode
       sessions = @screens[:chat].sessions_list || []
-      result = navigate_picker(event, items: sessions, index_ivar: :@session_picker_index)
 
-      case result
-      when :close
+      case @session_picker_mode
+      when :root
+        sessions
+      when :children
+        parent = sessions.find { |s| s["id"] == @session_picker_parent_id }
+        parent&.dig("children") || []
+      end
+    end
+
+    # Returns the visible items for the current page of the current mode.
+    # Each item is a Hash with :type (:root or :child), :data, and :parent_id (for children).
+    #
+    # @return [Array<Hash>] visible items for the current page
+    def session_picker_visible_items
+      all = session_picker_all_items_for_mode
+      start = @session_picker_page * SESSION_PICKER_PAGE_SIZE
+      page = all[start, SESSION_PICKER_PAGE_SIZE] || []
+
+      page.map do |item|
+        case @session_picker_mode
+        when :root
+          {type: :root, data: item}
+        when :children
+          {type: :child, data: item, parent_id: @session_picker_parent_id}
+        end
+      end
+    end
+
+    # @return [Boolean] true when more items exist beyond the current page
+    def session_picker_has_more?
+      total = session_picker_all_items_for_mode.size
+      ((@session_picker_page + 1) * SESSION_PICKER_PAGE_SIZE) < total
+    end
+
+    # @return [Integer] number of items beyond the current page
+    def session_picker_remaining_count
+      total = session_picker_all_items_for_mode.size
+      [total - ((@session_picker_page + 1) * SESSION_PICKER_PAGE_SIZE), 0].max
+    end
+
+    # Handles Escape in the session picker. In children mode, returns to root.
+    # In root mode, closes the picker.
+    # @return [void]
+    def handle_session_picker_escape
+      if @session_picker_mode == :children
+        return_to_root_sessions
+      else
         @session_picker_active = false
-      when Hash
-        pick_session(result)
       end
+    end
 
-      nil
+    # Drills into the children of the selected root session.
+    # Only available in root mode on sessions with children.
+    #
+    # @param visible [Array<Hash>] current page items from {#session_picker_visible_items}
+    # @return [void]
+    def drill_into_children(visible)
+      return unless @session_picker_mode == :root
+
+      item = visible[@session_picker_index]
+      return unless item&.dig(:type) == :root
+
+      session = item[:data]
+      return unless session["children"]&.any?
+
+      @session_picker_mode = :children
+      @session_picker_parent_id = session["id"]
+      @session_picker_page = 0
+      @session_picker_index = 0
+    end
+
+    # Returns from children mode to root sessions view.
+    # @return [void]
+    def return_to_root_sessions
+      return unless @session_picker_mode == :children
+
+      @session_picker_mode = :root
+      @session_picker_parent_id = nil
+      @session_picker_page = 0
+      @session_picker_index = 0
+    end
+
+    # Advances to the next page of sessions in the current mode.
+    # @return [void]
+    def load_more_sessions
+      @session_picker_page += 1
+      @session_picker_index = 0
     end
 
-    # Switches to the selected session and closes the picker.
+    # Switches to the session selected in the picker and closes the overlay.
     #
-    # @param session [Hash] session entry from sessions_list
+    # @param visible [Array<Hash>] current page items from {#session_picker_visible_items}
     # @return [void]
-    def pick_session(session)
-      return unless session
+    def select_session_picker_item(visible)
+      item = visible[@session_picker_index]
+      return unless item
 
       @session_picker_active = false
-      @screens[:chat].switch_session(session["id"])
+      @screens[:chat].switch_session(item[:data]["id"])
     end
 
     # Renders the session picker overlay in the sidebar.
-    # Shows a loading indicator until the sessions_list arrives from the brain.
+    # Shows paginated root sessions or children with drill-down navigation.
     #
     # @param frame [RatatuiRuby::Frame] terminal frame for widget rendering
     # @param area [RatatuiRuby::Rect] sidebar area to render into
@@ -444,10 +670,19 @@ module TUI
           tui.span(content: "Loading...", style: tui.style(fg: "yellow"))
         ])]
       else
-        lines = sessions.each_with_index.flat_map do |session, idx|
-          format_session_picker_entry(tui, session, idx, current_id)
+        visible = session_picker_visible_items
+        @session_picker_index = @session_picker_index.clamp(0, [visible.size - 1, 0].max)
+
+        lines = visible.each_with_index.flat_map do |item, idx|
+          if item[:type] == :root
+            format_root_session_entry(tui, item[:data], idx, current_id)
+          else
+            format_child_session_entry(tui, item[:data], idx, current_id)
+          end
         end
 
+        lines.concat(format_load_more_entry(tui)) if session_picker_has_more?
+
         if lines.empty?
           lines = [tui.line(spans: [
             tui.span(content: "No sessions", style: tui.style(fg: "dark_gray"))
@@ -458,7 +693,7 @@ module TUI
       picker = tui.paragraph(
         text: lines,
         block: tui.block(
-          title: "Sessions",
+          title: session_picker_title,
           borders: [:all],
           border_type: :rounded,
           border_style: {fg: "cyan"}
@@ -467,26 +702,39 @@ module TUI
       frame.render_widget(picker, area)
     end
 
-    # Formats a single session entry for the picker. Highlights the selected
-    # entry and marks the currently active session.
+    # Returns the picker title based on the current navigation mode.
+    #
+    # @return [String] "Sessions" for root mode, "← #N" for children mode
+    def session_picker_title
+      case @session_picker_mode
+      when :root then "Sessions"
+      when :children then "#{BACK_ARROW} ##{@session_picker_parent_id}"
+      end
+    end
+
+    # Formats a root session entry with drill-in arrow and child count.
     #
     # @param tui [RatatuiRuby] TUI rendering API
-    # @param session [Hash] session data with "id", "message_count", "updated_at"
-    # @param idx [Integer] position in the list (determines hotkey)
-    # @param current_id [Integer] the active session's ID
-    # @return [Array<RatatuiRuby::Widgets::Line>] single line for this entry
-    def format_session_picker_entry(tui, session, idx, current_id)
+    # @param session [Hash] serialized session from the brain
+    # @param idx [Integer] position in the current page
+    # @param current_id [Integer] ID of the currently active session
+    # @return [Array<RatatuiRuby::Widgets::Line>]
+    def format_root_session_entry(tui, session, idx, current_id)
       selected = idx == @session_picker_index
       is_current = session["id"] == current_id
+      children = session["children"] || []
 
       hotkey = picker_hotkey(idx)
       prefix = hotkey ? "[#{hotkey}]" : "   "
       marker = is_current ? "*" : " "
-      id_label = "##{session["id"]}"
+      arrow = children.any? ? CHILDREN_ARROW : " "
+
+      display_name = session["name"] || "##{session["id"]}"
       count = "#{session["message_count"]}msg"
       time = format_relative_time(session["updated_at"])
+      child_info = children.any? ? " (#{children.size})" : ""
 
-      label = "#{prefix}#{marker}#{id_label} #{count} #{time}"
+      label = "#{prefix}#{marker}#{arrow}#{display_name} #{count}#{child_info} #{time}"
 
       style = if selected
         tui.style(fg: "black", bg: "cyan")
@@ -499,6 +747,47 @@ module TUI
       [tui.line(spans: [tui.span(content: label, style: style)])]
     end
 
+    # Formats a child session entry with hotkey, status indicator, and agent name.
+    #
+    # @param tui [RatatuiRuby] TUI rendering API
+    # @param child [Hash] serialized child session from the brain
+    # @param idx [Integer] position in the current page
+    # @param current_id [Integer] ID of the currently active session
+    # @return [Array<RatatuiRuby::Widgets::Line>]
+    def format_child_session_entry(tui, child, idx, current_id)
+      selected = idx == @session_picker_index
+      is_current = child["id"] == current_id
+
+      hotkey = picker_hotkey(idx)
+      prefix = hotkey ? "[#{hotkey}]" : "   "
+      marker = is_current ? "*" : " "
+      status = child["processing"] ? CHILD_STATUS_RUNNING : CHILD_STATUS_DONE
+      status_color = child["processing"] ? "yellow" : "green"
+      display_name = child["name"] || UNNAMED_SUBAGENT_LABEL
+
+      label = "#{prefix}#{marker}#{status} #{display_name}"
+
+      style = if selected
+        tui.style(fg: "black", bg: "cyan")
+      elsif is_current
+        tui.style(fg: "cyan", modifiers: [:bold])
+      else
+        tui.style(fg: status_color)
+      end
+
+      [tui.line(spans: [tui.span(content: label, style: style)])]
+    end
+
+    # Formats the "Load more" entry shown when additional pages exist.
+    #
+    # @param tui [RatatuiRuby] TUI rendering API
+    # @return [Array<RatatuiRuby::Widgets::Line>]
+    def format_load_more_entry(tui)
+      remaining = session_picker_remaining_count
+      label = "[0]  Load more (#{remaining})"
+      [tui.line(spans: [tui.span(content: label, style: tui.style(fg: "dark_gray"))])]
+    end
+
     # -- View mode picker ----------------------------------------------
 
     # Opens the view mode picker overlay. Pre-selects the current mode.

data/lib/tui/message_store.rb

@@ -115,6 +115,26 @@ module TUI
       end
     end
 
+    # Removes entries by their event IDs. Used when the brain reports
+    # that events have left the LLM's viewport (context window eviction).
+    # Acquires the mutex once for the entire batch.
+    #
+    # @param event_ids [Array<Integer>] database IDs of events to remove
+    # @return [Integer] count of entries actually removed
+    def remove_by_ids(event_ids)
+      @mutex.synchronize do
+        removed = 0
+        event_ids.each do |event_id|
+          entry = @entries_by_id.delete(event_id)
+          next unless entry
+
+          @entries.delete(entry)
+          removed += 1
+        end
+        removed
+      end
+    end
+
     private
 
     # Replaces data on an existing entry matched by event ID.