samagotchi 0.102.0 → 0.103.0

data/lib/samagotchi/context_command.rb

@@ -11,6 +11,7 @@ require_relative "cli/command"
 require_relative "cli/exit"
 require_relative "cli/flags"
 require_relative "redacted_inspect"
+require_relative "session_access/local"
 
 module Samagotchi
   # `chi context`: attach live external text to sessions (ContextSources).
@@ -76,10 +77,16 @@ module Samagotchi
       def project? = session_id.nil?
     end
 
+    # Why chi context rm NAME ID (and chi web's DELETE …/context/NAME?own=1)
+    # leaves a source the session's project has.
+    def self.project_source_message(name) = "#{name} is the project's: chi context rm #{name} --project, or mute it for this session"
+
     # @param argv [Array<String>] the arguments after "context"
     # @param clock [#call] now, for ls's ages ("4s ago")
+    # @param access [SessionAccess::Local, nil] where the sessions are;
+    #   default this machine's, in +state_dir+
     def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, state_dir: nil, env: ENV, cwd: Dir.pwd,
-                   clock: -> { Time.now })
+                   clock: -> { Time.now }, access: nil)
       @argv = argv.dup
       @stdin = stdin
       @stdout = stdout
@@ -88,6 +95,7 @@ module Samagotchi
       @env = env
       @cwd = cwd
       @clock = clock
+      @access = access || SessionAccess::Local.new(state_dir: @state_dir)
     end
 
     # @return [Integer] exit status: 0 done, 1 refused or failed, 2 usage
@@ -127,11 +135,10 @@ module Samagotchi
         name: name, cmd: options[:cmd], every_seconds: ContextSources.check_every!(options[:every]),
         why: ContextSources.one_line(options[:why], ContextSources::LINE_MAX_CHARS),
         hint: ContextSources.one_line(options[:hint], ContextSources::LINE_MAX_CHARS),
-        scope: nil, added_by: inside_session ? "agent" : "cli", created_at: Time.now.utc.iso8601
+        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601
       )
       each_target(options, args) do |target|
-        location = location_of(target)
-        location.add(source.with(scope: location.scope))
+        @access.context_add(target, source)
         @stdout.puts("#{target.label}  attached #{name}")
         true
       end
@@ -144,6 +151,7 @@ module Samagotchi
       if options[:cmd] || options[:push] || options[:every]
         return usage_error("a URL's command comes from its provider: give no --cmd, --push or --every")
       end
+      return add_remote_url(url, options, args) if @access.remote?
 
       resolved = ContextProviders.resolve(url)
       return fail_line("no installed bundle resolves #{url} (chi bundle install github-pr for GitHub PRs)") unless resolved
@@ -152,11 +160,10 @@ module Samagotchi
         name: resolved.name, cmd: resolved.cmd, every_seconds: resolved.every_seconds,
         why: ContextSources.one_line(options[:why] || resolved.why, ContextSources::LINE_MAX_CHARS),
         hint: ContextSources.one_line(options[:hint] || resolved.hint, ContextSources::LINE_MAX_CHARS),
-        scope: nil, added_by: inside_session ? "agent" : "cli", created_at: Time.now.utc.iso8601, provider: resolved.bundle
+        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601, provider: resolved.bundle
       )
       each_target(options, args) do |target|
-        location = location_of(target)
-        location.add(source.with(scope: location.scope))
+        @access.context_add(target, source)
         @stdout.puts("#{target.label}  attached #{source.name}")
         true
       end
@@ -164,6 +171,19 @@ module Samagotchi
       fail_line(e.message)
     end
 
+    # A URL on a remote: its installed bundles' providers resolve it there.
+    def add_remote_url(url, options, args)
+      why = ContextSources.one_line(options[:why], ContextSources::LINE_MAX_CHARS)
+      hint = ContextSources.one_line(options[:hint], ContextSources::LINE_MAX_CHARS)
+      each_target(options, args) do |target|
+        name = @access.context_add_url(target, url, why: why, hint: hint, added_by: added_by)
+        @stdout.puts("#{target.label}  attached #{name}")
+        true
+      end
+    rescue ContextProviders::Invalid => e
+      fail_line(e.message)
+    end
+
     def run_push(options, args)
       name = args.shift
       return usage_error("give the source's NAME") unless name
