samagotchi 0.159.0 → 0.161.0

data/lib/samagotchi/send_command.rb

@@ -673,7 +673,7 @@ module Samagotchi
         return false
       end
       unless result.accepted?
-        @info.puts("#{session.id}  #{refused_word(result)}: #{result.detail || "could not queue it"}")
+        @info.puts("#{session.id}  #{result.refusal_text}")
         return false
       end
 
@@ -685,19 +685,6 @@ module Samagotchi
 
     SENT_COMMAND = "sent as a session command"
 
-    # A remote's refusals of what this machine checks before sending (a
-    # parent's /continue yes, a loosening /parent-answers, images to a
-    # model that can't see them): its turn route's error codes.
-    REMOTE_REFUSALS = %w[parent_answers_refused parent_continue_refused no_vision].freeze
-
-    # How a delivery that didn't go in reads: refused (a worker older than
-    # queueing would steer it; a remote refused it as chi send refuses it
-    # here) or failed.
-    def refused_word(result)
-      refused = result.error == Delivery::QUEUE_UNAVAILABLE["error"] || REMOTE_REFUSALS.include?(result.error)
-      refused ? "refused" : "failed"
-    end
-
     # chi send's client id, or chi answer's for a parent agent's /continue
     # yes (the worker holds that to its guardrails.parent_answers).
     def client_id_for(prompt) = ParentGate.parent_continue?(prompt) ? ClientId::CLI_ANSWER : CLIENT_ID
@@ -773,7 +760,7 @@ module Samagotchi
                  end
       result = @access.deliver_turn(id, prompt: prompt, client_id: client_id_for(prompt), images: refs, delivery: delivery)
       unless result.accepted?
-        @info.puts("#{short}  #{refused_word(result)}: #{result.detail || "could not queue it"}")
+        @info.puts("#{short}  #{result.refusal_text}")
         return false
       end
 

data/lib/samagotchi/session.rb

@@ -5,6 +5,7 @@ require "json"
 require "securerandom"
 require "time"
 require_relative "atomic_file"
+require_relative "log"
 require_relative "context_note"
 require_relative "interrupted_turn"
 require_relative "last_turn"
@@ -166,6 +167,11 @@ module Samagotchi
       # deleted folder no longer leads to its repository. nil outside a repo,
       # and in files written before the field existed (see #project_root).
       SessionField.plain("project_root", nil),
+      # The project's id (ProjectId: a marked project's `id:`), saved beside
+      # project_root at creation, else nil: its memories and project context
+      # sources are keyed by it (MemoryPaths.key_for), so a session resumed
+      # after its folder moved finds them under the id, not its dead path.
+      SessionField.plain("project_id", nil, optional: true),
       # Memories the session was started with (--memory) and memories hidden
       # from it (--mute): the worker rebuilds the same prompt on a respawn.
       # Names as given; the engine normalizes them.
@@ -271,6 +277,14 @@ module Samagotchi
       # chi web's create) can name it (`--wait --turn T ID`). nil for a
       # session created idle, and for one saved before the field existed.
       SessionField.plain("first_turn_id", nil, optional: true),
+      # Who sent that prompt when no person did (a ClientId: a delegating
+      # parent's delegate:<parent8>, a schedule's chain link
+      # system:schedule:<id>): the first turn's origin, so the command
+      # intake treats it as theirs (CommandIntake) and last_turn names
+      # them. nil for a person's prompt (chi send --new, the web, a TUI, a
+      # continue) and an idle session. Set once, by spawn_session; a
+      # continue and a fork don't carry it.
+      SessionField.plain("first_turn_client_id", nil, optional: true),
       # A Verify fresh child's requester, rules and claim (VerifyFreshOrigin),
       # nil for any other session. Set once, at spawn (VerifyFresh.start).
       # Autoloaded on the first one (the bundle test kit's load budget).
@@ -290,7 +304,7 @@ module Samagotchi
     attr_accessor :id, :metadata_version, :mode, :model_name, :model_typed, :working_directory, :messages,
                   :created_at, :updated_at, :status, :last_prompt, :first_preview, :title, :test_run,
                   :used_memory_names, :preloaded_memory_names, :muted_memory_names, :parent_id, :scratch,
