samagotchi 0.159.0 → 0.161.0

data/lib/samagotchi/memory_orphans.rb

@@ -6,19 +6,41 @@ module Samagotchi
   # A project memory folder left behind by a move: memories copied to a
   # machine (or a path) where the project root differs, so its key
   # (MemoryPaths.project_key: basename + MD5 of the root) differs too, and
-  # chi finds no project memories without a word about why.
+  # chi finds no project memories without a word about why. A marked
+  # project with an id is keyed by the id (`<basename>-<8 hex>`, which the
+  # pattern never takes for a path key): it is asked about only while its
+  # id folder holds no *.md, like any other (memories moved before it had
+  # an id). An id folder is a candidate itself for a project keyed by path
+  # with the same basename: a marked folder that `git init` made a
+  # repository.
   #
   # Pure: one listing of the projects dir, no git subprocess. Said at
   # session start (Engine#announce_load_events!, label "memory") and under a
   # memory_read miss (Tools::MemoryRead); never in the system prompt.
   module MemoryOrphans
     # @!attribute computed [String] the folder chi reads (this project's key)
-    # @!attribute candidates [Array<String>] same-basename folders, other hashes
+    # @!attribute candidates [Array<String>] same-basename folders keyed by
+    #   another path's hash or by a project id
     # @!attribute computed_exists [Boolean] whether +computed+ is a folder (empty of memories)
     Found = Data.define(:computed, :candidates, :computed_exists)
 
+    # A project keyed by its path is <name>_<8 hex>; a marked project's folder is
+    # its id, <name>-<8 hex>.
+    PATH_HASH = /_\h{8}\z/
+
     module_function
 
+    # A candidate folder's key, in words: an earlier path's hash, or a chi project
+    # id (a folder marked by `chi project init`, left behind when `git init` makes
+    # it a repository). +candidate+ is a folder path.
+    def key_note(candidate)
+      hash_keyed?(candidate) ? "another path's hash" : "project id #{File.basename(candidate)}"
+    end
+
+    # Internal: is this candidate keyed by its path rather than by a project id?
+    def hash_keyed?(candidate) = File.basename(candidate).match?(PATH_HASH)
+    private_class_method :hash_keyed?
+
     # The orphan candidates for +cwd+'s project, or nil: only inside a
     # project, a git repository or a marked folder (outside both the root is
     # cwd, and every src/ or tmp/ would match), and only while the computed folder holds no *.md (a
@@ -33,10 +55,14 @@ module Samagotchi
       return nil if File.directory?(computed) && Dir.children(computed).any? { |name| name.end_with?(".md") }
 
       key = File.basename(computed)
-      # The root's basename, never a split of a key on "_" (a basename may hold one).
-      pattern = /\A#{Regexp.escape(File.basename(MemoryPaths.project_root(cwd)))}_\h{8}\z/
+      # The root's basename, never a split of a key on "_" (a basename may hold one): another path's key
+      # (<basename>_<8 hex>), or a marked project's id folder (<basename>-<8 hex>, ProjectId) a `git init`
+      # in the marked folder (git wins: keyed by its path again) left behind.
+      pattern = /\A#{Regexp.escape(File.basename(MemoryPaths.project_root(cwd)))}[_-]\h{8}\z/
       names = Dir.children(projects).select { |name| name != key && name.match?(pattern) }
-      candidates = names.sort.map { |name| File.join(projects, name) }.select { |path| File.directory?(path) }
+      # A link is an adopted project's old name (ProjectInit.adopt), never an orphan.
+      candidates = names.sort.map { |name| File.join(projects, name) }
+                        .select { |path| File.directory?(path) && !File.symlink?(path) }
       return nil if candidates.empty?
 
       Found.new(computed: computed, candidates: candidates, computed_exists: File.directory?(computed))
@@ -57,9 +83,18 @@ module Samagotchi
       found = find(env: env, cwd: cwd)
       return unless found
 