@@ -173,18 +193,20 @@ module Samagotchi
 
       fetched = ContextSources.parse_output(text)
       each_target(options, args) do |target|
-        attached = find(target, name) or next false
-        # A command source's text is its command's (R2): a push between
-        # two fetches would read as a change and then vanish.
-        unless attached.source.push?
-          error_line("#{command_name}: #{name} runs a command, which writes its text: push goes to a --push source")
+        pushed = @access.context_push(target, name, fetched)
+        case pushed.status
+        when :missing
+          no_source(target, name)
+          next false
+        when :not_push
+          # A command source's text is its command's (R2): a push between
+          # two fetches would read as a change and then vanish.
+          error_line("#{command_name}: #{SessionAccess::ContextPush.not_push_message(name)}")
           next false
         end
 
-        before, written = attached.location.locked(name) do
-          [attached.location.snapshot(name).revision, attached.location.record_text(name, fetched)]
-        end
-        @stdout.puts("#{target.label}  #{name}: #{written.revision == before ? "unchanged" : "new text"} (#{written.revision[0, 12]})")
+        @stdout.puts("#{target.label}  #{name}: #{pushed.revision == pushed.before ? "unchanged" : "new text"} " \
+                     "(#{pushed.revision[0, 12]})")
         true
       end
     end
@@ -194,7 +216,7 @@ module Samagotchi
       return usage_error("unknown format #{format.inspect}: use --format text|json") unless [nil, "text", "json"].include?(format)
 
       targets = targets(options, args) or return CLI::Exit::FAILED
-      rows = targets.flat_map { |target| rows_for(target) }
+      rows = targets.flat_map { |target| @access.context_entries(target).map { |entry| row(target, entry) } }
       if format == "json"
         @stdout.puts(JSON.pretty_generate(rows))
       elsif rows.empty?
@@ -212,10 +234,10 @@ module Samagotchi
       targets = targets(options, args) or return CLI::Exit::FAILED
       return usage_error("show takes one target") if targets.size > 1
 
-      attached = find(targets.first, name) or return CLI::Exit::FAILED
-      snapshot = attached.snapshot
+      entry = @access.context_entry(targets.first, name) or return no_source(targets.first, name)
+      snapshot = entry.snapshot
       if options[:json]
-        @stdout.puts(JSON.pretty_generate({ "source" => attached.source.to_h, "snapshot" => snapshot.to_h }))
+        @stdout.puts(JSON.pretty_generate({ "source" => entry.source.to_h, "snapshot" => snapshot.to_h }))
         return 0
       end
       unless snapshot.text?
@@ -229,7 +251,8 @@ module Samagotchi
 
     # Runs the command in this process, not the worker's: the result shows
     # here, and the worker sees the new snapshot on its next loop. The
-    # source's lock keeps the two from running it at once.
+    # source's lock keeps the two from running it at once. Local only
+    # (SessionAccess::Contract): it runs the command on this machine.
     def run_refresh(options, args)
       name = args.shift
       return usage_error("give the source's NAME") unless name
@@ -271,15 +294,12 @@ module Samagotchi
 
       ContextSources.check_name!(name)
       each_target(options, args) do |target|
-        location = location_of(target)
-        if location.remove(name)
+        case @access.context_remove(target, name)
+        when :removed
           @stdout.puts("#{target.label}  detached #{name}")
           next true
-        end
-
-        project = !target.project? && ContextSources.project_location_for(target.project_root, state_dir: @state_dir)
-        if project&.source(name)
-          error_line("#{command_name}: #{name} is the project's: chi context rm #{name} --project, or mute it for this session")
+        when :project
+          error_line("#{command_name}: #{self.class.project_source_message(name)}")
         else
           error_line("#{command_name}: no source #{name} for #{target.label}")
         end
@@ -287,6 +307,7 @@ module Samagotchi
       end
     end
 
+    # Local only (SessionAccess::Contract): the session's muted/ files here.
     def run_mute(options, args) = mute_or_unmute(options, args, mute: true)
     def run_unmute(options, args) = mute_or_unmute(options, args, mute: false)
 
@@ -327,10 +348,11 @@ module Samagotchi
         return [target]
       end
       if args.empty?
-        own = inside_session
+        own = inside_session unless @access.remote?
         unless own
