samagotchi 0.160.0 → 0.161.0

data/lib/samagotchi/memory_bundle/uninstaller.rb

@@ -44,14 +44,24 @@ module Samagotchi
       def run
         provenance = Provenance.new(name: @name)
         bundle = provenance.record
-        raise UninstallError.not_installed(@name) unless bundle
-
-        # The scope from the flag, else the record's
-        target_scope = @scope.to_s.strip.empty? ? bundle.effective_scope : @scope
-        target_dir = MemoryPaths.scope_dir(target_scope) or raise UninstallError, "invalid scope: #{target_scope}"
+        if bundle
+          target_scope = @scope.to_s.strip.empty? ? bundle.effective_scope : @scope
+          target_dir = MemoryPaths.scope_dir(target_scope) or raise UninstallError, "invalid scope: #{target_scope}"
+        else
+          target_scope = @scope.to_s.strip.empty? ? provenance.pending_scope : @scope
+          pending_target = provenance.pending_target_dir
+          raise UninstallError.not_installed(@name) unless target_scope && pending_target
+
+          target_dir = MemoryPaths.scope_dir(target_scope) or raise UninstallError, "invalid scope: #{target_scope}"
+          if @scope.to_s.strip.empty?
+            target_dir = pending_target
+          elsif File.expand_path(target_dir) != pending_target
+            raise UninstallError.not_installed(@name)
+          end
+        end
 
-        files = bundle.files
-        hooks = bundle.hooks
+        files = provenance.files_with_pending(bundle, target_dir: target_dir)
+        hooks = bundle&.hooks || {}
         if files.empty? && hooks.empty?
           # No file list, just remove provenance (rules, a plugin and scripts
           # live there too)
@@ -98,7 +108,7 @@ module Samagotchi
 
             @warnings << "Kept #{file_key_str}: bundle #{others.join(", ")} has it too"
             unless ModelOverlay.bundle_overlay?(file_key_str, bundle_files: files.keys.map(&:to_s), target_dir: target_dir)
-              retag(target_scope, target_path, file_key_str, others.first)
+              retag(target_scope, target_path, file_key_str, others.first, target_dir: target_dir)
             end
             next
           end
@@ -108,8 +118,8 @@ module Samagotchi
           end
           # Remove index line (not fatal: a warning says so)
           begin
-            IndexUpdater.remove_index(target_scope, file_key_str.delete_suffix(".md"))
-            IndexUpdater.remove_index(target_scope, file_key_str) # legacy "name.md" line
+            IndexUpdater.remove_index(target_scope, file_key_str.delete_suffix(".md"), target_dir: target_dir)
+            IndexUpdater.remove_index(target_scope, file_key_str, target_dir: target_dir) # legacy "name.md" line
           rescue StandardError => e
             @warnings << "index.md: line for #{file_key_str.delete_suffix(".md")} not removed (#{e.message})"
           end
@@ -151,6 +161,8 @@ module Samagotchi
       # scripts by their source-less AssetState and ASSET_UNINSTALL's
       # save_first; an older chi's hooks/ by Trash#copy_edits.
       def save_edits(provenance, bundle)
+        return unless bundle
+
         @trash.copy_edits(provenance.hooks_dir, "hooks", bundle.hooks.transform_values(&:sha256))
         { rule: [provenance.guardrails_dir, bundle.guardrails], plugin: [provenance.plugin_dir, bundle.plugin_shas],
           script: [provenance.scripts_dir, bundle.scripts] }.each do |kind_of_file, (dir, recorded)|
@@ -161,9 +173,11 @@ module Samagotchi
       end
 
       # A kept shared file's index line names the bundle that still has it
-      # (a model overlay has none: the caller skips it).
-      def retag(scope, path, file_key, bundle)
-        IndexUpdater.update_index(scope, file_key.delete_suffix(".md"), File.size(path), source: bundle)
+      # (a model overlay has none: the caller skips it). +target_dir+ is the
+      # folder the file lives in, which for an install interrupted before its
+      # record is the journal's target dir, not the current folder's.
+      def retag(scope, path, file_key, bundle, target_dir:)
+        IndexUpdater.update_index(scope, file_key.delete_suffix(".md"), File.size(path), source: bundle, target_dir: target_dir)
       rescue StandardError => e
         @warnings << "index.md: line for #{file_key.delete_suffix(".md")} not updated (#{e.message})"
       end

data/lib/samagotchi/memory_orphans.rb

@@ -19,12 +19,28 @@ module Samagotchi
   # 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
@@ -67,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)
@@ -82,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/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/project_init.rb