-      name = File.basename(found.computed).sub(/_\h{8}\z/, "")
-      "a folder with the same project name (#{name}) exists with another path's hash; ask the user whether its " \
-        "memories belong to this project before using them."
+      # The project's name is its root folder's basename: splitting the key would
+      # print a project id as the name when this project is keyed by one.
+      name = File.basename(MemoryPaths.project_root(cwd))
+      if found.candidates.size == 1
+        candidate = found.candidates.first
+        "a folder with the same project name (#{name}) exists under #{key_note(candidate)}; ask the user " \
+          "whether its memories belong to this project before using them."
+      else
+        list = found.candidates.map { |candidate| "#{candidate} (#{key_note(candidate)})" }.join(", ")
+        "folders with the same project name (#{name}) exist under other keys (#{list}); ask the user whether their " \
+          "memories belong to this project before using them."
+      end
     end
 
     def text(found)
@@ -72,13 +107,19 @@ module Samagotchi
               else
                 "`mv #{candidate} #{computed}`"
               end
-        "#{lead}, but #{candidate} has the same project name with another path's hash (memories moved from " \
-          "another machine or path?). A name match can't prove it's this project; if it is, #{fix}."
+        why = if hash_keyed?(candidate)
+                "has the same project name with #{key_note(candidate)} (memories moved from another machine or " \
+                  "path?)"
+              else
+                "has the same project name keyed by a project id (#{File.basename(candidate)}): the folder " \
+                "chi project init marked, keyed by its id instead of its path"
+              end
+        "#{lead}, but #{candidate} #{why}. A name match can't prove it's this project; if it is, #{fix}."
       else
         fix = found.computed_exists ? "move its files into #{computed}" : "`mv <that folder> #{computed}`"
-        "#{lead}, but these have the same project name with another path's hash (memories moved from another " \
-          "machine or path?): #{found.candidates.join(", ")}. A name match can't prove one is this project; if one " \
-          "is, #{fix}."
+        list = found.candidates.map { |candidate| "#{candidate} (#{key_note(candidate)})" }.join(", ")
+        "#{lead}, but these have the same project name (memories moved from another machine or path?): " \
+          "#{list}. A name match can't prove one is this project; if one is, #{fix}."
       end
     end
   end

data/lib/samagotchi/memory_paths.rb

@@ -3,6 +3,7 @@
 require "digest"
 require_relative "config"
 require_relative "guardrails/path_resolve"
+require_relative "project_id"
 
 module Samagotchi
   # Where memories live: <config dir>/memories, i.e. $XDG_CONFIG_HOME/samagotchi/memories
@@ -23,8 +24,12 @@ module Samagotchi
     # :none; +root+ is what memories are keyed on (#project_root: git's
     # common-dir checkout, the marked folder's realpath, or the folder
     # itself); +top+ is the folder a session reads its AGENTS.md chain from
-    # (the work tree's top, the marked root; nil for :none).
-    ProjectLookup = Data.define(:kind, :root, :top) do
+    # (the work tree's top, the marked root; nil for :none); +id+ is the
+    # marker's id (ProjectId), set only for kind :marker with a valid one
+    # (a git repository, and a marker #lookup ignores, never give one).
+    ProjectLookup = Data.define(:kind, :root, :top, :id) do
+      def initialize(kind:, root:, top:, id: nil) = super
+
       def project? = kind != :none
       def git? = kind == :git
       def marker? = kind == :marker
@@ -47,7 +52,7 @@ module Samagotchi
       return ProjectLookup.new(kind: :git, root: git_root(dot_git), top: File.dirname(dot_git)) if dot_git
 
       marked = nearest_marker(cwd, home: home)
-      return ProjectLookup.new(kind: :marker, root: marked, top: marked) if marked
+      return ProjectLookup.new(kind: :marker, root: marked, top: marked, id: marker_id(marked)) if marked
 
       ProjectLookup.new(kind: :none, root: cwd, top: nil)
     end
@@ -73,12 +78,30 @@ module Samagotchi
       File.join(system_dir(env: env), "projects")
     end
 
-    # One folder per project root: basename + 8 hex chars of MD5(full root path).
-    def project_key(cwd = Dir.pwd) = key_for_root(project_root(cwd))
+    # One folder per project: a marked project's id (ProjectId), else its
+    # root's path key (#key_for_root).
+    def project_key(cwd = Dir.pwd)
+      found = lookup(cwd)
+      key_for(root: found.root, id: found.id)
+    end
+
+    # The key of a project already resolved: +id+ (a ProjectLookup's, a
+    # session's project_id) when there is one, else +root+'s path key. Every
+    # caller holding a root keys here, with the id that came with it.
+    def key_for(root:, id:) = id || key_for_root(root)
 
