samagotchi 0.152.0 → 0.154.0

data/lib/samagotchi/idle_recap.rb

@@ -21,8 +21,7 @@ module Samagotchi
   # Owns the inactivity clock bookkeeping shared across UIs: it reads the
   # Engine's `last_activity_at` / `activity_seq` / `turn_running?` seam (the
   # single source of truth) rather than tracking its own timeline, so the
-  # clock behaves identically for the interactive REPL and any Engine-backed
-  # worker.
+  # clock behaves identically for any Engine-backed worker.
   #
   # When the session has been idle for `@inactivity` seconds, no turn is
   # running, and there are >= `@min_user_turns` user turns, the job
@@ -285,7 +284,7 @@ module Samagotchi
     attr_reader :generation, :inactivity, :min_user_turns, :sentences, :timeout
 
     # @param callable [#call] true while a continue offer waits for an
-    #   answer (the Worker's or the REPL's TurnFlow); read at each attempt
+    #   answer (the Worker's TurnFlow); read at each attempt
     attr_writer :awaiting_continue
 
     # @return [Hash, nil] the last recap written: {text:, title:, covered:,
@@ -345,7 +344,7 @@ module Samagotchi
 
       @mutex = Monitor.new
       # Serializes the attempt state machine (#tick on the scheduler thread,
-      # #request_now on a Bridge or REPL thread, #write_now). Never held by
+      # #request_now on a Bridge thread, #write_now). Never held by
       # #state, so a snapshot reading it doesn't wait on an emit.
       @run_mutex = Monitor.new
       @generation = 0
@@ -389,7 +388,7 @@ module Samagotchi
     end
 
     # Write a recap now and wait for it, bounded by the timeout: the worker
-    # (or the REPL) leaving. Skips the inactivity window and the once-per-
+    # leaving. Skips the inactivity window and the once-per-
     # window latch, not the rules on what to recap (minimum user turns,
     # something new). Takes over an attempt already in flight. Call it with
     # the idle scheduler stopped.

data/lib/samagotchi/idle_reminders.rb

@@ -11,8 +11,7 @@ module Samagotchi
   #      Engine#run_turn) as [SYSTEM: REMINDERS DUE <local time>] and marks it fired.
   #   2. Synthetic turns: when this job's tick finds due reminders while
   #      idle, it fires @auto_turn_callback, which queues their names
-  #      (Engine#note_due_reminders) for the worker's or the REPL's
-  #      reminder turn. While names are queued the tick waits; whoever
+  #      (Engine#note_due_reminders) for the worker's reminder turn. While names are queued the tick waits; whoever
   #      clears them (a turn's injection, the reminder turn's consumer)
   #      re-arms it. The queue is the only "already due" state.
   class IdleReminders
@@ -64,8 +63,8 @@ module Samagotchi
 
       # Signal the engine to create a synthetic turn via callback.
       # The callback is responsible for triggering a turn (e.g. SessionManager
-      # writes a file, TerminalUI queues input). The engine's run_turn or
-      # REPL injection point then picks up and delivers the reminders.
+      # writes a file). The engine's run_turn then picks up and delivers
+      # the reminders.
       return unless @auto_turn_callback
 
       @auto_turn_callback.call(due_names)

data/lib/samagotchi/iteration_limit.rb

@@ -5,8 +5,8 @@ require_relative "log"
 
 module Samagotchi
   # A turn's iteration limit (how many model ↔ tool rounds before the turn
-  # stops and offers to continue), one resolver for the Engine, the worker
-  # and the REPL.
+  # stops and offers to continue), one resolver for the Engine and the
+  # worker.
   module IterationLimit
     KEY = "turn.max_iterations"
     # A turn's limit unless turn.max_iterations says otherwise, and the

data/lib/samagotchi/kernel_loop.rb

@@ -11,6 +11,7 @@ require_relative "prompt_literal_guard"
 require_relative "token_usage"
 require_relative "client"
 require_relative "llm/errors"