-          error_line("#{command_name}: give session ids (or unique prefixes), or --project; " \
-                     "inside a chi session it's that session")
+          # Remotely no default: the session chi runs in is this machine's.
+          error_line("#{command_name}: give session ids (or unique prefixes)" \
+                     "#{", or --project; inside a chi session it's that session" unless @access.remote?}")
           return nil
         end
         args = [own]
@@ -340,6 +362,8 @@ module Samagotchi
       resolved.all? ? resolved.uniq : nil
     end
 
+    # A project's sources: local only (SessionAccess::Contract), this
+    # machine's checkout.
     def project_target
       unless MemoryPaths.in_repo?(@cwd)
         error_line("#{command_name}: --project needs a git repository, and #{@cwd} is in none")
@@ -354,8 +378,8 @@ module Samagotchi
     end
 
     def session_target(given)
-      id = Session.resolve_id(given, state_dir: @state_dir)
-      session = Session.load(id, state_dir: @state_dir)
+      id = @access.resolve_id(given)
+      session = @access.show(id)
       Target.new(session_id: id, project_root: session.project_root, cwd: session.working_directory, label: id[0, 8])
     rescue ArgumentError => e
       message = e.is_a?(Session::AmbiguousId) ? e.message : "no session #{given}"
@@ -363,64 +387,47 @@ module Samagotchi
       nil
     end
 
+    # Who adds a source: an agent (chi's execute runs this in a session)
+    # or the user's cli.
+    def added_by = inside_session ? "agent" : "cli"
+
     # The session chi's execute runs this in (SAMAGOTCHI_PARENT_SESSION;
-    # "chi" is a run with no session).
+    # "chi" is a run with no session). Machine-local (a session on this
+    # machine): remotely it is no default target (#targets), the ids are
+    # given.
     def inside_session
       id = @env.fetch("SAMAGOTCHI_PARENT_SESSION", "").to_s.strip
       id.empty? || id == "chi" ? nil : id
     end
 
-    # The folder a target's own sources live in.
-    def location_of(target)
-      if target.project?
-        ContextSources.project_location_for(target.project_root, state_dir: @state_dir)
-      else
-        ContextSources.session_location(target.session_id, state_dir: @state_dir)
-      end
-    end
+    # The folder a target's own sources live in (refresh, mute: local only).
+    def location_of(target) = @access.context_location(target)
 
-    # A source as the target sees it (a session: its own, then its project's).
+    # A source as the target sees it (a session: its own, then its
+    # project's), for refresh and mute (local only).
     # @return [ContextSources::Attached, nil] nil after an error line
     def find(target, name)
-      ContextSources.check_name!(name)
-      found = if target.project?
-                location = location_of(target)
-                source = location.source(name)
-                source && ContextSources::Attached.new(source: source, location: location, shadowed: false)
-              else
-                attached_to(target).find { |a| a.name == name }
-              end
-      error_line("#{command_name}: no source #{name} for #{target.label}") unless found
+      found = @access.context_attached(target, name)
+      no_source(target, name) unless found
       found
     end
 
-    def attached_to(target, shadowed: false)
-      ContextSources.attached(target.session_id, project_root: target.project_root, state_dir: @state_dir,
-                                                 shadowed: shadowed)
-    end
-
-    def rows_for(target)
-      if target.project?
-        location = location_of(target)
-        return location.sources.map { |source| row(target, source, location.snapshot(source.name)) }
-      end
-
-      own = ContextSources.session_location(target.session_id, state_dir: @state_dir)
-      subs = own.subscriptions
-      attached_to(target, shadowed: true).map do |a|
-        snapshot = a.snapshot
-        read = subs[a.name]&.read
-        row(target, a.source, snapshot, muted: own.muted?(a.name), shadowed: a.shadowed,
-                                        unread: snapshot.text? && read != snapshot.revision)
-      end
+    # @return [Integer] 1, after the line
+    def no_source(target, name)
+      error_line("#{command_name}: no source #{name} for #{target.label}")
+      CLI::Exit::FAILED
     end
 
-    def row(target, source, snapshot, muted: nil, shadowed: nil, unread: nil)
+    # One line of ls (its --format json object).
+    # @param entry [SessionAccess::ContextEntry]
+    def row(target, entry)
+      source = entry.source
+      snapshot = entry.snapshot
       { "target" => target.label, "session_id" => target.session_id, "name" => source.name, "scope" => source.scope,
         "cmd" => source.cmd, "every_seconds" => source.every_seconds, "why" => source.why, "hint" => source.hint,
         "added_by" => source.added_by, "created_at" => source.created_at, "fetched_at" => snapshot.fetched_at,
         "revision" => snapshot.revision, "summary" => snapshot.summary, "error" => snapshot.error,
-        "muted" => muted, "shadowed" => shadowed, "unread" => unread }.compact
+        "muted" => entry.muted, "shadowed" => entry.shadowed, "unread" => entry.unread }.compact
     end
 
     def print_rows(rows, labels:)

