samagotchi 0.2.0 → 0.4.0

data/lib/samagotchi/terminal_ui.rb

@@ -47,12 +47,7 @@ module Samagotchi
     include Formatting
     include InputSupport
 
-    AGENT_DESCRIPTION_FILE = "AGENT.md"
-    SKIP_AGENT_DESCRIPTION_ENV = "SAMAGOTCHI_SKIP_AGENT_MD"
-    STATS_COMMAND = "/stats"
-    # /exit --delete: delete the session on the way out.
-    EXIT_DELETE_FLAG = "--delete"
-    RECAP_COMMAND = "/recap"
+    SCRATCH_ARCHIVE_REFUSED = "a scratch session is deleted when you leave; nothing to archive"
     # The prompt while a question waits for its answer (its choices are in
     # the notes slot).
     QUESTION_PROMPT = "? "
@@ -103,9 +98,12 @@ module Samagotchi
       Engine.system_prompt_for(profile)
     end
 
+    # @param scratch [Boolean] `chi scratch`: a new session that is deleted
+    #   however the REPL ends, saves no memories and writes no recap
     def initialize(mode: :assist, prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
-                   spinner_tick_interval: THINKING_TICK_INTERVAL)
+                   spinner_tick_interval: THINKING_TICK_INTERVAL, scratch: false)
       @mode           = mode.to_sym
+      @scratch        = scratch
       # nil: no ticker thread (specs that compare exact frames).
       @spinner_tick_interval = spinner_tick_interval
       @spinner_lock = Monitor.new
@@ -139,6 +137,9 @@ module Samagotchi
         # Re-resolve client after resume may change effective model
         @client = @host_registry.resolve(@effective_model_name).client
       end
+      # The model it starts on names a configured host (a bad default.model
+      # doesn't matter when --model or the session picks another).
+      ModelProfile.check_host!(@effective_model_name, hosts: @host_registry.entries)
       # Only a caller's profile goes in; otherwise the Engine resolves one
       # for the effective model and hands it to the kernel.
       @kernel         = KernelLoop.new(client: @client, profile: profile, no_interrupt: no_interrupt, reminder_store: Samagotchi::ReminderStore.new)
@@ -172,11 +173,14 @@ module Samagotchi
         profile: profile,
         session_id: session_id,
         no_interrupt: no_interrupt,
-        model_name: @default_model_name,
+        # nil: the config default, unchecked here (the model the REPL starts
+        # on is checked above, and --model may make the default moot).
+        model_name: nil,
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
         kernel: @kernel,