+require_relative "degrade"
 require_relative "log"
 require_relative "empty_answer_retry"
 require_relative "cut"
@@ -198,9 +199,9 @@ module Samagotchi
     # memory_read's overflow guard. nil when it can't be read.
     # @return [ContextWindow::Resolved, nil]
     def tool_output_window
-      ContextWindow.resolve(client: @client, model: @turn_settings&.model_name, setting: @turn_settings&.window_setting)
-    rescue StandardError
-      nil
+      Degrade.call(:model, "context_window_unresolved") do
+        ContextWindow.resolve(client: @client, model: @turn_settings&.model_name, setting: @turn_settings&.window_setting)
+      end
     end
 
     def guard_generation
@@ -383,9 +384,9 @@ module Samagotchi
     end
 
     def model_props
-      @client.respond_to?(:server_props) ? @client.server_props(model: @turn_settings.model_name) : nil
-    rescue StandardError
-      nil
+      Degrade.call(:model, "server_props_unreadable") do
+        @client.respond_to?(:server_props) ? @client.server_props(model: @turn_settings.model_name) : nil
+      end
     end
 
     # One iteration. Returns :next, :answer (the turn ends), or the turn's
@@ -831,10 +832,9 @@ module Samagotchi
                                                            cancel_controller: turn.cancel_controller, answer: answer)
     end
 
+    # A failing stream callback (a UI gone) must not break the turn.
     def emit_stream_event(callback, event)
-      callback&.call(event)
-    rescue StandardError
-      nil
+      Degrade.call(:turn, "stream_event_callback_failed", type: (event[:type] if event.is_a?(Hash))) { callback&.call(event) }
     end
 
     # ── Hook dispatch helper ───────────────────────────────────────────────────
@@ -849,9 +849,8 @@ module Samagotchi
     def fire_hook(name, event)
       return unless @hooks
 
-      @hooks.fire(name, event)
-    rescue StandardError
       # A failing hook must not break the turn.
+      Degrade.call(:hooks, "hook_fire_failed", hook: name) { @hooks.fire(name, event) }
     end
 
     # Coerce a value to boolean — handles true/false, nil, and string "true"/"false".

data/lib/samagotchi/launch_mode.rb

@@ -1,21 +1,12 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  # How `bin/chi` runs a session: attached to a worker (as `--attach` and
-  # `--shared` do) or in the plain in-process REPL. With `session.shared` on,
-  # plain `chi` runs attached unless it asks for something attached mode
-  # can't do yet.
+  # How `bin/chi` runs a session: attached to a worker (the attached TUI,
+  # AttachLauncher), or --non-interactive's one turn in this process
+  # (TerminalUI, the one-shot host).
   module LaunchMode
-    # Options an attached TUI can't honor: the worker prints nothing, so
-    # --verbose is about this process's output. (--model and --no-interrupt
-    # reach the worker: a /model command, and no_interrupt on each posted
-    # turn; --memory and --mute are session fields the worker reads.)
-    REPL_ONLY = { verbose: "--verbose" }.freeze
-    # What an attached run can't be combined with (the worker runs its turns).
-    ATTACHED_CONFLICTS = { non_interactive: "--non-interactive", verbose: "--verbose" }.freeze
-    # Opening a `chi scratch` session a killed REPL left behind would turn it
-    # into a kept one.
-    SCRATCH_LEFTOVER = "that's a leftover scratch session; it is deleted at the next sweep (chi sessions clean)"
+    # What an attached run can't be combined with.
+    ATTACHED_CONFLICTS = { non_interactive: "--non-interactive" }.freeze
     # A worker spawned or resumed for an attach whose Bridge never came (%s:
     # the session id). A worker whose chi home couldn't load chi logs
     # SessionManager::HOME_BOOT_FAILED and exits: HomeDoctor's boot row says
@@ -30,20 +21,12 @@ module Samagotchi
     module_function
 
     # @param options [Hash] bin/chi's parsed options