-    # #project_key for a root already resolved (a session's project_root).
+    # The path key: basename + 8 hex chars of MD5(full root path). Pure: it
+    # reads no file (#key_for adds the id).
     def key_for_root(root) = "#{File.basename(root)}_#{Digest::MD5.hexdigest(root)[0..7]}"
 
+    # The id in the marker at +root+, or nil (none, or not a valid one: one
+    # debug line says why).
+    def marker_id(root)
+      read = ProjectId.read(root)
+      ProjectId.log_problem(root, read)
+      read.id
+    end
+
     # The project root (#lookup): in a repository, its common git directory
     # identifies the project; every linked worktree shares it. Returns the
     # checkout holding it when it is named .git, otherwise the git dir itself

data/lib/samagotchi/memory_usage.rb

@@ -124,7 +124,11 @@ module Samagotchi
       # The project the report is for, as MemoryPaths keys it (a worktree
       # resolves to its repository's root; both spellings of a path, /var and
       # /private/var, mean the same project).
-      @root = expand(MemoryPaths.project_root(File.expand_path(root.to_s)))
+      found = MemoryPaths.lookup(File.expand_path(root.to_s))
+      @root = expand(found.root)
+      # A marked project's id: its sessions from before a move (another
+      # stored root, the same id) are its sessions too.
+      @project_id = found.id
       @env = env
       @chars_per_token = chars_per_token.positive? ? chars_per_token.to_f : 4.0
       @warn_limit = warn_limit.to_i
@@ -331,23 +335,30 @@ module Samagotchi
       File.expand_path(dir)
     end
 
-    # The project a session belongs to: the root its file stores, or (a file
-    # from before the field, or a folder in no repository) the root of the
-    # folder it works in.
-    def session_project_root(session)
-      root = session.project_root ||
-             (session.working_directory.to_s.empty? ? nil : MemoryPaths.project_root(File.expand_path(session.working_directory.to_s)))
-      root && expand(root)
+    # The project a session belongs to, [root, id]: the root (and id) its
+    # file stores, or (a file from before the field, or a folder in no
+    # repository) the lookup of the folder it works in; [nil, nil] for none.
+    def session_project(session)
+      if session.project_root
+        [expand(session.project_root), session.project_id]
+      elsif !session.working_directory.to_s.empty?
+        found = MemoryPaths.lookup(File.expand_path(session.working_directory.to_s))
+        [expand(found.root), found.id]
+      else
+        [nil, nil]
+      end
     end
 
     def project_dir_of(session)
-      root = session_project_root(session)
-      root ? File.join(MemoryPaths.projects_dir(env: @env), MemoryPaths.key_for_root(root)) : nil
+      root, id = session_project(session)
+      root ? File.join(MemoryPaths.projects_dir(env: @env), MemoryPaths.key_for(root: root, id: id)) : nil
     end
 
-    # A session of this folder's project (worktrees of one repository share it).
+    # A session of this folder's project (worktrees of one repository share
+    # it; a marked project's sessions from before a move share its id).
     def project_session?(session)
-      session_project_root(session) == @root
+      root, id = session_project(session)
+      root == @root || (!@project_id.nil? && id == @project_id)
     end
 
     # "system/delegated" is the memory named delegated.

data/lib/samagotchi/note_command.rb

@@ -20,6 +20,7 @@ module Samagotchi
       Usage: chi note [--source NAME] [-m TEXT] (ID|PREFIX)... | --all
         Adds TEXT (or stdin) to each session as a context note: background
         the model sees on its next turn, not a prompt. It starts no turn.
+        A session that was continued: the newest link of its chain gets it.
         --source NAME  where it came from, shown to the model (default: cli)
         -m TEXT        the note; without it, stdin is read
         --all          every session a worker runs now, in every project
@@ -116,10 +117,17 @@ module Samagotchi
     # @return [Boolean] whether the note was queued
     def deliver(id, text, source)
       result = @access.note(id, text: text, source: source)