-                  :continues, :first_turn_id
+                  :continues, :first_turn_id, :first_turn_client_id, :project_id
     attr_writer :project_root, :delegate
     attr_reader :appended_prompt_files, :written_by
 
@@ -472,6 +486,10 @@ module Samagotchi
       @archived = false
       # #save's lock: one snapshot-and-write at a time (see #save).
       @save_lock = Mutex.new
+      # Read from its file (.load, .summary_from_file) or saved once: its
+      # file is there to rewrite, and one gone was deleted (#save doesn't
+      # bring it back).
+      @persisted = false
     end
 
     # Whether a chi newer than this one saved the loaded file: its
@@ -566,12 +584,12 @@ module Samagotchi
     # @raise [Toolkit::Refused] its toolkit (setup's, else the configured
     #   one SessionManager.spawn_session gives it) builds on a config kit
     #   with an invalid groups: (Toolkit.check_new!)
-    def self.new_session(mode:, model_name:, working_directory:, test_run: nil,
-                         preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, messages: [],
+    def self.new_session(mode:, model_name:, working_directory:, test_run: nil, parent_id: nil, messages: [],
                          scratch: false, model_typed: nil, delegate: false, setup: nil, continues: nil,
                          review: nil, now: Time.now)
       own = setup.to_h
       own = own.merge(toolkit_origin: own[:toolkit_origin] || "chosen")
+      project = ProjectScope.project_for(working_directory)
       Toolkit.check_new!(own[:toolkit] || Toolkit.configured(delegate: delegate))
       now = now.iso8601(3)
       resolved_test = if test_run.nil?
@@ -591,9 +609,8 @@ module Samagotchi
         status: STATUS_IDLE,
         first_preview: "",
         test_run: resolved_test,
-        project_root: ProjectScope.root_for(working_directory),
-        preloaded_memory_names: preloaded_memory_names,
-        muted_memory_names: muted_memory_names,
+        project_root: project&.root,
+        project_id: project&.id,
         parent_id: parent_id,
         scratch: scratch,
         delegate: delegate,
@@ -621,6 +638,7 @@ module Samagotchi
       raise NotFound, session_id unless File.exist?(path)
 
       session = from_h(JSON.parse(File.read(path)))
+      session.persisted!
       session.status = STATUS_STOPPED if stopped_marker?(session.id, state_dir: state_dir)
       session.parent_id = parent_override(session.id, state_dir: state_dir) || session.parent_id
       session
@@ -749,6 +767,7 @@ module Samagotchi
       return nil unless valid_id?(data["id"])
 
       session = from_h(data, messages: false)
+      session.persisted!
       session.status = STATUS_STOPPED if stopped_marker?(session.id, state_dir: File.dirname(path))
       session.parent_id = parent_override(session.id, state_dir: File.dirname(path)) || session.parent_id
       session
@@ -756,6 +775,10 @@ module Samagotchi
       nil
     end
 
+    # This session was read from its file (#save then refuses to recreate
+    # a deleted one).
+    def persisted! = (@persisted = true)
+
     # Persist the session atomically. Updates +updated_at+ in place.
     #
     # One save at a time per Session: a worker saves its session from the
@@ -767,6 +790,11 @@ module Samagotchi
     # Never call it from a trap handler (Mutex#lock raises ThreadError
     # there; WorkerSignals saves on a thread of its own) or from inside a
     # save (the lock isn't re-entrant).
+    #
+    # A session read from its file, or saved once, whose file is gone was
+    # deleted (SessionManager.delete_session, the retention sweep): the save
+    # is skipped (and logged) rather than bring it back. Only a new
+    # session's first save creates the file.
     # @param now [Time, nil] the updated_at to stamp (a spec's clock); nil,
     #   the time the lock is taken
     def save(state_dir: self.class.default_state_dir, now: nil)
@@ -781,7 +809,13 @@ module Samagotchi
         # Auto-compute first_preview if not yet cached and messages contain a user entry.
         compute_first_preview!
 
+        if @persisted && !File.exist?(path)
+          Log.warn(:worker, "save_skipped_deleted", sid: @id)
+          return self
+        end
+
         AtomicFile.write(path, JSON.pretty_generate(to_h) + "\n")
+        @persisted = true
       end
       self
     end
@@ -845,7 +879,25 @@ module Samagotchi
 
       dir = session_dir(session_id, state_dir: state_dir)
       FileUtils.mkdir_p(dir)
-      FileUtils.touch(File.join(dir, STOPPED_FILE))
+      # Its own at, on the clock the starting marker's at is written with
+      # (StartingMarker; resume_session compares them): a file's mtime may be
+      # coarse or skewed. Older chi readers ask only whether it exists.
+      AtomicFile.write(File.join(dir, STOPPED_FILE), JSON.generate({ "at" => Time.now.iso8601(6) }))
+    end
+
+    # When the stop marker was written: its own at, or (an older chi's empty
+    # file) its mtime; nil without one.
+    # @return [Time, nil]
+    def self.stopped_at(session_id, state_dir: default_state_dir)
+      path = File.join(session_dir(session_id, state_dir: state_dir), STOPPED_FILE)
+      own = begin
+        Time.iso8601(JSON.parse(File.read(path))["at"].to_s)
+      rescue JSON::ParserError, ArgumentError, TypeError, NoMethodError
+        nil
+      end
+      own || File.mtime(path)
+    rescue SystemCallError
+      nil
     end
 
     # Remove the stop marker (a resume, before its worker starts).

data/lib/samagotchi/session_access/local.rb

@@ -19,6 +19,7 @@ require_relative "../send_command/busy"
 require_relative "../chi_invocation"
 require_relative "../worker_sidecar"
 require_relative "../worker_link"
+require_relative "../worker_presence"
 require_relative "../review_start"
 require_relative "../launch_mode"
 require_relative "../participants"
@@ -103,7 +104,7 @@ module Samagotchi
         session = show(id)
         raise Refused.new(Session::SCRATCH_REFUSED, code: "scratch") if session.scratch
 
-        link = WorkerLink.resolve(session_dir(id), unlink: true)
+        link = WorkerPresence.read(id, state_dir: state_dir!, link: :unlink).link
         case link
         when WorkerLink::Live then return Woken.new(woke: false, sidecar: link.sidecar)
         when WorkerLink::Skew then raise Refused.new(link.message(id), code: "worker_newer")
@@ -126,8 +127,8 @@ module Samagotchi
       # @raise [ArgumentError] no such session
       def worker(id)
         show(id)
-        WorkerState.new(link: WorkerLink.resolve(session_dir(id), unlink: true),
-                        stopped: Session.stopped_marker?(id, state_dir: state_dir!))
+        presence = WorkerPresence.read(id, state_dir: state_dir!, link: :unlink)
+        WorkerState.new(link: presence.link, stopped: presence.stop_marked?)
       end
 
       # --- create and send
@@ -143,11 +144,11 @@ module Samagotchi
 
         start = spec.preview ? { prompt: spec.prompt, preview: spec.preview } : { prompt: spec.prompt }
         if spec.continues
-          return SessionContinue.run(spec.continues, **start, model: spec.model_name, **dir)
+          return SessionContinue.run(spec.continues, **start, model: spec.model_name, client_id: spec.client_id, **dir)
         end
 
         SessionManager.spawn_session(**start, working_directory: spec.working_directory, model_name: spec.model_name,
-                                              setup: spec.setup, **dir)
+                                              setup: spec.setup, client_id: spec.client_id, **dir)
       end
 
       # A review session (ReviewStart): a fork of review.from, or a fresh