-    # @param shared_config [Boolean] the session.shared config value
-    # @return [Array(Symbol, String)] :attached or :repl, and a note for the
-    #   user when the config asked for attached mode but didn't get it
-    def resolve(options, shared_config:)
-      return [:attached, nil] if options[:attach] || options[:shared]
-      # --no-shared, or nobody asked for attached mode.
-      return [:repl, nil] if options[:shared] == false || !shared_config
-      # A one-shot with no REPL: nothing to attach.
-      return [:repl, nil] if options[:non_interactive]
+    # @return [Symbol] :attached, or :one_shot (--non-interactive: one turn
+    #   in this process)
+    def resolve(options)
+      return :attached if options[:attach]
 
-      flag = REPL_ONLY.find { |key, _flag| options[key] }&.last
-      return [:repl, "(session.shared: #{flag} runs in a plain REPL)"] if flag
-
-      [:attached, nil]
+      options[:non_interactive] ? :one_shot : :attached
     end
 
     # Why an attached run's flags don't go together, or nil when they do.
@@ -51,12 +34,10 @@ module Samagotchi
     # @return [String, nil]
     def attached_conflict(options)
       conflict = ATTACHED_CONFLICTS.find { |key, _flag| options[key] }
-      if options[:attach] && options[:shared]
-        "use either --attach ID or --shared"
-      elsif options[:attach] && options[:resume]
-        "--attach takes the session id; --resume goes with --shared"
+      if options[:attach] && options[:resume]
+        "use either --attach ID or --resume ID"
       elsif conflict
-        "--attach/--shared can't be combined with #{conflict.last}"
+        "--attach can't be combined with #{conflict.last}"
       end
     end
   end

data/lib/samagotchi/level_setting_command.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "cache_confirm"
+require_relative "session"
 
 module Samagotchi
   # A command for a session's own level of a setting (/thinking,
   # /reasoning-history): with no argument, the level the next turn runs at
   # and where it came from; with a level, sets the session's own (the
   # setting's unset word unsets it). A change takes effect at the next
-  # turn's start (the REPL and the worker run it between turns), and the
+  # turn's start (the worker runs it between turns), and the
   # reply says what it costs the prompt cache. A costly change asks first
   # (CacheConfirm); --yes (or -y) applies it.
   #
@@ -47,7 +48,7 @@ module Samagotchi
       known, own = spec.parse.call(word)
       raise ArgumentError, "unknown #{spec.label} level #{word}\n#{spec.usage}" unless known
 
-      session = @engine.session or raise ArgumentError, "no session yet"
+      session = @engine.session or raise ArgumentError, Session::NONE_YET
       before = explained
       ask = confirm && !yes ? ask(before, own, word) : nil
       return ask if ask

data/lib/samagotchi/llm_context_command.rb

@@ -5,6 +5,7 @@ require_relative "llm_context_strategy"
 require_relative "llm_context_edit"
 require_relative "llm_context_stale"
 require_relative "cache_confirm"
+require_relative "session"
 
 module Samagotchi
   # /llm-context, the session's own LLM context values
@@ -14,7 +15,7 @@ module Samagotchi
   # `strategy <layers|none>`, `apply <rule>` and `budget <N|off>` (any of
   # them, in one line; `default` unsets one) it sets the session's own, and
   # `reset` unsets them all. A change takes effect at the next turn's
-  # start (the REPL and the worker run it between turns), and the reply
+  # start (the worker runs it between turns), and the reply
   # says what it costs: forget on or off changes the tool list and the
   # system prompt (a full cache break); stale turned on stages the reads
   # already superseded as one batch under the apply rule; a layer turned
@@ -49,7 +50,7 @@ module Samagotchi
       args, yes = CacheConfirm.split(args, downcase: false)
       return [listing(@engine.llm_context_explained), false, nil] if args.empty?
 
