pikuri-core 0.0.5 → 0.0.7

data/lib/pikuri/agent/extension.rb

@@ -10,6 +10,14 @@ module Pikuri
     # is fully constructed, and {#on_user_message} on every user turn
     # thereafter.
     #
+    # Each phase receives that phase's context object: +configure+
+    # gets the build-time {Configurator}; +bind+ and
+    # +on_user_message+ get the runtime {ExtensionContext} — the
+    # capability facade for everything that acts on the live agent
+    # (domain-event emission, raw tool registration, sub-agent
+    # listener derivation), with the agent itself readable via
+    # {ExtensionContext#agent}.
+    #
     # Mix this module into an extension class to inherit empty
     # default implementations of all three hooks; override the ones
     # you need. Extensions that don't +include+ this module still
@@ -59,25 +67,30 @@ module Pikuri
       def configure(c); end
 
       # Called by {Agent#initialize} after the block returns and the
-      # chat is fully wired, with the live {Agent} as the argument.
-      # Fires once per agent the extension was registered to via
-      # {Configurator#add_extension} — in the typical setup that's
-      # the parent agent only, since sub-agents do not inherit
-      # extensions. The default is a no-op; override when you need
-      # to install state keyed to the live agent object. Things
-      # you typically do here:
+      # chat is fully wired, with the agent's {ExtensionContext} as
+      # the argument. Fires once per agent the extension was
+      # registered to via {Configurator#add_extension} — in the
+      # typical setup that's the parent agent only, since sub-agents
+      # do not inherit extensions. The default is a no-op; override
+      # when you need to install state keyed to the live agent.
+      # Things you typically do here:
       #
-      # * register dynamic tools via {Agent#internal_add_tool}
+      # * register dynamic tools via {ExtensionContext#add_raw_tool}
       #   (used by {Pikuri::Mcp::Extension} for +mcp_connect+,
-      #   whose +execute+ closure needs the live agent so
-      #   activations register on the right chat)
-      # * register +on_close+ handlers via {Agent#on_close}
-      # * stash an +@agent+ reference if the extension's tools need
-      #   to act on this specific agent later
+      #   whose +execute+ closure needs the context so activations
+      #   register on the right chat)
+      # * wire domain-event emission via
+      #   {ExtensionContext#emit_event} (e.g. +Pikuri::Tasks::Extension+
+      #   arms its list's +on_change+ here)
+      # * register per-agent +on_close+ handlers via
+      #   {ExtensionContext#on_close}
+      # * stash the +ctx+ if the extension's tools need to act on
+      #   this specific agent later
       #
-      # @param agent [Agent] the live agent, fully wired
+      # @param ctx [ExtensionContext] capability facade for the
+      #   live, fully wired agent
       # @return [void]
-      def bind(agent); end
+      def bind(ctx); end
 
       # Optional per-turn hook fired by the {Agent} after a user-message
       # is added to the chat. The
@@ -97,12 +110,13 @@ module Pikuri
       # only — sub-agents do not inherit extensions, so a persona's turns are
       # never prefetched or recorded by the parent's memory.
       #
-      # @param agent [Agent] the live agent whose turn this is
+      # @param ctx [ExtensionContext] capability facade for the live
+      #   agent whose turn this is — same instance +bind+ received
       # @param content [String] the user message (initial or interloper) about
       #   to be sent to the model
       # @return [String, nil] an optional block of text to be injected verbatim as
       #   a system-role message (after the user message), or +nil+ to inject nothing
-      def on_user_message(agent, content); end
+      def on_user_message(ctx, content); end
     end
   end
 end