@@ -313,20 +314,17 @@ module Samagotchi
         return ContextPush.new(status: :missing) unless attached
         return ContextPush.new(status: :not_push) unless attached.source.push?
 
-        before, written = attached.location.locked(name) do
-          [attached.location.snapshot(name).revision, attached.location.record_text(name, fetched)]
-        end
-        if fetched.wake && before != written.revision && !target.project? && attached.location.session? &&
-           attached.source.scope == "session"
-          begin
-            subscription = attached.location.subscription(name)
-            recent_wake = context_wake_recent?(subscription)
-            SessionManager.wake_for_context(target.session_id, **dir) unless recent_wake || Config.get("context.wake") == false
-          rescue StandardError => e
-            Log.exception(:context, "context_push_wake_failed", e, sid: target.session_id, source: name)
+        record = lambda do
+          attached.location.locked(name) do
+            [attached.location.snapshot(name).revision, attached.location.record_text(name, fetched)]
           end
         end
-        ContextPush.new(status: :pushed, before: before, revision: written.revision)
+        unless !target.project? && attached.location.session? && attached.source.scope == "session"
+          before, written = record.call
+          return ContextPush.new(status: :pushed, before: before, revision: written.revision)
+        end
+
+        push_delivery(target.session_id, name, fetched, attached.location, record)
       end
 
       # The target's sources: a session's own, then its project's (shadowed