-      @stdout.puts("#{id[0, 8]}  #{outcome(result)}")
+      @stdout.puts("#{where(id, result)}  #{outcome(result)}")
       result.delivered?
     end
 
+    # The id, or for a session that was continued the link that took it.
+    def where(id, result)
+      return id[0, 8] unless result.continued?
+
+      "#{id[0, 8]} → #{result.id[0, 8]} (continued)"
+    end
+
     def outcome(result)
       case result.status
       when :refused then "refused: #{result.refusal}"

data/lib/samagotchi/note_delivery.rb

@@ -5,31 +5,35 @@ require_relative "owner_lock"
 require_relative "session_inbox"
 
 module Samagotchi
-  # Loaded on first use: this autoload keeps SessionManager and its ~80
-  # files unloaded until the delegate/session path needs them.
-  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
-  # 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).
+  # `chi note`, the agent's send_note, `chi broadcast` and /objectives: a
+  # note delivery (SessionInbox.deliver :note). A note to a link that was
+  # continued goes to its chain's newest link (SessionInbox::Head); 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 (a note
+  # never starts one). Callers word the outcome (#refusal for a refused one).
   module NoteDelivery
     # 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 one-turn chi run
-    #   owns it, or it is a chi scratch session: +scratch+)
+    # @!attribute id [String] the session that has the note: +asked+, or
+    #   the newest link of its chain
+    # @!attribute status [Symbol] :queued (a worker runs it or is starting),
+    #   :waits (no 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, :scratch) do
-      def initialize(id:, status:, queued:, scratch: false) = super
+    # @!attribute asked [String] the id the caller named (+id+ by default)
+    Result = Data.define(:id, :status, :queued, :scratch, :asked) do
+      def initialize(id:, status:, queued:, scratch: false, asked: nil) = super(id:, status:, queued:, scratch:, asked: asked || id)
 
       def delivered? = status != :refused
 
+      # The note went on to a later link of +asked+'s chain.
+      def continued? = asked != id
+
       # Why a refused note was refused, in its condition's one wording.
       def refusal = scratch ? Session::SCRATCH_REFUSED : ONE_SHOT_REFUSAL
     end
@@ -38,19 +42,25 @@ module Samagotchi
 
     # @param id [String] a full session id (resolved by the caller)
     # @param objectives [Hash, nil] an objectives note's payload
+    # @param pin [Boolean] keep it in +id+, never its chain's newest link
+    #   (an /objectives list is the conversation of +id+'s own)
+    # @param resolved [SessionInbox::Resolved, nil] the link the caller
+    #   resolved already (SessionInbox::Head.resolve(:note, id)): no second walk
     # @return [Result]
     # @raise [SessionInbox::NoteRejected] an empty note or one over 16 KiB
-    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)
-      return Result.new(id: id, status: :queued, queued: 0) if owner
+    # @raise [Session::NotFound] no such session
+    def deliver(id, text:, source:, state_dir:, from_session: nil, from_cwd: nil, objectives: nil, pin: false,
+                resolved: nil)
+      body = SessionInbox.checked_text(text)
+      delivered = SessionInbox.deliver(:note, id, state_dir: state_dir, pin: pin, resolved: resolved) do |at|
+        SessionInbox.write_note(at, text: body, source: source, from_session: from_session, from_cwd: from_cwd,
+                                    objectives: objectives, state_dir: state_dir)
+        false
+      end
+      raise Session::NotFound, id if delivered.wake == :gone
 
-      Result.new(id: id, status: :waits, queued: SessionInbox.find_new_note_files(File.dirname(path, 2)).size)
+      Result.new(id: delivered.id, asked: delivered.asked, status: delivered.status, queued: delivered.queued || 0,
+                 scratch: delivered.refused? && delivered.wake == :scratch)
     end
   end
 end