data/lib/pikuri/agent/extension_context.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Pikuri
+  class Agent
+    # Capability facade handed to {Extension#bind} and
+    # {Extension#on_user_message} — the runtime counterpart of
+    # {Configurator}. Where the Configurator collects *build-time*
+    # declarations (tools, listeners, prompt snippets), this object
+    # grants the *runtime* capabilities an extension needs once the
+    # agent is fully wired: emitting domain events onto the listener
+    # stream, registering raw per-agent tools, and deriving sub-agent
+    # listener lists.
+    #
+    # == Why a handed object, not a getter on Agent
+    #
+    # The {Agent} deliberately exposes NO public path to these
+    # capabilities — no +listeners+ reader, no +chat+ reader, no
+    # emit method. Holding an agent reference grants read access to
+    # its configuration ({Agent#tools}, {Agent#transport}, ...) and
+    # nothing more; the write capabilities live here, and the only
+    # way to obtain this object is to be an {Extension} receiving a
+    # +bind+ / +on_user_message+ call (or to be handed it onward by
+    # one, e.g. {Pikuri::SubAgent::SubAgentTool} and
+    # {Pikuri::Mcp::Servers::Connect} both capture the context their
+    # extension's +bind+ received). Capabilities flow by explicit
+    # handoff, never by fetching from a globally reachable object.
+    #
+    # The usual Ruby caveat applies: nothing here is mechanically
+    # sealed (+instance_variable_get+ exists). The boundary is the
+    # API contract — same as every seam in CLAUDE.md.
+    #
+    # == Boundary rule
+    #
+    # Operations that *act on* the live agent's wiring live here.
+    # Passive readers of constructor-given config (+transport+,
+    # +id+, +streaming+, +tools+, +cancellable+, ...) stay on
+    # {Agent}, reachable via {#agent}. Don't move readers in; don't
+    # add capabilities to Agent.
+    #
+    # == Audit
+    #
+    # One context per agent, constructed by {Agent#initialize} right
+    # before the extension +bind+ sweep. {ListenerList#emit} has
+    # exactly two callers: {Agent} (loop narration) and this class
+    # (extension domain events). The roster of capability users is
+    # +grep -rn 'emit_event\|add_raw_tool\|sub_agent_listeners'
+    # pikuri-*/lib/+.
+    class ExtensionContext
+      # @param agent [Agent] the live, fully wired agent.
+      # @param chat [RubyLLM::Chat] the agent's underlying chat —
+      #   target of {#add_raw_tool}.
+      # @param listeners [ListenerList] the agent's listener list —
+      #   target of {#emit_event} / {#sub_agent_listeners}.
+      # @param on_close_sink [Array<Proc>] the agent's live
+      #   +@on_close_handlers+ array, which {#on_close} appends to —
+      #   same live-sink shape as {Configurator}'s +on_close_sink:+.
+      def initialize(agent:, chat:, listeners:, on_close_sink:)
+        @agent = agent
+        @chat = chat
+        @listeners = listeners
+        @on_close_handlers = on_close_sink
+      end
+
+      # @return [Agent] the live agent, for read access to its
+      #   configuration (tools, transport, id, streaming, ...).
+      attr_reader :agent
+
+      # Emit a domain event onto the agent's listener stream.
+      #
+      # Core {Event} variants narrate the chat loop and are emitted
+      # by {Agent} alone; gems define their own variants (e.g.
+      # +Pikuri::Tasks::ListChanged+) in their own namespace and
+      # emit them here. Listeners must no-op on variants they don't
+      # recognize — {Listener::Base#on_event}'s default and
+      # +case+-fallthrough give that for free.
+      #
+      # Called on the agent's thread (typically from inside a tool's
+      # +execute+, where the event lands between {Event::ToolCall}
+      # and {Event::ToolResult} in the stream). Listeners doing
+      # cross-thread handoff snapshot/serialize inside +on_event+.
+      #
+      # @param event [Object] an immutable event value (by
+      #   convention a +Data+ instance).
+      # @return [void]
+      def emit_event(event)
+        @listeners.emit(event)
+        nil
+      end
+
+      # Register a raw +RubyLLM::Tool+ subclass on the agent's
+      # underlying chat, bypassing the {Pikuri::Tool}
+      # strict-validation seam — hence "raw": native pikuri tools
+      # should go through {Pikuri::Tool} (registered at build time
+      # via {Configurator#add_tool}) so they get {Tool::Parameters}
+      # validation and the LLM-actionable +"Error: ..."+ contract.
+      # Intended callers: {Pikuri::Mcp::Servers} (MCP tools
+      # deliberately bypass — see IDEAS.md §"MCP tools bypass
+      # +Pikuri::Tool+ entirely") and
+      # {Pikuri::SubAgent::Extension} (the +agent+ tool must
+      # register after the parent's tool list is final).
+      #
+      # The added tool does NOT enter {Agent#tools}, only the chat's
+      # tool list. Sub-agents therefore cannot snapshot it — which
+      # is the whole point: activation is strictly per-agent, see
+      # IDEAS.md §"Per-agent activation, no propagation".
+      #
+      # @param ruby_llm_tool [Class] subclass of +RubyLLM::Tool+
+      # @return [void]
+      def add_raw_tool(ruby_llm_tool)
+        @chat.with_tool(ruby_llm_tool)
+        nil
+      end
+
+      # Derive a listener list for a spawned sub-agent via
+      # {ListenerList#for_sub_agent}. Sole intended caller:
+      # {Pikuri::SubAgent::SubAgentTool}, once per spawn.
+      #
+      # The derived list deliberately aliases the parent's listener
+      # *instances* where a listener opts to share by reference
+      # (stateful sinks like {Listener::InMemoryEventList}) — see
+      # {ListenerList#for_sub_agent} for the per-listener semantics.
+      #
+      # @param params [Hash{Symbol => Object}] forwarded to each
+      #   listener's +for_sub_agent+ hook (currently +id:+).
+      # @return [ListenerList]
+      def sub_agent_listeners(**params)
+        @listeners.for_sub_agent(**params)
+      end
+
+      # Register a handler called by {Agent#close}. Symmetric to
+      # {Configurator#on_close} — same LIFO + per-handler-rescue +
+      # idempotent semantics — but available post-construction, so
+      # an {Extension}'s +bind+ can install per-agent cleanup keyed
+      # to this specific agent (e.g. +Pikuri::Memory::Extension+
+      # arms its recorder's bounded flush here).
+      #
+      # @yield called with no arguments at close time
+      # @return [void]
+      def on_close(&blk)
+        raise ArgumentError, 'on_close requires a block' unless block_given?
+
+        @on_close_handlers << blk
+        nil
+      end
+    end
+  end
+end