@@ -353,7 +351,8 @@ module Samagotchi
       def context_candidates(target)
         return [] if target.project?
 
-        ContextCandidates.with_status(target.session_id, project_root: target.project_root, state_dir: @state_dir)
+        ContextCandidates.with_status(target.session_id, project_root: target.project_root, project_id: target.project_id,
+                                                         state_dir: @state_dir)
                          .map { |candidate, status| ContextCandidate.new(candidate: candidate, status: status) }
       end
 
@@ -371,7 +370,9 @@ module Samagotchi
         ContextSources.check_name!(name)
         return :removed if context_location(target).remove(name)
 
-        project = !target.project? && ContextSources.project_location_for(target.project_root, state_dir: @state_dir)
+        project = !target.project? && ContextSources.project_location_for(target.project_root,
+                                                                          project_id: target.project_id,
+                                                                          state_dir: @state_dir)
         project&.source(name) ? :project : :missing
       end
 
@@ -394,7 +395,7 @@ module Samagotchi
       # live in.
       def context_location(target)
         if target.project?
-          ContextSources.project_location_for(target.project_root, state_dir: @state_dir)
+          ContextSources.project_location_for(target.project_root, project_id: target.project_id, state_dir: @state_dir)
         else
           ContextSources.session_location(target.session_id, state_dir: @state_dir)
         end
@@ -465,6 +466,36 @@ module Samagotchi
 
       private
 
+      # A session source's push, as a push delivery (SessionInbox.deliver
+      # :push): the text recorded, then a wake when it asks one (a change
+      # with wake, context.wake on, the source not woken lately) as the
+      # push WakePolicy decides (an idle-exited session starts; a stopped
+      # one never). A failed wake is logged: the push stands.
+      # @return [ContextPush]
+      def push_delivery(session_id, name, fetched, location, record)
+        before = written = asked = nil
+        delivered = begin
+          SessionInbox.deliver(:push, session_id, state_dir: state_dir!) do
+            before, written = record.call
+            asked = fetched.wake && before != written.revision && context_wake_allowed?(location, name)
+          end
+        rescue StandardError => e
+          raise unless written
+
+          Log.exception(:context, "context_push_wake_failed", e, sid: session_id, source: name)
+          nil
+        end
+        # Its session file is gone (:gone): the source's folder takes it, as before.
+        before, written = record.call if delivered&.refused?
+        ContextPush.new(status: :pushed, before: before, revision: written.revision, wake: asked ? delivered&.wake : nil)
+      end
+
+      def context_wake_allowed?(location, name)
+        return false if Config.get("context.wake") == false
+
+        !context_wake_recent?(location.subscription(name))
+      end
+
       def grants = @grants ||= Grants.new(Grants.path(state_dir: state_dir!))
 
       LOCAL_PROBE_TIMEOUT = 1.0
@@ -534,8 +565,8 @@ module Samagotchi
       end
 
       def attached_to(target, shadowed: false)