data/lib/samagotchi/engine.rb

@@ -347,6 +347,8 @@ module Samagotchi
       # A plugin tool's row refs resolve against the session's folder, as
       # answer refs do (AnswerRefs), not the process's.
       @kernel.session_cwd = -> { @session&.working_directory }
+      # forget_outputs refuses what the user pinned in the working set.
+      @kernel.working_set_pins = -> { @session&.working_set_pins || [] }
       # A cut tool output is saved whole in the session's folder.
       @kernel.session_dir = -> { @session&.id && Session.session_dir(@session.id, state_dir: session_state_dir) }
       @kernel.guardrail_gate = @guardrail_wiring.gate
@@ -2943,7 +2945,8 @@ module Samagotchi
     end
 
     # The working set (WorkingSet) as the model has it, as a
-    # :working_set_updated event ({items:, at:}): at each request (the
+    # :working_set_updated event ({items:, at:}, adds: while the user's
+    # adds are pending): at each request (the
     # stream handler's :generation_started, from the running turn's
     # conversation) and at turn end (#end_turn, from the session's kept
     # messages). Only when it differs from the last one emitted for this
@@ -2958,18 +2961,19 @@ module Samagotchi
     def emit_working_set(on_event, session, conversation)
       return unless session && conversation
 
-      snapshot = WorkingSet.build(conversation, cwd: session.working_directory, strategy: working_set_strategy)
+      snapshot = WorkingSet.build(conversation, cwd: session.working_directory, strategy: working_set_strategy,
+                                  pins: session.working_set_pins)
 
-      items = snapshot.items.map(&:to_h)
+      shown = snapshot.to_h.except(:at)
       last = @working_set_emitted
-      if items.empty?
-        return unless last && last[0] == session.id && !last[1].empty?
-      elsif last == [session.id, items]
+      if snapshot.empty?
+        return unless last && last[0] == session.id && last[1] != { items: [] }
+      elsif last == [session.id, shown]
         return
       end
 
-      @working_set_emitted = [session.id, items]
-      event = { type: :working_set_updated, items: items, at: snapshot.at }
+      @working_set_emitted = [session.id, shown]
+      event = { type: :working_set_updated, **shown, at: snapshot.at }
       on_event ? emit_event(on_event, event) : announce_or_hold(event)
     rescue StandardError => e
       Log.warn(:turn, "working_set_failed", error: e.class.name, msg: e.message.to_s[0, 200])

data/lib/samagotchi/idle_recap.rb

@@ -550,10 +550,16 @@ module Samagotchi
       @client
     end
 
+    # The summarize thread: its recap, or nil when it failed. A failure of
+    # any kind (a LoadError, a stack overflow too) ends it quietly, logged:
+    # no recap this time, and no dead thread's trace on the worker's
+    # stderr. A real exit or interrupt goes on as raised.
     def spawn_summarize(client, prompt)
       Thread.new do
         client.summarize(prompt, session_id: @session_id.call, on_usage: @on_usage)
-      rescue StandardError => e
+      rescue SystemExit, SignalException
+        raise
+      rescue Exception => e # rubocop:disable Lint/RescueException -- a recap's failure, whatever it is, is no recap
         # No recap this time (the next idle window tries again); say why.
         Log.exception(:recap, "summarize_failed", e)
         nil

data/lib/samagotchi/kernel_loop.rb

@@ -30,6 +30,7 @@ require_relative "tool_ids"
 require_relative "llm_context_view"
 require_relative "llm_context_apply"
 require_relative "llm_context_forget"
+require_relative "working_set"
 require_relative "llm_context_notice"
 require_relative "answer_display"
 require_relative "llm/model_result"