data/lib/pikuri/agent/listener/terminal.rb

@@ -1,21 +1,33 @@
 # frozen_string_literal: true
 
 require 'rainbow'
-require 'tty-markdown'
 
 module Pikuri
   class Agent
     module Listener
       # Terminal renderer for the normalized event stream: dim grey
-      # reasoning, Markdown-rendered assistant content, cyan tool-
-      # call and tool-result lines, yellow fallback notice, red
-      # cancelled notice. An {Event::SystemInjected} block (recalled
+      # reasoning, assistant content printed raw (Markdown as-is),
+      # cyan tool-call and tool-result lines, yellow fallback
+      # notice, red cancelled notice, magenta model-switch notice.
+      # An {Event::SystemInjected} block (recalled
       # memory / context an extension injected) renders dim grey
       # with a +⊕+ marker. {Event::UserTurn} is intentionally silent
       # (the terminal user just typed the message, so re-rendering
       # it adds nothing); {Event::Tokens} and {Event::ContextCap}
       # are silent too (their consumer is {TokenLog}).
       #
+      # Assistant Markdown deliberately prints raw, with no
+      # Markdown-to-ANSI rendering. A renderer (+tty-markdown+)
+      # used to sit on the non-streaming path; it was dropped:
+      # rendering can never apply to the streaming path anyway
+      # (half-finished Markdown — broken code fences, half-built
+      # tables — doesn't render), the gem hadn't shipped a release
+      # since 2023 (its known ANSI-in-table crashes forced a
+      # rescue-and-degrade carve-out here), and it pulled seven
+      # transitive gems into the audit surface. Raw Markdown is
+      # perfectly readable in a terminal; proper rendering belongs
+      # to a richer host (the planned pikuri-tui).
+      #
       # Optionally prepends a fixed number of leading spaces to
       # every rendered line via the +padding:+ kwarg. Sub-agents
       # get a fresh padded instance through {#for_sub_agent}
@@ -30,11 +42,8 @@ module Pikuri
       # - {Event::ThinkingDelta} fragments print live in the same
       #   dim grey as the non-streaming {Event::Thinking}, with no
       #   trailing newline so the next fragment continues the line.
-      # - {Event::AssistantDelta} fragments print live, *raw* — no
-      #   Markdown render. tty-markdown can't render half-finished
-      #   Markdown (broken code blocks, half-rendered tables), so
-      #   the live stream gives up formatting in exchange for
-      #   liveness.
+      # - {Event::AssistantDelta} fragments print live the same
+      #   way, uncolored.
       # - {Event::Thinking} and {Event::Assistant} bookends print
       #   a single blank line as a stream terminator, not their
       #   content (the content already landed via the deltas). The
