samagotchi 0.153.0 → 0.154.0

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/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/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)

data/lib/samagotchi/objectives_command.rb

@@ -8,7 +8,7 @@ module Samagotchi
   # /objectives: with no arguments the session's list (Objectives), each
   # objective's latest move under it (the model's objectives tool; a move
   # changes nothing); `set`, `add`, `edit`, `done`, `drop` and `undo` edit it. An edit is a
-  # whole new list in a note file (NoteDelivery, with its refusal of a chi REPL's session), so it is
+  # whole new list in a note file (NoteDelivery, with its refusal of a one-turn chi run's session), so it is
   # safe from any thread, a turn running or not: it goes into the conversation
   # at the worker's next pass between turns, and a second edit stacks on an
   # unabsorbed first. Nothing here saves the session.
@@ -18,10 +18,6 @@ module Samagotchi
             "(a text may end \"(done when: …)\"; lines work as | does)".freeze
     NONE = "no objectives; #{NAME} set A | B sets them".freeze
     BETWEEN_TURNS = "(an edit goes into the conversation between turns)"
-    SEPARATOR = /\n|(?:\A|\s)\|(?:\s|\z)/
-    # What the frame shows a status as: typed at a text's start it would pass
-    # for one (Objectives::Item#line).
-    STATUS_MARK = /\A(?:\[(?:#{Objectives::STATUSES.join("|")})\]\s*)+/i
     # A proposal card's action (Tools::ObjectivesTool): the edit, then the card
     # folds to a line, once: it is recorded, so a repeat applies nothing. A
     # reword's --was says what it was proposed against. The prefix is the
@@ -30,7 +26,6 @@ module Samagotchi
     FOLDS = { Objectives::APPLIED => "Proposal applied", Objectives::DISMISSED => "Proposal dismissed" }.freeze
     DISMISS = "dismiss"
     CHECK = /\Acheck(?:\s|\z)/i
-    MARKS = { "done" => Objectives::DONE, "drop" => Objectives::DROPPED, "undo" => Objectives::ACTIVE }.freeze
 
     # @param engine [Engine] #session, #session_state_dir
     def initialize(engine:)
@@ -84,7 +79,7 @@ module Samagotchi
     end
 
     def run_line(args, was: nil)
-      session = @engine.session or return ["no session yet", :error]
+      session = @engine.session or return [Session::NONE_YET, :error]
       # The running turn's moves aren't in session.messages yet. A snapshot from
       # this thread, read only: an entry is there whole or not yet, and a call
       # with no result yet pairs with nothing.
@@ -93,7 +88,7 @@ module Samagotchi
       verb, rest = args.to_s.strip.split(/\s+/, 2)
       return [listing(list, session), :ok] if verb.nil?
 
-      edited = edit(list, verb.downcase, rest.to_s, was: was)
+      edited = Objectives::Edit.apply(list, verb.downcase, rest.to_s, was: was)
       return [USAGE, :error] if edited.nil?
       return [edited, :error] if edited.is_a?(String)
       return ["#{listing(list, session)}\n(no change)", :ok] if edited == list
@@ -101,70 +96,10 @@ module Samagotchi
       deliver(edited, session)
     end
 
-    # @return [Objectives::List, String, nil] the new list, what's wrong with
-    #   the line, or nil for a line that isn't one
-    def edit(list, verb, rest, was: nil)
-      case verb
-      when "set", "add"
-        entries = entries_of(rest)
-        return nil if entries.nil? || entries.empty?
-
-        verb == "set" ? list.set(entries) : entries.reduce(list) { |so_far, e| so_far.add(e[:text], done_when: e[:done_when]) }
-      when "edit" then reword(list, rest, was: was)
-      when *MARKS.keys then mark(list, MARKS.fetch(verb), rest)
-      end
-    end
-
-    def mark(list, status, rest)
-      ids = rest.upcase.split(/[\s,]+/).reject(&:empty?)
-      return nil if ids.empty?
-
-      missing = ids.reject { |id| list.find(id) }
-      return "no objective #{missing.join(", ")}" unless missing.empty?
-
-      if status == Objectives::DONE
-        dropped = ids.select { |id| list.find(id).status == Objectives::DROPPED }
-        return "#{dropped.join(", ")} is dropped; #{NAME} undo #{dropped.join(" ")} brings it back" unless dropped.empty?
-      end
-
-      ids.reduce(list) { |so_far, id| so_far.mark(id, status) }
-    end
-
-    # The objective's new text: the whole rest of the line, a | too.
-    def reword(list, rest, was: nil)
-      id, text = rest.strip.split(/\s+/, 2)
-      entry = text && entry_of(text.gsub(/[[:space:]]+/, " ").strip)
-      return nil unless entry
-
-      id = id.upcase
-      item = list.find(id) or return "no objective #{id}"
-      return "#{id} has changed since this was proposed: #{item.text}" if was && Objectives.fingerprint(item) != was
-
-      list.reword(id, entry[:text], done_when: entry[:done_when])
-    end
-
-    # One {text:, done_when:} per line or |-part, any whitespace collapsed
-    # (Unicode line separators too: the frame is one line per item).
-    # @return [Array<Hash>, nil] nil when a part has no text of its own
-    def entries_of(rest)
-      parts = rest.split(SEPARATOR).map { |part| part.gsub(/[[:space:]]+/, " ").strip }.reject(&:empty?)
-      entries = parts.map { |part| entry_of(part) }
-      entries.all? ? entries : nil
-    end
-
-    def entry_of(part)
-      found = Objectives::DONE_WHEN.match(part)
-      text = (found ? found[1] : part).sub(STATUS_MARK, "").strip
-      return nil if text.empty?
-
-      done_when = found && found[2]
-      { text: text, done_when: done_when.to_s.empty? ? nil : done_when }
-    end
-
     def deliver(list, session)
       result = NoteDelivery.deliver(session.id, text: list.text, source: Objectives::SOURCE,
                                                 state_dir: @engine.session_state_dir, objectives: list.to_payload)
-      return ["refused: #{NoteDelivery::REPL_REFUSAL}", :error] unless result.delivered?
+      return ["refused: #{result.refusal}", :error] unless result.delivered?
 
       @engine.announce_objectives(session)
       ["#{lines_of(list)}\n#{BETWEEN_TURNS}", :ok]