-      session = @engine.session or raise ArgumentError, "no session yet"
+      session = @engine.session or raise ArgumentError, Session::NONE_YET
       before = @engine.llm_context_explained
       updated = args.casecmp?(RESET) ? LLMContextOverride.new : LLMContextOverride.update(@engine.llm_context_override, words(args))
       ask = confirm && !yes ? ask(session, before, updated, args) : nil

data/lib/samagotchi/llm_context_stale.rb

@@ -197,8 +197,8 @@ module Samagotchi
         return texts ? [[refs.first, call, texts.first.text]] : []
       end
 
-      # A call_tool of a built-in ran as it: its run's lead names the
-      # built-in (BuiltinCalls.unwrap_saved).
+      # A call_tool of a chi tool (a built-in or a plugin's) ran as it: its
+      # run's lead names the tool (BuiltinCalls.unwrap_saved).
       calls = batch.map(&:last)
       calls = calls.zip(ToolResponse.runs(entry[:content], calls.size)).map do |call, run|
         Tools::BuiltinCalls.unwrap_saved(Tools::BuiltinCalls.wrap_saved(call, run&.text), run&.text)

data/lib/samagotchi/log.rb

@@ -71,7 +71,7 @@ module Samagotchi
         @monitor.synchronize { close_state }
       end
 
-      # The session this process works for (a worker, the REPL); records
+      # The session this process works for (a worker, a one-shot); records
       # carry its first SID_LENGTH chars unless they pass their own sid:.
       attr_accessor :session_id
 
@@ -127,7 +127,7 @@ module Samagotchi
         state[:writer].write(text)
         mirror(text) if state[:mirror] && !echo
         text
-      rescue StandardError
+      rescue StandardError # degrade-ok: Log's own internals: a failure here must not recurse into Log
         nil
       end
 
@@ -152,7 +152,7 @@ module Samagotchi
           ts: Time.now, level: level.to_s.upcase, tag: tag, pid: Process.pid,
           sid: sid && sid.to_s[0, SID_LENGTH], event: event, fields: fields, payload: payload
         ))
-      rescue StandardError
+      rescue StandardError # degrade-ok: Log's own internals: a failure here must not recurse into Log
         nil
       end
 
@@ -170,13 +170,13 @@ module Samagotchi
 
       def echo_to_stderr(text)
         $stderr.puts(text)
-      rescue StandardError
+      rescue StandardError # degrade-ok: Log's own internals: a failure here must not recurse into Log
         nil
       end
 
       def mirror(text)
         $stderr.write(text)
-      rescue StandardError
+      rescue StandardError # degrade-ok: Log's own internals: a failure here must not recurse into Log
         nil
       end
 
@@ -201,8 +201,8 @@ module Samagotchi
       def build_state
         options = @options
         path = options.fetch(:path, :auto)
-        path = LogPath.resolve rescue nil if path == :auto
-        level = options[:level] || (Config.get("log.level") rescue nil)
+        path = LogPath.resolve rescue nil if path == :auto # degrade-ok: Log's own internals: a failure here must not recurse into Log
+        level = options[:level] || (Config.get("log.level") rescue nil) # degrade-ok: Log's own internals: a failure here must not recurse into Log
         level = LEVELS.key?(level.to_s.downcase.to_sym) ? level.to_s.downcase.to_sym : DEFAULT_LEVEL
         { writer: DebugLog.new(path: path), level: LEVELS.fetch(level), mirror: options[:mirror] ? true : false }
       end

data/lib/samagotchi/log_line.rb

@@ -16,7 +16,7 @@ module Samagotchi
   # (debug dumps) are indented by four spaces and belong to the record above.
   module LogLine
     LEVELS = %w[DEBUG INFO WARN ERROR].freeze
-    TAGS = %w[turn http worker bridge web attached repl idle recap hooks plugins guardrails config memory model context broadcast toolkit system_one].freeze
+    TAGS = %w[turn http worker bridge web attached idle recap hooks plugins guardrails config memory model context broadcast toolkit system_one prompt].freeze
     INDENT = "    "
 
     Record = Struct.new(:ts, :level, :tag, :pid, :sid, :event, :fields, :payload, keyword_init: true)