@@ -45,15 +54,6 @@ module Pikuri
       # the deltas are silently ignored and the bookend events
       # render the full text the way they always have.
       class Terminal < Base
-        # Subsystem logger; set its level with +PIKURI_LOG_TERMINAL+
-        # or the global +PIKURI_LOG+. Used for the narrow rescue
-        # around third-party rendering (+tty-markdown+ choking on
-        # assistant output) — see the CLAUDE.md "secondary to the
-        # loop" carve-out.
-        #
-        # @return [Logger]
-        LOGGER = Pikuri.logger_for('Terminal')
-
         # Cap, in characters, applied to tool-result content
         # rendered to the terminal. Anything longer is truncated
         # with a marker that reports the original byte size so the
@@ -119,7 +119,7 @@ module Pikuri
             if @streaming
               terminate_stream
             else
-              println(indent(render_markdown(content)))
+              println(indent(content))
             end
           in Event::ThinkingDelta(content:)
             stream_fragment(Rainbow(content).color(85, 85, 85)) if @streaming
@@ -132,6 +132,8 @@ module Pikuri
             println(indent(Rainbow("→ #{name}(#{args})").cyan))
           in Event::ToolResult(content:)
             println(indent(Rainbow("= #{truncate_tool_result(content)}").cyan))
+          in Event::ModelSwitched(from:, to:)
+            println(indent(Rainbow("⇄ model: #{from.model} → #{to.model}").magenta))
           in Event::FallbackNotice(reason:)
             println(indent(Rainbow("! #{reason}").yellow))
           in Event::Cancelled
@@ -228,23 +230,6 @@ module Pikuri
           text.to_s.each_line.map { |line| prefix + line }.join
         end
 
-        # Render assistant Markdown for the terminal, degrading to
-        # the raw string when the renderer raises. tty-markdown /
-        # strings have known bugs around ANSI inside tables (e.g.
-        # +Strings::Wrap.insert_ansi+ raising +IndexError+); we'd
-        # rather show ugly Markdown than abort an in-flight
-        # conversation.
-        #
-        # @param content [String] assistant Markdown
-        # @return [String] rendered ANSI text, or +content+
-        #   unchanged on render failure
-        def render_markdown(content)
-          TTY::Markdown.parse(content)
-        rescue StandardError => e
-          LOGGER.warn("TTY::Markdown render failed (#{e.class}: #{e.message}); falling back to raw text")
-          content
-        end
-
         # Flatten whitespace and cap to {MAX_TOOL_RESULT_CHARS}. The
         # cap keeps multi-screen dumps (rendered HTML, PDF text)
         # from drowning the terminal stream; the byte-count suffix
@@ -252,12 +237,20 @@ module Pikuri
         # exactly this" from "tool returned much more, you're
         # seeing a slice."
         #
+        # Whitespace is flattened *first* (collapsing real tabs, CRs and
+        # newlines into single spaces — fine here, since this passive
+        # echo is a status line, not an approval artifact), then the
+        # result runs through {Pikuri::Sanitizer} so a tool observation
+        # can't smuggle an ESC or other control byte into this cyan line.
+        # The sanitizer's warnings are dropped — they belong at a
+        # confirmation prompt, not the stream narration.
+        #
         # @param content [String] tool observation
         # @return [String] single-line display form, possibly
         #   truncated
         def truncate_tool_result(content)
           original_bytes = content.to_s.bytesize
-          flattened = content.to_s.gsub(/\s+/, ' ').strip
+          flattened = Sanitizer.sanitize(content.to_s.gsub(/\s+/, ' ').strip).text
           return flattened if flattened.length <= MAX_TOOL_RESULT_CHARS
 
           "#{flattened[0, MAX_TOOL_RESULT_CHARS]}… (#{original_bytes} bytes total)"

data/lib/pikuri/agent/listener/token_log.rb

@@ -6,8 +6,12 @@ module Pikuri
       # Logs the conversation's context-window consumption per
       # assistant turn via +Pikuri.logger_for('Tokens')+. Consumes
       # {Event::Tokens} (one log line per emission) and