-        ContextSources.attached(target.session_id, project_root: target.project_root, state_dir: @state_dir,
-                                                   shadowed: shadowed)
+        ContextSources.attached(target.session_id, project_root: target.project_root, project_id: target.project_id,
+                                                   state_dir: @state_dir, shadowed: shadowed)
       end
 
       # The block's post to the session's live worker, again on a 408 (the

data/lib/samagotchi/session_access/remote.rb

@@ -317,14 +317,17 @@ module Samagotchi
       def note(id, text:, source:)
         reply = request(:post, "#{session_path(id)}/notes", body: { text: text, source: source })
         json = reply.json.is_a?(Hash) ? reply.json : {}
+        # id: the link that has it, or refused it (a chi web before it names none: +id+).
+        head = Session.valid_id?(json["id"]) ? json["id"] : id
         case reply.status
         when 200
           raise_refusal(reply) unless json["status"].is_a?(String)
 
-          NoteDelivery::Result.new(id: id, status: json["status"].to_sym, queued: json["queued"].to_i)
+          NoteDelivery::Result.new(id: head, asked: id, status: json["status"].to_sym, queued: json["queued"].to_i)
         when 409
           if json["error"] == "owned_by_tui"
-            return NoteDelivery::Result.new(id: id, status: :refused, queued: 0, scratch: json["scratch"] == true)
+            return NoteDelivery::Result.new(id: head, asked: id, status: :refused, queued: 0,
+                                            scratch: json["scratch"] == true)
           end
 
           raise_refusal(reply)
@@ -508,7 +511,10 @@ module Samagotchi
         reply = request(:post, "#{session_path(target.session_id)}/context/#{name}/push",
                         body: { text: fetched.text, summary: fetched.summary, wake: fetched.wake, hint: fetched.hint })
         case reply.status
-        when 200 then ContextPush.new(status: :pushed, before: reply.json["before"], revision: reply.json["revision"])
+        when 200
+          # An older chi web's answer names no wake: the line is as it was.
+          wake = ContextPush::WAKES.find { |known| known.to_s == reply.json["wake"] }
+          ContextPush.new(status: :pushed, before: reply.json["before"], revision: reply.json["revision"], wake: wake)
         when 404
           return ContextPush.new(status: :missing) if context_missing?(reply)
 
@@ -736,7 +742,8 @@ module Samagotchi
           raise SessionManager::ScratchSession, sid if json["scratch"] == true
 
           raise SessionManager::OwnedByTUI, sid
-        when "worker_running", "still_stopping" then raise SessionManager::DeleteRefused.new(sid, reason)
+        when "worker_running", "still_stopping", "scheduled"
+          raise SessionManager::DeleteRefused.new(sid, reason, message: message)
         when "busy", "scratch"
           raise SessionManager::ArchiveRefused.new(sid, reason, busy_id: json["busy_id"]) if reason
         when "continued", "open_children", "folder_gone"
@@ -809,7 +816,8 @@ module Samagotchi
         owner = json["owner"] && OwnerLock::Owner.new(pid: nil, kind: json["owner"].to_s, started_at: nil)
         SessionView.new(id: json["id"], status: json["status"], title: json["title"],
                         display_title: json["display_title"] || json["title"] || json["first_preview"].to_s,
-                        project_root: json["project_root"], working_directory: json["working_directory"],
+                        project_root: json["project_root"], project_id: json["project_id"],
+                        working_directory: json["working_directory"],
                         model_name: json["model_name"], model_typed: json["model_typed"],
                         parent_answers: json["parent_answers"], owner: owner,
                         pending_question: PendingQuestion.from_file(pending))

data/lib/samagotchi/session_access/web_bridge_client.rb

@@ -141,8 +141,8 @@ module Samagotchi
 
       # POST …/cancel.
       # @return [BridgeClient::Response]
-      def cancel(reason:)
-        post(:cancel, "cancel", { reason: reason })
+      def cancel(reason:, turn_id: nil)
+        post(:cancel, "cancel", { reason: reason, turn_id: turn_id }.compact)
       end
 
       # POST …/exit: the worker asked to exit (chi web passes client_id on

data/lib/samagotchi/session_access.rb