data/lib/samagotchi/log_path.rb

@@ -4,7 +4,7 @@ require_relative "config"
 require_relative "paths"
 
 module Samagotchi
-  # Where the debug log (DebugLog) goes, for the REPL, the attached terminal
+  # Where the debug log (DebugLog) goes, for a one-shot, the attached terminal
   # and the background worker alike: nil when log.disable is set, else log.file
   # (~ and relative paths expanded against cwd), else
   # $XDG_STATE_HOME/samagotchi/samagotchi.log (~/.local/state/... by default),

data/lib/samagotchi/message_parts.rb

@@ -240,8 +240,9 @@ module Samagotchi
     # +tool_id+: its output's ToolIds id, with its ✂ mark in +marks+.
     def tool_part(call, output, registry, shown = nil, images = nil, label: nil, diff: nil, refs: nil, cwd: nil,
                   tool_id: nil, marks: {})
-      # A built-in reached through call_tool reloads as that built-in's
-      # row, with via (its saved params and label are the built-in's).
+      # A chi tool (a built-in or a plugin's) reached through call_tool
+      # reloads as that tool's row, with via (its saved params and label
+      # are the tool's).
       # A direct call of an MCP tool reloads as the call_tool row it ran as.
       call = Tools::BuiltinCalls.unwrap_saved(Tools::BuiltinCalls.wrap_saved(call, output), output)
       name = call[:name].to_s

data/lib/samagotchi/note_command.rb

@@ -123,7 +123,7 @@ module Samagotchi
 
     def outcome(result)
       case result.status
-      when :refused then "refused: #{NoteDelivery::REPL_REFUSAL}"
+      when :refused then "refused: #{result.refusal}"
       when :queued then "queued: its worker adds it within a few seconds"
       else "waits for the session's next start (#{result.queued} #{result.queued == 1 ? "note" : "notes"} queued)"
       end

data/lib/samagotchi/note_delivery.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "session"
+require_relative "owner_lock"
 require_relative "session_inbox"
 
 module Samagotchi
@@ -9,21 +10,28 @@ module Samagotchi
   autoload :SessionManager, File.expand_path("session_manager", __dir__)
 
   # The one rule for putting a context note into a session, shared by
-  # `chi note`, the agent's send_note and `chi broadcast`: a session a chi
-  # REPL owns refuses it (notes need attached mode); any other gets the
-  # note in its notes/ folder, which a live worker adds within seconds and
-  # a session with no worker at its next start. Callers word the outcome.
+  # `chi note`, the agent's send_note and `chi broadcast`: a session a
+  # one-turn chi run owns, or a chi scratch session, refuses it; any other
+  # gets the note in its notes/ folder, which a live worker adds within
+  # seconds and a session with no worker at its next start. Callers word
+  # the outcome (#refusal for a refused one).
   module NoteDelivery
-    # Why a chi REPL's session takes no note.
-    REPL_REFUSAL = "it is open in a chi REPL; notes need attached mode"
+    # Why a one-turn chi run's session takes no note.
+    ONE_SHOT_REFUSAL = "it is #{OwnerLock::TUI_BUSY}; send the note once it ends"
 
     # The outcome for one session.
     # @!attribute status [Symbol] :queued (a worker runs it), :waits (no
-    #   worker: it waits for the next start) or :refused (a chi REPL owns it)
+    #   worker: it waits for the next start) or :refused (a one-turn chi run
+    #   owns it, or it is a chi scratch session: +scratch+)
     # @!attribute queued [Integer] notes waiting in its notes/ folder
     #   (:waits only; 0 otherwise)
-    Result = Data.define(:id, :status, :queued) do
+    Result = Data.define(:id, :status, :queued, :scratch) do
+      def initialize(id:, status:, queued:, scratch: false) = super
+
       def delivered? = status != :refused