-      # {Event::ContextCap} (one-shot cap, picked off and cached);
-      # every other event variant is a no-op.
+      # {Event::ContextCap} (the cap, picked off and cached —
+      # refreshed if a later {Event::ContextCap} arrives after a
+      # model switch); every other event variant is a no-op. A
+      # switch does not reset the running size or message count: the
+      # next {Event::Tokens} self-corrects the headline to the new
+      # model's count.
       #
       # Existence rationale: catch context-window growth before the
       # provider raises +RubyLLM::ContextLengthExceededError+.
@@ -96,12 +100,19 @@ module Pikuri
         #   listener you get a fresh instance via {#for_sub_agent}.
         attr_reader :id
 
-        # The most recent log line, in the exact format written to
-        # {LOGGER} (including any +[<id>] + prefix). Empty until
-        # the first {Event::Tokens} has been processed. Hosts that
+        # The most recent status line, *without* the +[<id>] +
+        # prefix — the prefix is {LOGGER}'s concern (the log
+        # stream interleaves agents, so its lines must carry the
+        # id inline); consumers of this reader get the id
+        # separately ({#id} here, the first callable parameter on
+        # {#on_status_line}) and decide the presentation
+        # themselves. Empty until the first {Event::Tokens} has
+        # been processed. Hosts that
         # want to surface the current context-window snapshot in
         # their own UI (e.g. a TUI status footer) read this
-        # instead of re-implementing the formatting.
+        # instead of re-implementing the formatting. Hosts that
+        # want to be *pushed* each new line instead of polling
+        # set {#on_status_line}.
         #
         # Thread safety: a single instance-variable read of a
         # +String+ — safe to read from any thread; readers may
@@ -112,6 +123,34 @@ module Pikuri
         # @return [String]
         attr_reader :status_line
 
+        # Optional status-line observer, +nil+ by default. When
+        # set to a callable, it is invoked with the owning
+        # agent's {#id} and the freshly formatted {#status_line}
+        # after every {Event::Tokens} — the push counterpart to
+        # polling {#status_line}, for hosts that stream the line
+        # onward (a Sinatra SSE endpoint pushing it to the
+        # browser, a websocket, a TUI redraw trigger). Fires on
+        # whatever thread runs the owning agent's loop, so the
+        # callable must hand off to its sink thread-safely; and
+        # like any listener it sits on the loop's path — an
+        # exception it raises propagates into the conversation,
+        # so handle dead connections inside the callable.
+        #
+        # Instances derived via {#for_sub_agent} copy the
+        # observer set at derivation time, so one callable
+        # receives parent and sub-agent lines alike; the +id+
+        # parameter (+""+ for the main agent, the generated id
+        # for a sub-agent) is what lets the UI route each line to
+        # the right status row — the line itself is unprefixed
+        # (see {#status_line}). An observer assigned *after*
+        # a sub-agent spawned doesn't reach that sub-agent's
+        # instance.
+        #
+        # @return [Proc, nil] called with +(id, status_line)+ —
+        #   the owning agent's id +String+ and the unprefixed
+        #   {#status_line} +String+
+        attr_accessor :on_status_line
+
         # @param id [String] owning agent's id, prepended to each
         #   log line as +[<id>] + when non-empty. Defaults to +""+
         #   for the main agent.
@@ -122,6 +161,7 @@ module Pikuri
           @context_window_size = 0
           @context_window_cap = nil
           @status_line = ''
+          @on_status_line = nil
         end
 
         # Sub-agent variant: a fresh +TokenLog+ with a zeroed
@@ -132,12 +172,17 @@ module Pikuri
         # prefix; defaults to +""+ when absent. The cap is left
         # +nil+ here; the sub-agent's {Agent#initialize} emits a
         # fresh {Event::ContextCap} immediately after construction
-        # and this listener picks it up off the stream.
+        # and this listener picks it up off the stream. The
+        # {#on_status_line} observer carries over by reference, so
+        # a host streaming the parent's lines sees the sub-agent's
+        # too — distinguished by the +id+ the callable receives.
         #
         # @param id [String] sub-agent's id
         # @return [TokenLog]
         def for_sub_agent(id: '', **)
-          self.class.new(id: id)
+          derived = self.class.new(id: id)
+          derived.on_status_line = @on_status_line
+          derived
         end
 
         # @param event [Agent::Event]
@@ -162,8 +207,9 @@ module Pikuri
 
         private
 