-        recap: recap_config,
+        recap: scratch ? nil : recap_config,
+        scratch: scratch,
         reminders: {
           callback: lambda { |due_names|
             # When a reminder is due, queue a synthetic turn that
@@ -242,15 +246,20 @@ module Samagotchi
         model_name: @effective_model_name,
         working_directory: Dir.pwd,
         preloaded_memory_names: @requested_memories,
-        muted_memory_names: @muted_memory_names
+        muted_memory_names: @muted_memory_names,
+        scratch: @scratch
       )
       claim_session!(session.id) unless @owner_lock
+      # Saved at once, so a process killed before its first turn leaves a
+      # file the sweep knows to delete.
+      session.save if @scratch
       # Attach before building the prompt so it can name the session id.
       @engine.session = session
       messages = messages_for(session)
 
       if @prompt && @non_interactive
         # Headless / CI mode: run directly without TTY rendering.
+        ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
         result = @engine.run_turn(
           session,
           @prompt,
@@ -259,6 +268,13 @@ module Samagotchi
           cancel_controller: nil,
           images: ImageInput.extract(@prompt)
         )
+        if empty_answer?(result)
+          # Nothing to print: say so on stderr and fail, so a script that
+          # pipes the answer doesn't take the silence for one.
+          session.save
+          warn EMPTY_ANSWER_ERROR
+          exit 1
+        end
         @surface.commit(result.output)
         session.save
         return
@@ -266,10 +282,14 @@ module Samagotchi
 
       assist_loop(session: session, messages: messages)
       # After the idle layer has stopped: nothing writes the session now.
-      if @delete_on_exit
+      if @scratch
+        nil # deleted below, however the REPL ended
+      elsif @delete_on_exit
         delete_after_exit(session)
       elsif @discard_on_exit
         discard_after_exit(session)
+      elsif @archive_on_exit
+        archive_after_exit(session)
       else
         keep_after_exit(session)
       end
@@ -278,6 +298,32 @@ module Samagotchi
       # #initialize): the anytime commands finish, the plugins' services
       # stop (a server process).
       @engine&.shutdown
+      # A scratch session goes on every way out: /exit, Ctrl-D, an error,
+      # SIGTERM or SIGHUP (Ruby raises those here). Only kill -9 leaves it
+      # to the sweep.
+      delete_scratch(session, quiet: @non_interactive || !$!.nil?) if @scratch && session
+    end
+
+    EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
+
+    # A -p --non-interactive turn that ended with no answer (the empty-answer
+    # retries used up): no text, or the chat loop's placeholder.
+    def empty_answer?(result)
+      return false if result.respond_to?(:canceled?) && result.canceled?
+      return false if result.respond_to?(:resumable?) && result.resumable?
+
+      result.output.to_s.strip.empty? || (result.respond_to?(:empty_answer?) && result.empty_answer?)
+    end
+
+    # Delete the scratch session, the last thing the REPL does. Quiet after
+    # a one-shot or on the way out of an error or a signal.
+    def delete_scratch(session, quiet:)
+      @owner_lock&.release
+      @owner_lock = nil
+      SessionManager.delete_session(session.id)
+      @surface.commit("Scratch session deleted.") unless quiet
+    rescue StandardError => e
+      warn "Scratch session #{session.id} was not deleted (#{e.message}): chi sessions delete #{session.id}"
     end
 
     # The session stays: the recap first, then the resume line, last.
@@ -330,6 +376,17 @@ module Samagotchi
       @surface.commit("Session #{session.id} was not deleted (#{e.message}): chi sessions delete #{session.id}")
     end
 
+    # /archive: give up the session, then archive it (hidden from the lists,
+    # kept for good). An empty one is discarded instead (#discard_on_exit?).
+    def archive_after_exit(session)
+      @owner_lock&.release
+      @owner_lock = nil
+      SessionManager.archive_session(session.id)
+      @surface.commit("Archived session #{session.id}. chi sessions list --archived finds it.")
+    rescue SessionManager::ArchiveRefused, SessionManager::OwnedByTUI, ArgumentError, SystemCallError => e
+      @surface.commit("Session #{session.id} was not archived (#{e.message}): chi sessions archive #{session.id}")
+    end
+
     # Take the session's OwnerLock for this process's lifetime: the TUI runs
     # its own Engine, so no worker may run the session meanwhile.
     # @raise [SessionBusy] when a worker or another TUI owns it
@@ -356,6 +413,9 @@ module Samagotchi
         @surface.commit("Resumed session: #{session.id}")
         saved = @engine.saved_recap
         @surface.commit(recap_block(saved[:text], turns_since: saved[:turns_since])) if saved
+      elsif @scratch
+        messages = [system_message]
+        @surface.commit("Scratch session: nothing is kept, it is deleted when you leave.")
       else
         messages = [system_message]
         @surface.commit("Session: #{session.id}")
@@ -363,26 +423,8 @@ module Samagotchi
       messages
     end
 
-    # Public entrypoint for background session workers.
-    # Keeps worker call sites out of TerminalUI private API details.
-    def process_background_prompt(session:, prompt:)
-      @engine.process_background_prompt(session: session, prompt: prompt)
-    end
-
     private
 
-    # Generate profile-aware tool calling hint.
-    # Kept as a one-line delegator to Engine (single source of truth).
-    def tool_call_hint
-      return @engine.tool_call_hint
-    end
-
-    # Assist system prompt — delegates wholesale to Engine so the two can
-    # never drift apart. This single delegator fixes the 4-line regression.
-    def assist_system_prompt
-      return @engine.assist_system_prompt
-    end
-
     # Interactive REPL loop. Session seed + messages are built by #run and
     # threaded in here (so --prompt / --resume share one code path). The
     # working session is persisted at the end of every turn.
@@ -496,15 +538,22 @@ module Samagotchi
           end
         end
         break if input.nil?
-        if exit_command?(input)
-          @delete_on_exit ||= delete_on_exit?(input)
+        local = local_command(input)
+        if local == :exit
+          @delete_on_exit ||= SessionCommands.delete_on_exit?(input)
+          break
+        end
+        if local == :archive
+          next @surface.commit(SCRATCH_ARCHIVE_REFUSED) if @scratch
+
+          @archive_on_exit = true
           break
         end
         # Not an answer to a continue offer either.
-        next detach_note if detach_command?(input)
+        next detach_note if local == :detach
 
         # /stats and /recap run; the offer stays open.
-        if @turn_flow.awaiting_continue? && !stats_command?(input) && !recap_command?(input)
+        if @turn_flow.awaiting_continue? && !%i[stats recap].include?(local)
           answer_continue_offer(session, input)
         else
           # The ? read left no echo: show what ran.
@@ -557,15 +606,14 @@ module Samagotchi
         persist_recent_history(input) if command.shell
         return
       end
-      return @surface.commit("\nmodel> session stats:\n#{format_session_metrics(@engine.stats_snapshot)}") if stats_command?(input)
-      return @surface.commit("\nmodel> #{handle_recap_command}") if recap_command?(input)
+      return if show_local_command(input)
 
       @turn_flow.before_prompt_turn
       persist_recent_history(input)
       begin
         # Engine#run_turn injects due reminders as a tail message, appends
         # the prompt, and renders through @renderer via on_event.
-        result = run_engine_turn(session, normalize_model_input(input), images: ImageInput.extract(input))
+        result = run_engine_turn(session, input, images: ImageInput.extract(input))
       rescue LLM::ProviderError, ImageStore::Error => e
         # Engine closed the turn (:turn_failed); show its duration.
         # Retries were already tallied via generation_retrying events.
@@ -661,18 +709,6 @@ module Samagotchi
       prompt
     end
 
-    # Appends the current memory index to the base system prompt so the agent
-    # is always aware of stored memories without needing to call a tool first.
-    # Delegates wholesale to Engine (single source of truth).
-    def system_prompt_with_index(base)
-      result = @engine.system_prompt_with_index(base)
-      # Mirror any --memory activations the Engine performed so the sticky
-      # status line can surface them. The prompt body injection moved into
-      # Engine; echoing the activated names here is purely a UI concern.
-      sync_engine_activated_memories
-      result
-    end
-
     # Engine owns the system prompt (including --memory activation), but the
     # sticky status line is a UI concern. Mirror the activated names so they
     # appear in the status line.
@@ -682,12 +718,6 @@ module Samagotchi
       end
     end
 
-    # Render a result from a turn that bypassed Engine#run_turn (continue,
-    # reminder turns) exactly as a :turn_completed would be rendered.
-    def emit_result(result)
-      @renderer.render_turn_summary(@engine.turn_summary(result))
-    end
-
     # ── Turn view: the drawing surface EventRenderer calls ──────────────────
     public
 
@@ -758,8 +788,21 @@ module Samagotchi
         @thinking_waiting_since = nil
         clear_retry_spinner_status
         @turn_tally.started(key: tally_key(event), tool: event[:tool], params: event[:params])
-        memory_loaded = capture_memory_tool_call(event)
-        capture_thinking_tool_call(event) if memory_loaded
+        @last_tool_call_event = event
+        refresh_thinking_spinner_status
+      end
+    end
+
+    # The Engine's memory list: after a memory read (read_names, right after
+    # its tool_call_started) and at the end of a turn (preloads).
+    def used_memories_updated(event)
+      @spinner_lock.synchronize do
+        Array(event[:used_memory_names]).each { |name| add_unique_memory_name(:@session_memory_names, name) }
+        added = Array(event[:read_names]).select { |name| add_unique_memory_name(:@thinking_memory_names, name) }
+        next if added.empty?
+
+        @thinking_recent_memory_loaded = added.last
+        capture_thinking_tool_call(@last_tool_call_event) if @last_tool_call_event
         refresh_thinking_spinner_status
       end
     end
@@ -806,16 +849,6 @@ module Samagotchi
       @surface.commit("#{paint('chi>', 36)} turn #{state} (#{format_elapsed_duration(record[:duration_ms])})")
     end
 
-    def split_memory_scope(raw)
-      value = raw.to_s.strip
-      if value.include?("/")
-        scope, name = value.split("/", 2)
-        return [scope, name] if Tools::VALID_SCOPES.include?(scope)
-      end
-
-      [nil, value]
-    end
-
     def read_input(awaiting_continue:)
       emit_idle_status_line
 
@@ -841,6 +874,11 @@ module Samagotchi
       # empty synthetic turn then (it duplicated output).
       return unless @engine.reminders_due?
 
+      # A pending continue offer goes, as for a new prompt (the worker's rule).
+      if @turn_flow.before_reminder_turn
+        sync_continue_slot(false)
+        @surface.commit(QuestionSlot.continue_summary("(dropped: a reminder ran)", paint: method(:paint)))
+      end
       hint = "reminder: #{names.join(", ")} · Ctrl-C cancels it"
       @surface.set_slot(:hints, [color_output? ? paint(hint, 90) : hint])
       result = nil
@@ -954,27 +992,20 @@ module Samagotchi
       @repl_input.prefill(input) ? "prompt restored for retry" : "the failed prompt is in the input history (↑)"
     end
 
-    def shell_bang_command?(input)
-      input.to_s.match?(/\A!\s*\S/)
-    end
+    # The id of the terminal's own command +input+ is (:exit, :archive,
+    # :detach, :stats, :recap; SessionCommands registers them), or nil.
+    def local_command(input) = command_registry.lookup_local(input)&.id
 
-    def stats_command?(input)
-      input.to_s.strip == STATS_COMMAND
-    end
-
-    def recap_command?(input)
-      input.to_s.strip == RECAP_COMMAND
-    end
-
-    # SessionCommands runs /model; the REPL mirrors the result.
-    def handle_model_command(input)
-      result = @commands.run(input)
-      sync_model_mirrors
-      result.output
-    end
-
-    def handle_models_command
-      @commands.run(SessionCommands::MODELS_COMMAND).output
+    # /stats and /recap, which show and change nothing (at the prompt, a
+    # continue offer's ? prompt, or during a turn).
+    # @return [Boolean] whether +input+ was one
+    def show_local_command(input)
+      case local_command(input)
+      when :stats then @surface.commit("\nmodel> session stats:\n#{format_session_metrics(@engine.stats_snapshot)}")
+      when :recap then @surface.commit("\nmodel> #{handle_recap_command}")
+      else return false
+      end
+      true
     end
 
     # /recap: the saved recap, and a new one asked for at once when the
@@ -991,29 +1022,10 @@ module Samagotchi
     # A resumed session doesn't get the default input either.
     def default_input_wanted? = !@resume_session && !@no_default_input
 
-    # exit or /exit, with --delete to delete the session on the way out.
-    def exit_command?(input)
-      words = input.to_s.strip.downcase.split
-      %w[exit /exit].include?(words.first) && (words.size == 1 || words == [words.first, EXIT_DELETE_FLAG])
-    end
-
-    def delete_on_exit?(input) = input.to_s.strip.downcase.split.last == EXIT_DELETE_FLAG
-
-    def detach_command?(input) = input.to_s.strip.casecmp?("/detach")
-
     def clone_messages(messages)
       Array(messages).map(&:dup)
     end
 
-    def skip_agent_description?
-      value = ENV[SKIP_AGENT_DESCRIPTION_ENV]
-      value == "1" || value&.casecmp?("true")
-    end
-
-    def rg_available?
-      system("command -v rg", out: File::NULL, err: File::NULL)
-    end
-
     # Run one REPL turn (a prompt, or a continue/reminder turn with nil) through
     # Engine#run_turn, rendering via @renderer.
     # @param images [Array<Hash>] the prompt's `@path` images ({path:})
@@ -1024,6 +1036,8 @@ module Samagotchi
       # Build the (memoized) prompt now so --memory activations show in this
       # turn's status lines, including after /model rebuilt it.
       seed_system_prompt
+      # A prompt the user typed brings an archived session back to the lists.
+      ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir) if prompt && !continue
       result = with_steering do
         @engine.run_turn(
           session,
@@ -1066,11 +1080,13 @@ module Samagotchi
     # in the prompt.
     # @return [Boolean, :back] whether the turn took it, :back to put it back
     def steer_line(line)
-      return exit_after_turn(delete: delete_on_exit?(line)) if line.nil? || exit_command?(line)
-      return detach_note if detach_command?(line)
+      local = local_command(line) unless line.nil?
+      return exit_after_turn(delete: SessionCommands.delete_on_exit?(line)) if line.nil? || local == :exit
+      return detach_note if local == :detach
       return false if @active_cancel_controller&.cancelled?
       return start_anytime_command(line) if command_registry.lookup(line)&.anytime
-      return command_during_turn(line) if command_line?(line)
+      # A command, never steering text (/archive waits, back in the prompt).
+      return command_during_turn(line) if local || command_registry.command?(line)
       return true if line.strip.empty?
       # Steering merges text only: a line with images runs as the next turn.
       return image_line_waits if ImageInput.extract(line).any?
@@ -1104,15 +1120,10 @@ module Samagotchi
 
     # @return [true, :back]
     def command_during_turn(line)
-      if stats_command?(line)
-        @surface.commit("\nmodel> session stats:\n#{format_session_metrics(@engine.stats_snapshot)}")
-      elsif recap_command?(line)
-        @surface.commit("\nmodel> #{handle_recap_command}")
-      else
-        @surface.commit(COMMAND_BUSY)
-        return :back
-      end
-      true
+      return true if show_local_command(line)
+
+      @surface.commit(COMMAND_BUSY)
+      :back
     end
 
     # D8: an anytime command runs on its own thread while the turn goes on
@@ -1132,16 +1143,12 @@ module Samagotchi
       true
     end
 
-    def command_line?(line)
-      command_registry.command?(line) || stats_command?(line) || recap_command?(line) || exit_command?(line)
-    end
-
-    # The kernel's drain at an iteration boundary: queued lines, #memory
-    # shorthand made words as for a prompt, and saved in the history.
+    # The kernel's drain at an iteration boundary: queued lines, sent as
+    # typed and saved in the history.
     def drain_steering
       @pending_input_queue.drain.map do |line|
         persist_recent_history(line)
-        normalize_model_input(line)
+        line
       end
     end
 
@@ -1299,17 +1306,6 @@ module Samagotchi
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def capture_memory_tool_call(event)
-      call = event[:call].is_a?(Hash) ? event[:call] : {}
-      memory_name = memory_name_from_tool_call(call)
-      return false if memory_name.nil? || memory_name.empty?
-
-      added_to_thinking = add_unique_memory_name(:@thinking_memory_names, memory_name)
-      add_unique_memory_name(:@session_memory_names, memory_name)
-      @thinking_recent_memory_loaded = memory_name if added_to_thinking
-      added_to_thinking
-    end
-
     def capture_thinking_tool_call(event)
       call = event[:call].is_a?(Hash) ? event[:call] : {}
       name = call[:name].to_s.strip
@@ -1367,67 +1363,6 @@ module Samagotchi
       true
     end
 
-    def memory_name_from_tool_call(call)
-      tool_name = call[:name].to_s
-      case tool_name
-      when Tools::MemoryRead::NAME
-        normalize_memory_name(call[:content])
-      when Tools::Read::NAME
-        memory_name_from_read_path(call[:content])
-      else
-        nil
-      end
-    end
-
-    def normalize_memory_name(raw)
-      value = raw.to_s.strip
-      return nil if value.empty?
-
-      File.basename(value, ".md")
-    end
-
-    def memory_name_from_read_path(raw_path)
-      path = raw_path.to_s.strip.tr("\\", "/")
-      return nil if path.empty?
-      return nil unless path.match?(/memories[\/].+\.md\z/)
-
-      normalize_memory_name(path)
-    end
-
-    def memory_spinner_segment
-      segment = memory_spinner_segment_plain
-      return "" if segment.empty?
-
-      color_output? ? paint(segment, MEMORY_SPINNER_COLOR) : segment
-    end
-
-    def memory_spinner_segment_plain
-      names = Array(@thinking_memory_names)
-      return "" if names.empty?
-
-      visible = names.first(MEMORY_SPINNER_PREVIEW_LIMIT)
-      suffix = names.length > visible.length ? ", +#{names.length - visible.length}" : ""
-      " mem: #{visible.join(', ')}#{suffix}"
-    end
-
-    def memory_sticky_line
-      names = Array(@session_memory_names)
-      muted = @engine.muted_memory_names
-      return "" if names.empty? && muted.empty?
-
-      parts = []
-      parts << "active this session: #{preview_names(names)}" unless names.empty?
-      parts << "muted: #{preview_names(muted)}" unless muted.empty?
-      body = "memories> #{parts.join(' · ')}"
-      color_output? ? paint(body, MEMORY_SPINNER_COLOR) : body
-    end
-
-    def preview_names(names, limit: MEMORY_STICKY_PREVIEW_LIMIT)
-      visible = names.first(limit)
-      suffix = names.length > visible.length ? ", +#{names.length - visible.length}" : ""
-      "#{visible.join(', ')}#{suffix}"
-    end
-
     def reset_thinking_memory_names
       @thinking_memory_names = []
     end
@@ -1549,54 +1484,24 @@ module Samagotchi
       ConfigFile.recap_config
     end
 
-    def bare_model_for(full_ref)
-      @host_registry.bare_name(full_ref)
-    end
-
-    def spinner_status_line
-      return "" unless status_line_enabled?
-
-      lines = spinner_status_lines
-      lines.empty? ? "" : lines.first
-    end
-
     def spinner_status_lines(width: status_effective_width)
       return [] unless status_line_enabled?
 
       build_status_lines(scope: :spinner, width: width)
     end
 
-    def sticky_status_line
-      return "" unless status_line_enabled?
-
-      lines = sticky_status_lines
-      lines.empty? ? "" : lines.first
-    end
-
     def sticky_status_lines(width: status_effective_width)
       return [] unless status_line_enabled?
 
       build_status_lines(scope: :sticky, width: width)
     end
 
-    def idle_status_line
-      return "" unless status_line_enabled?
-
-      lines = idle_status_lines
-      lines.empty? ? "" : lines.first
-    end
-
     def idle_status_lines(width: status_effective_width)
       return [] unless status_line_enabled?
 
       build_status_lines(scope: :idle, width: width)
     end
 
-    def build_status_line(scope:)
-      lines = build_status_lines(scope: scope)
-      lines.empty? ? "" : lines.first
-    end
-
     # The status rows for +scope+ (:spinner, :sticky or :idle), cut to +width+.
     def build_status_lines(scope:, width: status_effective_width)
       status_rows(status_segments(scope), width)
@@ -1772,11 +1677,6 @@ module Samagotchi
       "model> waiting for the first token... #{waited.floor}s #{frame}"
     end
 
-    def thinking_spinner_status_line(frame)
-      lines = thinking_spinner_status_lines(frame)
-      lines.empty? ? "" : lines.first
-    end
-
     # The spinner row, then (from a turn's 3rd tool call) its tool tally.
     # The spinner stops while tools run, so the tally shows while the model
     # generates between tool rounds.
@@ -1844,10 +1744,6 @@ module Samagotchi
       nil
     end
 
-    def pending_question_event?
-      !!@pending_question_event
-    end
-
     # Called from REPL thread (run_assist_loop top) — renders widget, blocks
     # until user selects, then answers via Engine#answer_question which wakes
     # the parked turn thread.
@@ -1889,6 +1785,9 @@ module Samagotchi
 
       # Ensure spinner cleared and terminal in known state (same as reminder mute handling)
       finish_thinking_spinner rescue nil
+      # An edit's diff goes above the slot, into the scrollback.
+      preview = prompt.preview_lines(paint: method(:paint))
+      @surface.commit(preview.join("\n")) unless preview.empty?
       choices = prompt.slot(paint: method(:paint))
 
       question_prompt = paint(QUESTION_PROMPT, 33)
@@ -1976,17 +1875,5 @@ module Samagotchi
         return :canceled if controller&.cancelled?
       end
     end
-
-    # Process a prompt through the kernel loop and return the model response.
-    # Delegates to the internal Engine instance.
-    def process_prompt_through_kernel(session, prompt)
-      @engine.process_prompt_through_kernel(session, prompt)
-    end
-
-    # Write an agent response to the session output directory.
-    def write_session_output(output_dir, response)
-      timestamp = Time.now.strftime("%Y%m%d%H%M%S%9N")
-      File.write(File.join(output_dir, "#{timestamp}.txt"), response.to_s)
-    end
   end
 end