+
+      # Why a refused note was refused, in its condition's one wording.
+      def refusal = scratch ? Session::SCRATCH_REFUSED : ONE_SHOT_REFUSAL
     end
 
     module_function
@@ -35,6 +43,8 @@ module Samagotchi
     def deliver(id, text:, source:, state_dir:, from_session: nil, from_cwd: nil, objectives: nil)
       owner = SessionManager.session_owner(id, state_dir: state_dir)
       return Result.new(id: id, status: :refused, queued: 0) if owner&.tui?
+      # Its terminal's alone, live or left behind.
+      return Result.new(id: id, status: :refused, queued: 0, scratch: true) if Session.load(id, state_dir: state_dir).scratch
 
       path = SessionInbox.write_note(id, text: text, source: source, from_session: from_session, from_cwd: from_cwd,
                                          objectives: objectives, state_dir: state_dir)

data/lib/samagotchi/objectives.rb

@@ -10,6 +10,7 @@ require_relative "llm_context_stale"
 require_relative "log"
 require_relative "message_time"
 require_relative "objectives_check"
+require_relative "objectives_edit"
 require_relative "session"
 require_relative "session_chain"
 require_relative "session_inbox"
@@ -103,13 +104,19 @@ module Samagotchi
         new(change: change, id: id, text: kept, note: note, was: Objectives.fingerprint(item))
       end
 
-      # What's wrong with it against +list+, nil when it can apply.
+      # What's wrong with it against +list+, nil when it can apply: its #line
+      # through the same Edit its card's Apply runs, so what Apply would refuse
+      # is refused here.
       def refusal(list)
         return "change must be add, reword, done or drop" unless %w[add reword done drop].include?(change)
         return "#{change} needs a text" if %w[add reword].include?(change) && text.empty?
-        return nil if change == "add"
+        return Objectives.unknown(id, list) unless change == "add" || list.find(id)
 
-        list.find(id) ? nil : "no objective #{id} (this session's: #{list.items.map(&:id).join(", ")})"
+        verb, rest = line.delete_prefix("/objectives ").split(/\s+/, 2)
+        edited = Edit.apply(list, verb, rest.to_s, was: was)
+        return "#{change} needs a text of its own, not only a status or a done-when" if edited.nil?
+
+        edited.is_a?(String) ? edited : nil
       end
 
       # The /objectives line that applies it. An add's text can't split in two.
@@ -240,6 +247,20 @@ module Samagotchi
       AtomicFile.write(path, JSON.generate(known.merge(card => state)))
     end
 