-        # Update the snapshot and write one +INFO+ line to the
-        # subsystem logger.
+        # Update the snapshot, write one +INFO+ line to the
+        # subsystem logger, and push the line to the status-line
+        # observer (when one was given at construction).
         #
         # @param tokens [Event::Tokens]
         # @return [void]
@@ -178,13 +224,14 @@ module Pikuri
           delta = @context_window_size - prev_ctx
 
           @status_line = format_line(input_now, tokens.output.to_i, delta)
-          LOGGER.info(@status_line)
+          prefix = @id.empty? ? '' : "[#{@id}] "
+          LOGGER.info("#{prefix}#{@status_line}")
+          @on_status_line&.call(@id, @status_line)
         end
 
         def format_line(input, output, delta)
           sign = delta.negative? ? '-' : '+'
-          prefix = @id.empty? ? '' : "[#{@id}] "
-          "#{prefix}msg ##{@msg}: ctx=#{format_ctx}  Δ#{sign}#{format_k(delta.abs)}  ↑#{format_k(input)}  ↓#{format_k(output)}"
+          "msg ##{@msg}: ctx=#{format_ctx}  Δ#{sign}#{format_k(delta.abs)}  ↑#{format_k(input)}  ↓#{format_k(output)}"
         end
 
         # +<used>+ when no cap is set, +<used>/<cap>+ when one is.

data/lib/pikuri/agent/listener.rb

@@ -11,10 +11,12 @@ module Pikuri
     # == What lives here, what doesn't
     #
     # The directory holds *pure consumers*: code whose only side
-    # effect is to react to events the +Agent+ has already emitted.
-    # No listener writes back into the stream — the +Agent+ is the
-    # only emitter — and no listener reaches into ruby_llm's chat
-    # callbacks. Both responsibilities live in {Agent}.
+    # effect is to react to events already emitted. No listener
+    # writes back into the stream — emission belongs to the +Agent+
+    # (loop narration) and to extensions via
+    # {Agent::ExtensionContext#emit_event} (domain events) — and no
+    # listener reaches into ruby_llm's chat callbacks (that wiring
+    # lives in {Agent}).
     #
     # Host-facing signal holders — step budget, cancellation flag,
     # mid-loop user input queue — are *controls*, not listeners.
@@ -45,7 +47,12 @@ module Pikuri
         #   Event::ThinkingDelta, Event::Assistant,
         #   Event::AssistantDelta, Event::ToolCall,
         #   Event::ToolResult, Event::Tokens, Event::ContextCap,
-        #   Event::FallbackNotice, Event::Cancelled]
+        #   Event::FallbackNotice, Event::Cancelled, Object] one of
+        #   the core loop-narration variants, or a gem-defined
+        #   domain event emitted via
+        #   {Agent::ExtensionContext#emit_event} (e.g.
+        #   +Pikuri::Tasks::ListChanged+) — match the variants you
+        #   know, let everything else fall through
         # @return [void]
         def on_event(event); end
       end

data/lib/pikuri/agent/listener_list.rb

@@ -24,10 +24,14 @@ module Pikuri
       end
 
       # Dispatch one event to every listener, in registration order.
-      # Called exclusively by {Agent} — listeners themselves never
-      # call this; the stream is one-way.
+      # Exactly two callers: {Agent} (loop-narration {Event}
+      # variants) and {ExtensionContext#emit_event} (extension
+      # domain events). Listeners themselves never call this; the
+      # stream is one-way.
       #
-      # @param event [Agent::Event]
+      # @param event [Object] an {Agent::Event} variant or a
+      #   gem-defined domain event (an immutable value, by
+      #   convention a +Data+ instance)
       # @return [void]
       def emit(event)
         @listeners.each { |l| l.on_event(event) }
@@ -78,20 +82,6 @@ module Pikuri
         self.class.new(swapped)
       end
 
-      # Return a new {ListenerList} containing this list's listeners
-      # plus the given extras, in order. Used by {Synthesizer} and
-      # other internal consumers to derive a list from an existing
-      # one. Returns +self+ when +extras+ is empty so the common
-      # no-op case allocates nothing.
-      #
-      # @param extras [Array<Listener::Base>] listeners to append
-      # @return [ListenerList]
-      def with(*extras)
-        return self if extras.empty?
-
-        self.class.new(@listeners + extras)
-      end
-
       # @example
       #   list.to_s # => "[Terminal, TokenLog(ctx=0.0k)]"
       #