@@ -166,7 +166,10 @@ module Samagotchi
     # @!attribute owner [OwnerLock::Owner, nil] its worker or one-turn chi run
     # @!attribute pending_question [PendingQuestion, nil] the file's
     SessionView = Data.define(:id, :status, :title, :display_title, :project_root, :working_directory, :model_name,
-                              :model_typed, :parent_answers, :owner, :pending_question)
+                              :model_typed, :parent_answers, :owner, :pending_question, :project_id) do
+      def initialize(id:, status:, title:, display_title:, project_root:, working_directory:, model_name:,
+                     model_typed:, parent_answers:, owner:, pending_question:, project_id: nil) = super
+    end
 
     # What chi send --new created (Remote; Local gives the Session): its
     # id, a model warning, the session it continues, the delegates it took
@@ -268,9 +271,15 @@ module Samagotchi
     # chi context push's outcome: :pushed (+before+ the revision it had,
     # +revision+ the new one), :missing (no such source), :not_push (a
     # command source, whose text is its command's) or :continued (the
-    # session was continued, as +next_id+: nothing was written).
-    ContextPush = Data.define(:status, :before, :revision, :next_id) do
-      def initialize(status:, before: nil, revision: nil, next_id: nil) = super
+    # session was continued, as +next_id+: nothing was written). +wake+:
+    # what a push that asked for a wake did (SessionInbox.deliver :push:
+    # :woken, :live, :stopped, :starting, :archived, :scratch, :owned,
+    # :gone), nil when it asked none (or an older chi web's answer has none).
+    ContextPush = Data.define(:status, :before, :revision, :next_id, :wake) do
+      def initialize(status:, before: nil, revision: nil, next_id: nil, wake: nil) = super
+
+      # What chi context push adds to its line for the wake, else nil.
+      def wake_line = ContextPush::WAKE_LINES[wake]
 
       # Why a push to +name+ was refused as :not_push: a command source's
       # text is its command's, and a push between two fetches would read
@@ -286,5 +295,12 @@ module Samagotchi
           "attach it to #{next_id} (or pair again with #{next_id}) and push there"
       end
     end
+
+    # The wakes a chi web's push answer may name (Remote reads no other).
+    ContextPush::WAKES = %i[woken live stopped starting archived scratch owned gone].freeze
+    # chi context push's words for a wake; none for the others (:live: the
+    # worker sees it as any push).
+    ContextPush::WAKE_LINES = { woken: "chi woken", stopped: "chi is stopped: it sees this at its next start",
+                                starting: "chi is starting" }.freeze
   end
 end

data/lib/samagotchi/session_commands.rb

@@ -473,7 +473,8 @@ module Samagotchi
 
       peers = Tools::Peers.new(session_id: session.id, cwd: session.working_directory, state_dir: @engine.peer_state_dir)
       listing = Tools::ContextRead.call("", peers: peers)
-      candidates = ContextCandidates.listing(session.id, project_root: session.project_root, state_dir: @engine.peer_state_dir)
+      candidates = ContextCandidates.listing(session.id, project_root: session.project_root, project_id: session.project_id,
+                                                         state_dir: @engine.peer_state_dir)
       candidates ? "#{listing}\n\n#{candidates}" : listing
     end
 
@@ -618,9 +619,12 @@ module Samagotchi
 
     def approval_line(entry)
       what = entry["key"] ? entry["key"].tr("\n", " ") : "any call rule #{entry["rule"]} asks about"
-      where = if entry["scope"] == "session" then "session #{entry["session_id"].to_s[0, 8]}"
+      where = if entry["scope"] == "session"
+                place = entry["repo_root"] ? " in #{entry["repo_root"]}" : ""
+                "session #{entry["session_id"].to_s[0, 8]}#{place}#{" with its env:" if entry["env"]}"
               elsif entry["repo"] then "in repo #{entry["repo"]}"
-              else "in #{entry["repo_root"]}"
+              else
+                "in #{entry["repo_root"]}"
               end
       rule = entry["rule"] ? " (rule #{entry["rule"]}, #{entry["source"]})" : ""
       "#{entry["scope"]}: #{what} — #{where}#{rule}, #{entry["created_at"]}"