data/lib/samagotchi/note_move.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+require_relative "archive_store"
+require_relative "context_move"
+require_relative "log"
+require_relative "objectives"
+require_relative "session"
+require_relative "session_chain"
+require_relative "session_inbox"
+
+module Samagotchi
+  # A session chain's notes/ across a continue. The continue moves the
+  # previous link's waiting notes to the new link (.move, the last step
+  # of its before_spawn); a continue that fails gives them back (.give_back);
+  # the new link's worker adopts a note written to the previous link after
+  # the move (.adoption: a writer that resolved the id just before the new
+  # link was saved, or an older chi that knows no chain head). A note keeps
+  # its file name everywhere: its id, and its place in arrival order.
+  #
+  # Objectives lists stay where they are: an /objectives note is its own
+  # session's (pinned), and the continue's Objectives.carry already took the
+  # previous link's newest one into the new link's list.
+  module NoteMove
+    # The notes a continue writes into its new link itself (the chain note,
+    # ChildMove's, the attached context's, the objectives' carry): a failed
+    # continue deletes them with the link.
+    CONTINUE_SOURCES = [SessionChain::NOTE_SOURCE, ContextMove::NOTE_SOURCE, Objectives::SOURCE].freeze
+
+    module_function
+
+    # Moves +from+'s notes into +to+'s notes/, but not its objectives lists
+    # nor the notes a continue into +from+ wrote there (CONTINUE_SOURCES: a
+    # link continued before it ever started holds its own chain note, which
+    # the new link's own replaces). The rename is the claim: one a worker or
+    # another move took meanwhile is skipped. A claimed one
+    # (*.json.processing: an old worker took it and never absorbed it, or
+    # absorbed it and died before the delete) moves too, un-claimed, logged
+    # (notes_moved_claimed): the link is archived, so left there it would be
+    # lost, and a note seen twice beats a lost one.
+    # @return [Array<String>] the file names moved (un-claimed), oldest first
+    def move(from:, to:, state_dir:)
+      files = Dir.glob(File.join(notes_dir(from, state_dir), "*.{json,json.processing}"))
+                 .sort_by { |file| unclaimed_name(file) }
+                 .select { |file| (data = read(file)) && !objectives?(data) && !CONTINUE_SOURCES.include?(data["source"]) }
+      moved = rename(files, notes_dir(to, state_dir))
+      claimed = files.count { |file| file.end_with?(".processing") && moved.include?(unclaimed_name(file)) }
+      Log.info(:worker, "notes_moved_claimed", from: from[0, 8], to: to[0, 8], count: claimed) if claimed.positive?
+      Log.info(:worker, "notes_moved", from: from[0, 8], to: to[0, 8], count: moved.size) unless moved.empty?
+      moved
+    end
+
+    # A failed continue's undo, before its link +from+ is deleted: back to
+    # +to+ go the notes it moved (+moved+) and any other sent to the link
+    # meanwhile, never one the continue wrote itself (CONTINUE_SOURCES).
+    # @return [Array<String>] the file names given back
+    def give_back(from:, to:, moved:, state_dir:)
+      files = unclaimed(notes_dir(from, state_dir)).select do |file|
+        next true if moved.include?(File.basename(file))
+
+        data = read(file)
+        data && !objectives?(data) && !CONTINUE_SOURCES.include?(data["source"])
+      end
+      rename(files, notes_dir(to, state_dir)).tap do |back|
+        Log.info(:worker, "notes_given_back", from: from[0, 8], to: to[0, 8], count: back.size) unless back.empty?
+      end
+    end
+
+    # How far back along the chain a worker adopts (Adoption): the links
+    # continued into it, newest first.
+    ADOPT_MAX_LINKS = 8
+
+    # What a worker for +session+ adopts from the links before it, nil when
+    # there is nothing to adopt from: a first link, a predecessor not
+    # archived (checked first: no listing then), or one whose next link
+    # (SessionChain.next_of) is another. Else one listing walks back: each
+    # archived link whose next link is the one after it, from the newest, up
+    # to ADOPT_MAX_LINKS, stopping at one not archived or gone; each is
+    # adopted from by the creation of the link that continued it.
+    # @param session [Session]
+    # @return [Adoption, nil]
+    def adoption(session, state_dir:)
+      from = session.continues
+      return nil unless Session.valid_id?(from) && archived?(from, state_dir)
+
+      sessions = Session.list(state_dir: state_dir, sort: "created_at", order: "asc", include_archived: true)
+      byid = sessions.to_h { |s| [s.id, s] }
+      nexts = sessions.each_with_object({}) { |s, map| map[s.continues] ||= s.id if s.continues }
+      sources = []
+      child = session
+      while Session.valid_id?(from) && sources.size < ADOPT_MAX_LINKS && sources.none? { |src| src.from == from }
+        since = time_of(child.created_at)
+        break unless since && nexts[from] == child.id && archived?(from, state_dir)
+
+        sources << Source.new(from: from, since: since.to_i)
+        child = byid[from] or break
+        from = child.continues
+      end
+      sources.empty? ? nil : Adoption.new(to: session.id, sources: sources, state_dir: state_dir)
+    end
+
+    # A link adopted from (#adoption) and from when (whole seconds: the
+    # creation of the link that continued it).
+    Source = Data.define(:from, :since)
+
+    # A worker's adoption of the notes the links before it get after their
+    # continue: #call on each pass takes them while each link is archived
+    # (back in the lists, its notes are its own, and the walk stops there).
+    # Only notes from the second the next link was made on (a note's stamp
+    # has whole seconds): older ones are from before the continue (a
+    # continue made before notes moved left them), and would come days late,
+    # out of order with the conversation. They, objectives lists and claimed
+    # ones stay, each logged once.
+    class Adoption
+      def initialize(to:, sources:, state_dir:)
+        @to = to
+        @sources = sources
+        @state_dir = state_dir
+        @to_dir = NoteMove.notes_dir(to, state_dir)
+        @left = Set.new
+      end
+
+      # @return [Array<String>] the file names adopted
+      def call
+        adopted = []
+        @sources.each do |source|
+          break unless NoteMove.archived?(source.from, @state_dir)
+
+          adopted.concat(adopt(source))
+        end
+        adopted
+      end
+
+      private
+
+      def adopt(source)
+        files = NoteMove.unclaimed(NoteMove.notes_dir(source.from, @state_dir)).reject { |file| @left.include?(file) }
+        return [] if files.empty?
+
+        take, leave = files.partition { |file| adoptable?(NoteMove.read(file), source.since) }
+        log_left(source, leave)
+        NoteMove.rename(take, @to_dir).tap do |adopted|
+          Log.info(:worker, "notes_adopted", from: source.from[0, 8], sid: @to[0, 8], count: adopted.size) unless adopted.empty?
+        end
+      end
+
+      def adoptable?(data, since)
+        return false if data.nil? || NoteMove.objectives?(data)
+
+        (time = NoteMove.time_of(data["created_at"])) && time.to_i >= since
+      end
+
+      def log_left(source, files)
+        return if files.empty?
+
+        @left.merge(files)
+        Log.info(:worker, "notes_left_old", from: source.from[0, 8], sid: @to[0, 8], count: files.size)
+      end
+    end
+
+    def archived?(id, state_dir) = ArchiveStore.archived?(Session.session_dir(id, state_dir: state_dir))
+
+    # @return [Time, nil]
+    def time_of(value)
+      Time.iso8601(value.to_s)
+    rescue ArgumentError
+      nil
+    end
+
+    def notes_dir(id, state_dir) = File.join(Session.session_dir(id, state_dir: state_dir), SessionInbox::NOTES_DIR)
+
+    # The unclaimed note files, oldest first.
+    def unclaimed(dir) = Dir.glob(File.join(dir, "*.json")).sort_by { |file| File.basename(file) }
+
+    # @return [Hash, nil] the note file's JSON, nil when it can't be read
+    def read(file)
+      data = JSON.parse(File.read(file))
+      data.is_a?(Hash) ? data : nil
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
+    def objectives?(data) = data.is_a?(Hash) && (data["objectives"].is_a?(Hash) || data["source"] == Objectives::SOURCE)
+
+    # A note file's name without a claim's ".processing".
+    def unclaimed_name(file) = File.basename(file).delete_suffix(".processing")
+
+    # @return [Array<String>] the names renamed into +dir+, un-claimed (one
+    #   taken meanwhile is skipped)
+    def rename(files, dir)
+      return [] if files.empty?
+
+      FileUtils.mkdir_p(dir)
+      files.filter_map do |file|
+        name = unclaimed_name(file)
+        File.rename(file, File.join(dir, name))
+        name
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+  end
+end