@@ -183,9 +183,9 @@ module Samagotchi
       list.each { |place| lines.concat(move_folder(place.path(path_key), place.path(id))) }
       write_id(root, id)
       if orphans
-        lines << "memories from an earlier path: #{orphans.candidates.map { |c| Paths.tilde(c) }.join(", ")} (this " \
-                 "folder's name with another path's hash; if they are this project's, move their files into " \
-                 "#{Paths.tilde(list.first.path(id))})"
+        keys = orphans.candidates.map { |candidate| "#{Paths.tilde(candidate)} (#{MemoryOrphans.key_note(candidate)})" }
+        lines << "memories with this folder's name under another key: #{keys.join(", ")}; if they are this " \
+                 "project's, move their files into #{Paths.tilde(list.first.path(id))}"
       end
       Outcome.new(kind: :adopted, reason: nil, root: root, top: root, nested_in: nil, message: lines.join("\n"), id: id)
     end

data/lib/samagotchi/review_start.rb

@@ -80,7 +80,8 @@ module Samagotchi
       setup = setup.with(toolkit_origin: "chosen")
       SessionManager.spawn_session(prompt: nil, preview: preview(subjects), working_directory: dir, model_name: model,
                                    setup: setup, review: SessionReview.new(subjects: subjects),
-                                   note: note(subjects: subjects), note_source: NOTE_SOURCE, state_dir: state_dir)
+                                   note: note(subjects: subjects), note_source: NOTE_SOURCE, state_dir: state_dir,
+                                   client_id: nil)
     end
 
     # A review fork of +from+ (an id, a prefix, or last:<id>): a new session
@@ -106,9 +107,10 @@ module Samagotchi
       recap = RecapStore.read(Session.session_dir(source.id, state_dir: sd))
       session = SessionManager.spawn_session(
         prompt: nil, preview: preview(subjects, source: source), working_directory: dir, model_name: choice.model,
-        setup: SessionSetup.of(source).with(toolkit_origin: "chosen"),
+        setup: SessionSetup.of(source).with(preloaded_memory_names: [], toolkit_origin: "chosen"),
         review: SessionReview.new(subjects: subjects, from: source.id),
-        note: note(subjects: subjects, source: source, recap: recap, seed: seed), note_source: NOTE_SOURCE, state_dir: sd
+        note: note(subjects: subjects, source: source, recap: recap, seed: seed), note_source: NOTE_SOURCE,
+        state_dir: sd, client_id: nil
       )
       warnings = [choice.warning, session.model_warning].compact
       session.model_warning = warnings.join("; ") unless warnings.empty?

data/lib/samagotchi/schedule_command.rb

@@ -137,6 +137,7 @@ module Samagotchi
       end
 
       @stdout.puts("#{entry.id} added: #{entry.target_words} · #{entry.recurrence_words} · next #{clock(entry.next_due)}")
+      print_tick_warning
       CLI::Exit::OK
     end
 
@@ -144,13 +145,16 @@ module Samagotchi
       entries = @schedules.entries(include_disabled: @opts[:include_disabled] ? true : false)
       if @opts[:format] == "json"
         @stdout.puts(JSON.pretty_generate(entries.map { |entry| entry_line_json(entry) }))
+        print_tick_warning(@stderr)
         return CLI::Exit::OK
       end
       if entries.empty?
         @stdout.puts("no schedules")
+        print_tick_warning
         return CLI::Exit::OK
       end
       entries.each { |entry| @stdout.puts(entry_line(entry)) }
+      print_tick_warning
       CLI::Exit::OK
     end
 
@@ -194,6 +198,8 @@ module Samagotchi
         @stdout.puts("#{outcome.id}  #{word}  #{outcome.detail}")
       end
       CLI::Exit::OK
+    rescue Schedules::Corrupt => e
+      failed("#{e.message.lines.first.chomp}; left as is")
     end
 
     def act
@@ -231,6 +237,7 @@ module Samagotchi
       note = ""
       note += " skips #{entry.skips} of #{entry.max_skips} (#{skip_window(entry)})" if entry.skips.positive?
       note += " disabled after #{entry.failures} failures" unless entry.enabled
+      note += " last: #{entry.last_result}" if entry.last_result
       "#{entry.id}  #{entry.mode}  #{entry.recurrence_words}  #{clock(entry.next_due)}  #{entry.head[0, 8]}#{note}"
     end
 
@@ -248,5 +255,10 @@ module Samagotchi
         "skip_window" => skip_window(entry)
       )
     end
+
+    def print_tick_warning(stream = @stdout)
+      warning = @schedules.tick_warning
+      stream.puts(warning) if warning
+    end
   end
 end