@@ -178,6 +179,10 @@ module Samagotchi
     # a plugin tool's row refs resolve their files against (ToolRunner,
     # RowRefs); the Engine sets it. nil: the process's own (Dir.pwd).
     attr_accessor :session_cwd
+    # The session's working-set pins (a callable → Array<WorkingSetPin>),
+    # which forget_outputs refuses (LLMContextForget); the Engine sets it.
+    # nil: none.
+    attr_accessor :working_set_pins
     # The session's folder (a callable → String or nil), where ToolRunner
     # saves a cut output whole (ToolOutputFiles); the Engine sets it. nil:
     # none (a bare kernel), the cut says the output wasn't saved.
@@ -945,9 +950,16 @@ module Samagotchi
       end
 
       apply = -> { apply_llm_context!(turn.conversation, llm_context, context: turn.context, emit: turn.emit) }
-      LLMContextForget.call(turn, call, llm_context: llm_context, apply: apply)
+      LLMContextForget.call(turn, call, llm_context: llm_context, apply: apply, pinned: method(:pinned_ids))
     end
 
+    # The ids of +conversation+'s outputs the session's pins hold.
+    def pinned_ids(conversation)
+      pins = Array(@working_set_pins&.call)
+      WorkingSet.pinned_ids(conversation, pins: pins, cwd: @session_cwd&.call)
+    end
+    private :pinned_ids
+
     # Before each request of both loops (+moment+ :request; the warm-up
     # too, on its own copy, as the next turn's first request) and at the
     # end of a turn the model answered (:turn_end): the strategy's layers

data/lib/samagotchi/launch_mode.rb

@@ -11,6 +11,14 @@ module Samagotchi
     # 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)"
+    # A worker spawned or resumed for an attach whose Bridge never came (%s:
+    # the session id).
+    BRIDGE_LATE = "the worker for session %s did not start its Bridge in time"
 
     module_function
 
@@ -30,5 +38,19 @@ module Samagotchi
 
       [:attached, nil]
     end
+
+    # Why an attached run's flags don't go together, or nil when they do.
+    # @param options [Hash] bin/chi's parsed options
+    # @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"
+      elsif conflict
+        "--attach/--shared can't be combined with #{conflict.last}"
+      end
+    end
   end
 end

data/lib/samagotchi/llm_context_forget.rb

@@ -36,7 +36,10 @@ module Samagotchi
   #   to free anything (SMALL), an output already stubbed or forgotten, an
   #   id nothing in context has;
   # - an output the user dropped (WorkingSetSteer): neither forgotten nor
-  #   restored by the model, in WorkingSetSteer::Refused's words.
+  #   restored by the model, in WorkingSetSteer::Refused's words;
+  # - an output of an item the user pinned (+pinned+: WorkingSet.pinned_ids
+  #   of the session's pins), in WorkingSetSteer::Refused's words too (a
+  #   restore of one is fine: it brings the output back).
   # A read is never restored: reading the file again is its restore, and
   # the file may have changed.
   module LLMContextForget
@@ -74,8 +77,10 @@ module Samagotchi
     # call (both loops add the model's entry before its calls run).
     # @param apply [#call] → LLMContextApply::Outcome: the apply rule at a
     #   request, on the turn's conversation (KernelLoop#apply_llm_context!)
+    # @param pinned [#call, nil] conversation → the ids the user's pins
+    #   hold (WorkingSet.pinned_ids), asked only when a forget is asked
     # @return [String] the tool result
-    def call(turn, call, llm_context:, apply:, root: Dir.pwd, now: Time.now.utc.iso8601(3))
+    def call(turn, call, llm_context:, apply:, root: Dir.pwd, pinned: nil, now: Time.now.utc.iso8601(3))
       request = Tools::ForgetOutputs.parse(call)
       conversation = turn.conversation
       return restore(turn, request.restore, llm_context) if request.restore? && request.ids.empty?
@@ -85,7 +90,8 @@ module Samagotchi
                "what's ruled out, NEXT), since it is all that stays of them"
       end
 
-      forgotten, refused = forget(conversation, request, llm_context.protect_steps, root, now)
+      pinned_ids = pinned ? pinned.call(conversation) : Set.new
+      forgotten, refused = forget(conversation, request, llm_context.protect_steps, root, now, pinned_ids)
       lines = if forgotten.empty?
                 ["nothing forgotten"]
               else