data/lib/samagotchi/objectives_command.rb

@@ -97,8 +97,10 @@ module Samagotchi
     end
 
     def deliver(list, session)
+      # Pinned: the list is this session's own, never its chain's newest link's.
       result = NoteDelivery.deliver(session.id, text: list.text, source: Objectives::SOURCE,
-                                                state_dir: @engine.session_state_dir, objectives: list.to_payload)
+                                                state_dir: @engine.session_state_dir, objectives: list.to_payload,
+                                                pin: true)
       return ["refused: #{result.refusal}", :error] unless result.delivered?
 
       @engine.announce_objectives(session)

data/lib/samagotchi/owner_lock.rb

@@ -23,6 +23,8 @@ module Samagotchi
     # web's continueRefusal reads "<short> (why)" out of a refusal.
     TUI_BUSY = "in use by a one-turn chi --non-interactive run or an older chi's terminal"
     DEFAULT_WAIT = 2.0
+    # The kind a deleter holds the lock as while a session's files go.
+    DELETING = "deleting"
     RETRY_INTERVAL = 0.05
     OWNER_READ_ATTEMPTS = 10
     # Seconds .await_release waits past a leaving worker's own budget: its
@@ -33,7 +35,7 @@ module Samagotchi
 
     # Who holds the lock, as .owner reads it from the lock file. Its fields
     # may be nil for a moment right after acquisition.