+    # The one wording per refusal: the command, a proposal, a move and a check
+    # say these, each adding only its own context.
+    # @param ids [Array<String>, String] the ids the list doesn't have
+    def unknown(ids, list)
+      known = list.items.map(&:id)
+      "no objective #{Array(ids).join(", ")}#{" (this session's: #{known.join(", ")})" unless known.empty?}"
+    end
+
+    # @param ids [Array<String>, String] dropped ids
+    def dropped(ids)
+      ids = Array(ids)
+      "#{ids.join(", ")} #{ids.size == 1 ? "is" : "are"} dropped; /objectives undo #{ids.join(" ")} brings #{ids.size == 1 ? "it" : "them"} back"
+    end
+
     # The id a call names, as the list spells it.
     def move_id(call) = call[:id].to_s.strip.upcase
 

data/lib/samagotchi/objectives_check.rb

@@ -6,16 +6,14 @@ require "json"
 require "securerandom"
 require "time"
 
+require_relative "answer_text"
 require_relative "config"
 require_relative "context_note"
 require_relative "llm_context_stale"
 require_relative "log"
-require_relative "message_parts"
-require_relative "model_profile"
-require_relative "output_formatter"
+require_relative "redact"
 require_relative "session"
 require_relative "steer"
-require_relative "tool_call_parser"
 require_relative "verdict"
 
 module Samagotchi
@@ -51,9 +49,6 @@ module Samagotchi
     LEFT_OUT = "[earlier record left out]"
     # What the agent said to the user, in the record.
     OWN_WORDS = "[agent's own words]"
-    # A thought cut off before its close: the whole entry, from an opening at its
-    # start. MessageParts' forms are the closed one and the template-opened one.
-    UNCLOSED_THINK = /\A\s*<think>.*\z/m
     SYSTEM = "You check one claim a coding agent made about its own work, for the user. You see only the claim and the " \
              "session's record: what the user and others wrote, what the tools returned, and what the agent said to the " \
              "user, marked #{OWN_WORDS}. You didn't do the work and you owe the agent nothing. The agent's own words " \
@@ -77,7 +72,7 @@ module Samagotchi
     # @param args [String] the objective's id
     # @return [Array(String, Symbol)] the reply, and :ok or :error
     def run(engine, args)
-      session = engine.session or return ["no session yet", :error]
+      session = engine.session or return [Session::NONE_YET, :error]
       id = args.to_s.strip.upcase
       return ["usage: /objectives check ID", :error] unless Objectives::ID.match?(id)
       # The running turn's text is theirs: it doesn't go to a side request.
@@ -98,8 +93,8 @@ module Samagotchi
       model = configured_model
       Objectives.with_lock(dir) do
         list = Objectives.current(session.id, session.messages, state_dir: engine.session_state_dir, running: conversation)
-        item = list.find(id) or next ["no objective #{id}", :error]
-        next ["#{id} is dropped", :error] if item.status == Objectives::DROPPED
+        item = list.find(id) or next [Objectives.unknown(id, list), :error]
+        next [Objectives.dropped(id), :error] if item.status == Objectives::DROPPED
 
         move = list.moves[id] or next ["#{id} has no move to check yet", :error]
         name = model || engine.effective_model_ref
@@ -167,7 +162,7 @@ module Samagotchi
 
     # The chat request: the objective, the claim and the record, in a frame whose
     # tag no text in them could know, so tool output can't close it. Secrets
-    # chi's participant redaction knows (ParticipantView::Redact, by shape and
+    # chi's participant redaction knows (Redact, by shape and
     # by name, no model involved) don't leave: objectives.check_model may be
     # another host.
     # @param item [Objectives::Item]
@@ -182,8 +177,7 @@ module Samagotchi
     end
 
     def redacted(text)
-      require_relative "web/participant_view"
-      Web::ParticipantView::Redact.text(text, Web::ParticipantView::Viewer.new(cwd: nil))
+      Redact.text(text, Redact::Viewer.new(cwd: nil))
     end
     private_class_method :redacted
 
@@ -217,7 +211,7 @@ module Samagotchi
 
       case (entry[:role] || entry["role"]).to_s
       when "model"
-        words = own_words(text)
+        words = AnswerText.visible(text)
         "#{OWN_WORDS}\n#{cut(words, OUTPUT_CHARS)}" unless words.empty?
       when "user" then "[#{Steer.participant_message?(entry) ? "participant" : "user"}]\n#{cut(text, OUTPUT_CHARS)}"
       when "system"
@@ -229,19 +223,6 @@ module Samagotchi
     end
     private_class_method :said_part
 
-    # What the user saw of a model entry. A chat entry's content is that already
-    # (its reasoning is the separate :thinking, its calls :tool_calls); a native
-    # entry's is the raw response, thoughts and call markup inline.
-    # @return [String]
-    def own_words(text)
-      gemma = ToolCallParser::Gemma.new(ModelProfile.gemma4)
-      text = gemma.strip_thought(text).gsub(MessageParts::QWEN_THINK, "").sub(UNCLOSED_THINK, "")
-                  .sub(MessageParts::QWEN_OPEN_THINK, "")
-      text = ToolCallParser.strip_calls(gemma.strip_tool_calls(text), "<tool_call>", "</tool_call>")
-      OutputFormatter.strip_markup(text)
-    end
-    private_class_method :own_words
-
     # A multipart entry's text parts.
     def text_of(content)
       return content.to_s.scrub if content.is_a?(String)