@@ -99,7 +105,7 @@ module Samagotchi
     # Saves a staged forget on each output +request+ names that may go.
     # @return [Array(Array<String>, Hash{String => String})] the ids
     #   forgotten, and the refused ones with why
-    def forget(conversation, request, protect_steps, root, now)
+    def forget(conversation, request, protect_steps, root, now, pinned_ids)
       outputs = outputs(conversation)
       last = LLMContextStale.step_count(conversation)
       # The steps before the call's own: protected_ids counts that one too.
@@ -107,7 +113,7 @@ module Samagotchi
                                                                root: root)
       refused = {}
       forgotten = request.ids.select do |id|
-        why = refusal(conversation, outputs[id], request.keep[id], last, protect_steps, kept_reads)
+        why = refusal(conversation, outputs[id], request.keep[id], last, protect_steps, kept_reads, pinned_ids)
         refused[id] = why if why
         why.nil?
       end
@@ -124,11 +130,12 @@ module Samagotchi
     # Why +output+ can't go (a String for the result), nil when it can.
     # +last+: the call's own step; the protect_steps steps before it are
     # the model's latest outputs.
-    def refusal(conversation, output, keep, last, protect_steps, kept_reads)
+    def refusal(conversation, output, keep, last, protect_steps, kept_reads, pinned_ids)
       return "no output with that id in context (ids look like t42)" unless output
 
       held = LLMContextEdit.on(conversation[output.index])[output.ref.id]
       return WorkingSetSteer::Refused.text(:dropped) if held&.kind == LLMContextEdit::DROP
+      return WorkingSetSteer::Refused.text(:pinned_by_user) if pinned_ids.include?(output.ref.id)
       return "already forgotten or stubbed" if held
       if protect_steps.positive? && output.step >= last - protect_steps
         return "from your last #{protect_steps} step#{"s" unless protect_steps == 1}; you may still need it, forget it later"

data/lib/samagotchi/note_command.rb

@@ -6,6 +6,7 @@ require_relative "note_delivery"
 require_relative "session_manager"
 require_relative "cli/command"
 require_relative "cli/flags"
+require_relative "session_access/local"
 
 module Samagotchi
   # `chi note`: push text into sessions as a context note (background the
@@ -33,12 +34,15 @@ module Samagotchi
     end
 
     # @param argv [Array<String>] the arguments after "note"
-    def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, state_dir: nil)
+    # @param access [SessionAccess::Local, nil] where the sessions are;
+    #   default this machine's, in +state_dir+
+    def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, state_dir: nil, access: nil)
       @argv = argv.dup
       @stdin = stdin
       @stdout = stdout
       @stderr = stderr
       @state_dir = state_dir || Session.default_state_dir
+      @access = access || SessionAccess::Local.new(state_dir: @state_dir)
     end
 
     # @return [Integer] exit status: 0 all queued, 1 any refused or failed,
@@ -93,8 +97,7 @@ module Samagotchi
 
     # --all: every live session. @return [Integer] exit status
     def deliver_to_live(text, source)
-      ids = SessionManager.session_summaries(live: true, include_tests: Session.test_session_env?,
-                                             state_dir: @state_dir).map { |s| s[:id] }
+      ids = @access.summaries(live: true, include_tests: Session.test_session_env?).map { |s| s[:id] }
       if ids.empty?
         error_line("chi note: no live sessions (chi sessions list --live --scope=all)")
         return 1
@@ -104,9 +107,7 @@ module Samagotchi
     end
 
     def resolve(given)
-      id = Session.resolve_id(given, state_dir: @state_dir)
-      Session.load(id, state_dir: @state_dir)
-      id
+      @access.resolve(given)
     rescue ArgumentError => e
       message = e.is_a?(Session::AmbiguousId) ? e.message : "no session #{given}"
       error_line("chi note: #{message}")
@@ -115,7 +116,7 @@ module Samagotchi
 
     # @return [Boolean] whether the note was queued
     def deliver(id, text, source)
-      result = NoteDelivery.deliver(id, text: text, source: source, state_dir: @state_dir)
+      result = @access.note(id, text: text, source: source)
       @stdout.puts("#{id[0, 8]}  #{outcome(result)}")
       result.delivered?
     end