-    # kind: "worker" or "tui"; pid as written (an Integer). leaving_at (an
+    # kind: "worker", "tui" or "deleting" (Owner#deleting?); pid as written (an Integer). leaving_at (an
     # ISO 8601 time) and leave_wait (seconds): set once a worker is leaving
     # (#mark_leaving), its Bridge closed, the lock held for its last work
     # (the recap on leave) for up to leave_wait.
@@ -45,6 +47,10 @@ module Samagotchi
 
       def worker? = kind == "worker"
 
+      # A deleter removing the session's files (SessionManager's
+      # remove_session_files): no worker, nothing to signal.
+      def deleting? = kind == DELETING
+
       # A worker that closed its Bridge and releases the lock once its
       # last work is done.
       def leaving? = worker? && !leaving_at.nil?

data/lib/samagotchi/plugin/attached_context.rb

@@ -152,7 +152,8 @@ module Samagotchi
         return [] unless id && Session.exist?(id, state_dir: state_dir)
 
         session = Session.load(id, state_dir: state_dir)
-        ContextSources.attached(id, project_root: session.project_root, state_dir: state_dir).map do |attached|
+        ContextSources.attached(id, project_root: session.project_root, project_id: session.project_id,
+                                    state_dir: state_dir).map do |attached|
           snapshot = attached.snapshot
           { name: attached.name, scope: attached.location.scope, why: attached.source.why,
             hint: snapshot.hint || attached.source.hint, fetched_at: snapshot.fetched_at, error: snapshot.error,
@@ -192,6 +193,7 @@ module Samagotchi
 
       def attached?(candidate, session)
         ContextSources.attached(session&.id || @host.session_id.call, project_root: session&.project_root,
+                                                                      project_id: session&.project_id,
                                                                       state_dir: state_dir, shadowed: true)
                       .any? { |a| a.name == candidate.name || (candidate.url && a.source.hint == candidate.url) }
       end

data/lib/samagotchi/plugin/sessions.rb

@@ -71,7 +71,10 @@ module Samagotchi
           prompt: prompt, working_directory: @host.cwd.call || Dir.pwd, model_name: @host.model_name&.call,
           parent_id: parent_id, messages: Array(messages).map { |message| unfrozen(message) }, preview: title,
           images_from: Session.session_dir(parent_id, state_dir: state_dir), state_dir: state_dir,
-          setup: @host.setup&.call || SessionSetup.new, before_spawn: before_spawn
+          setup: @host.setup&.call || SessionSetup.new, before_spawn: before_spawn,
+          # The first prompt is the plugin's, as #send's is: no command of the
+          # owner's (CommandIntake), a ! line refused.
+          client_id: ClientId::PLUGIN
         )
         child.id
       rescue *REFUSED => e