samagotchi 0.153.0 → 0.154.1

data/lib/samagotchi/session_model_settings.rb

@@ -7,6 +7,7 @@ require_relative "session_setting"
 require_relative "steer_cut"
 require_relative "steer_cut_after"
 require_relative "thinking"
+require_relative "session"
 
 module Samagotchi
   # The session's settings on its effective model, as the Engine reads them:
@@ -163,7 +164,7 @@ module Samagotchi
     # @raise [ArgumentError] with no session yet
     def reasoning_history_override=(level)
       session = @session.call
-      raise ArgumentError, "no session yet" unless session
+      raise ArgumentError, Session::NONE_YET unless session
 
       SessionSetting::REASONING_HISTORY.set(session, level)
     end
@@ -178,7 +179,7 @@ module Samagotchi
     # @raise [ArgumentError] with no session yet
     def thinking_override=(level)
       session = @session.call
-      raise ArgumentError, "no session yet" unless session
+      raise ArgumentError, Session::NONE_YET unless session
 
       SessionSetting::THINKING.set(session, level)
     end

data/lib/samagotchi/session_participants.rb

@@ -4,7 +4,7 @@ require_relative "steer"
 require_relative "participant_mode"
 
 module Samagotchi
-  # Loaded only when a session is read: it brings Web::Grants (and Rack).
+  # Loaded only when a session is read: it brings Grants.
   autoload :Participants, File.expand_path("participants", __dir__)
 
   # What a session's Engine knows of its participants: participants.json

data/lib/samagotchi/session_retention.rb

@@ -18,7 +18,7 @@ module Samagotchi
   # (session.retention_days), count (session.max_count, counting only the
   # sessions that stay), statuses kept (session.keep_status), sessions left
   # empty (SessionManager.discardable?, an hour on), leftover scratch
-  # sessions and skeleton-only directories; a session with a live owner
+  # sessions (once past SCRATCH_START_GRACE) and skeleton-only directories; a session with a live owner
   # always stays.
   module SessionRetention
     # The session.retention_days / max_count / keep_status defaults.
@@ -30,7 +30,7 @@ module Samagotchi
     DEFAULT_KEEP_STATUS = [].freeze
 
     # How long a session may sit empty before the sweep takes it: its
-    # worker (or a REPL) deletes it as it leaves, so the sweep only catches
+    # worker deletes it as it leaves, so the sweep only catches
     # those killed first (a reboot, kill -9).
     EMPTY_GRACE_SECONDS = 3600
 
@@ -69,7 +69,7 @@ module Samagotchi
     end
 
     # Directories with no session file and nothing but the skeleton, nobody
-    # owning them: a REPL killed before its first save, or a worker woken
+    # owning them: a one-shot killed before its first save, or a worker woken
     # just as its session was discarded.
     # @return [Array<String>] their ids
     private_class_method def self.prune_orphan_dirs(state_dir, dry_run:)
@@ -93,6 +93,16 @@ module Samagotchi
       end
     end
 
+    # How long after its save an unowned scratch session may still be
+    # waiting for the worker just spawned for it to take its owner lock.
+    SCRATCH_START_GRACE = SessionManager::WORKER_START_GRACE
+
+    private_class_method def self.scratch_starting?(path, now)
+      now - File.mtime(path) < SCRATCH_START_GRACE
+    rescue SystemCallError
+      false
+    end
+
     # Lazy sweep guard: runs prune at most once per SWEEP_INTERVAL_HOURS
     # (session.sweep_interval_hours).
     MARKER = ".last_retention"
@@ -161,8 +171,10 @@ module Samagotchi
     # +any_age+ makes every session eligible, whatever its age and the
     # count (`chi sessions clean` with no --days: test runs are throwaway).
     #
-    # A scratch session nobody owns (its REPL was killed) goes whatever its
-    # age, its status and the count; +test_only+ takes it too.
+    # A scratch session nobody owns (its terminal and worker were killed) goes whatever its
+    # age, its status and the count; +test_only+ takes it too. One saved
+    # within SCRATCH_START_GRACE (its file's mtime, against +now+) stays: its
+    # worker may not have taken the owner lock yet.
     #
     # +max_count+ counts the sessions that stay: one deleted whatever its
     # place (scratch, left empty, expired, +any_age+) takes no slot.
@@ -173,7 +185,7 @@ module Samagotchi
     # @return [Hash] { deleted: [ids], kept: [ids], skipped: [ids] }
     def self.apply(state_dir: Session.default_state_dir, days: DEFAULT_RETENTION_DAYS, max_count: DEFAULT_MAX_COUNT,
                    keep_status: DEFAULT_KEEP_STATUS, dry_run: false, test_only: false, alive_check: nil,
-                   empty_check: nil, any_age: false)
+                   empty_check: nil, any_age: false, now: Time.now)
       keep_status = Array(keep_status).map(&:to_s)
       # Fetch all sessions sorted newest-first for count logic
       all = Session.list(state_dir: state_dir, sort: "updated_at", order: "desc")
@@ -182,7 +194,6 @@ module Samagotchi
         all = all.select { |session| session.test_run || session.scratch }
       end
 
-      now = Time.now
       cutoff = days.to_i.positive? ? now - (days.to_i * 86_400) : nil
       max = max_count.to_i
 
@@ -217,6 +228,15 @@ module Samagotchi
           end
         end
 
+        # A scratch session saved within SCRATCH_START_GRACE: `chi scratch`
+        # saves it, then spawns the worker that takes its owner lock, so no
+        # owner yet doesn't mean a leftover. Kept, it takes no count slot.
+        if session.scratch && scratch_starting?(path, now)
+          kept << session.id
+          passed_over += 1
+          next
+        end
+
         left_empty = begin
           empty_check&.call(session.id)
         rescue StandardError

data/lib/samagotchi/sessions_command.rb

@@ -21,7 +21,7 @@ module Samagotchi
   # `chi sessions`: list, stop, restart, archive/unarchive, delete, prune,
   # clean and stats sessions from the shell (bin/chi dispatches here before
   # OptionParser; the subcommands have their own flags). Not SessionCommands,
-  # the REPL's slash commands for sessions (session_commands.rb).
+  # the slash commands a session's worker runs (session_commands.rb).
   class SessionsCommand
     include CLI::Command
 
@@ -207,15 +207,15 @@ module Samagotchi
       )
       case format
       when "json"
-        # owner: "worker", "tui" (a chi REPL: it takes no notes or messages)
+        # owner: "worker", "tui" (a one-turn chi run: it takes no notes or messages)
         # or nil; recap: the saved recap's first sentence, or nil; project:
         # its git project's root, or nil
         # parent_id: the session that delegated it (the delegate tool), or nil
         # delegate: started by the delegate tool (a fork has a parent_id too)
         # continues: the session it continues (its chain's previous link), or nil
         # archived: hidden from the lists (only with --archived can it be true)
-        # scratch: a `chi scratch` session (deleted when its REPL ends, a
-        # leftover one at the next sweep)
+        # scratch: a `chi scratch` session (deleted when its terminal leaves,
+        # a leftover one at the next sweep)
         # ctx_pct: how full the context was after the last turn, or nil
         # title: the session's own name (/title; desc shows it too), or nil;
         # auto_title: the one its recap gave it (RecapTitle), or nil

data/lib/samagotchi/share_command.rb

@@ -8,12 +8,12 @@ require_relative "cli/flags"
 require_relative "session"
 require_relative "session_access"
 require_relative "session_access/local"
-require_relative "web/grants"
+require_relative "grants"
 require_relative "web/qr"
 
 module Samagotchi
   # `chi share`: invite a participant to review a session (the
-  # shared-sessions plan: a Web::Grants grant, one session, one person or
+  # shared-sessions plan: a Grants grant, one session, one person or
   # agent, 7 days unless --expires says otherwise), list the participants,
   # revoke them. Local or through chi --remote NAME (SessionAccess). The
   # token is printed once, in the link; chi keeps only its digest. See
@@ -95,9 +95,9 @@ module Samagotchi
       return parsed if parsed.is_a?(Integer)
 
       send(:"run_#{@sub || "invite"}", parsed.options, parsed.args)
-    rescue SessionAccess::BadRequest, Web::Grants::BadIdentity => e
+    rescue SessionAccess::BadRequest, Grants::BadIdentity => e
       usage_error(e.message)
-    rescue Web::Grants::Unwritable => e
+    rescue Grants::Unwritable => e
       error_line("#{command_name}: #{e.message}")
       CLI::Exit::FAILED
     rescue ArgumentError => e
@@ -114,13 +114,13 @@ module Samagotchi
       return usage_error("give one session ID") unless args.size == 1
       return usage_error("--name NAME: who the link is for") if options[:name].to_s.strip.empty?
 
-      ttl = Web::Grants.parse_ttl(options[:expires])
+      ttl = Grants.parse_ttl(options[:expires])
       return usage_error("--expires takes Nh or Nd, 1h to 30d (e.g. 3d)") if ttl == false
 
       cap = options[:cap] && dollars(options[:cap])
       return usage_error(CAP_USAGE) if cap == false
 
-      identity = options[:identity] && Web::Grants.clean_identity(options[:identity])
+      identity = options[:identity] && Grants.clean_identity(options[:identity])
 
       id = @access.resolve(args.first)
       invitation = @access.invite(id, name: options[:name], kind: options[:agent] ? "agent" : "human", ttl: ttl, cap: cap,
@@ -149,13 +149,13 @@ module Samagotchi
       0
     end
 
-    CAP_USAGE = "a cap is dollars, $0 to $#{Web::Grants::MAX_CAP.to_i} (e.g. --cap 5)".freeze
+    CAP_USAGE = "a cap is dollars, $0 to $#{Grants::MAX_CAP.to_i} (e.g. --cap 5)".freeze
 
     def run_cap(_options, args)
       return usage_error("give a session ID, a participant and dollars (chi share cap ID p_… 5)") unless args.size == 3
 
       participant = args[1]
-      return usage_error("not a participant: #{participant} (chi share ls lists them)") unless Web::Grants::ID_RE.match?(participant)
+      return usage_error("not a participant: #{participant} (chi share ls lists them)") unless Grants::ID_RE.match?(participant)
 
       cap = dollars(args[2])
       return usage_error(CAP_USAGE) if cap == false
@@ -172,7 +172,7 @@ module Samagotchi
       return false unless text.match?(/\A\d+(?:\.\d+)?\z/)
 
       value = text.to_f
-      Web::Grants.cap?(value) ? value : false
+      Grants.cap?(value) ? value : false
     end
 
     def money(value) = value.nil? ? "-" : format("$%.2f", value)
@@ -184,7 +184,7 @@ module Samagotchi
         return usage_error("give a session ID (and a participant), or --all")
       end
       participant = args[1]
-      return usage_error("not a participant: #{participant} (chi share ls lists them)") if participant && !Web::Grants::ID_RE.match?(participant)
+      return usage_error("not a participant: #{participant} (chi share ls lists them)") if participant && !Grants::ID_RE.match?(participant)
 
       id = args.first && @access.resolve(args.first)
       revoked = @access.revoke_participants(id, participant: participant)

data/lib/samagotchi/steer.rb

@@ -28,6 +28,12 @@ module Samagotchi
   module Steer
     KIND = "steer"
     INPUT_KIND = "input"
+    # KernelLoop's line asking a Qwen model to finish the tool call it left
+    # open: a user line inside the running turn, the model's alone. No turn
+    # opens with it (#turn_prompt?), and the page draws nothing for it, as it
+    # showed nothing live. Its kind adds no header (#header): its bytes go
+    # out as before it had one.
+    RECOVERY_KIND = "recovery"
 
     # A drain item for an input line with its sender (source nil = the user).
     # A plain String is still a valid item: the user's line. +mark+: fields
@@ -136,7 +142,7 @@ module Samagotchi
     PARTICIPANT_SOURCE = "participant"
     # The owner's author, when one is written out; absent means the same.
     OWNER_AUTHOR = "owner"
-    # A participant's author: this prefix, then its id (Web::Grants'
+    # A participant's author: this prefix, then its id (Grants'
     # grant id), "p:<id>" (#author_for, #participant_id).
     PARTICIPANT_PREFIX = "p:"
     # A participant's message's keys, which every message copy keeps.
@@ -317,6 +323,11 @@ module Samagotchi
       message.is_a?(Hash) && (message[:role] || message["role"]).to_s == "user" && !steer?(message)
     end
 
+    # KernelLoop's recovery line (RECOVERY_KIND).
+    def recovery?(message)
+      message.is_a?(Hash) && (message[:kind] || message["kind"]).to_s == RECOVERY_KIND
+    end
+
     # The user's lines merged into a running turn (Merge#messages).
     def input?(message)
       message.is_a?(Hash) && (message[:kind] || message["kind"]).to_s == INPUT_KIND
@@ -333,7 +344,7 @@ module Samagotchi
       start = (message[:turn_start] || message["turn_start"]) == true
       return start if (message[:role] || message["role"]).to_s == "system"
 
-      prompt?(message) && (!input?(message) || start)
+      prompt?(message) && !recovery?(message) && (!input?(message) || start)
     end
 
     # A stored `!shell` line: "!(cmd)\n<output>", no turn id. A user message,

data/lib/samagotchi/stream_event.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "degrade"
+
+module Samagotchi
+  # The one rule for handing a loop event to its on_stream_event callback
+  # (KernelLoop#emit_stream_event, ToolRunner#emit): no callback is fine, and
+  # a failing one (a UI gone) must not break the turn or the tool call. Its
+  # failure is a Degrade record under :turn, named by the caller (+failure+,
+  # so a log still says which side lost the event), with the event's type.
+  module StreamEvent
+    module_function
+
+    # @param callback [#call, nil] the loop's on_stream_event
+    # @param event [Hash] the event
+    # @param failure [String] the Degrade event slug when +callback+ raises
+    # @return the callback's value, nil when it raised or there is none
+    def emit(callback, event, failure:)
+      Degrade.call(:turn, failure, type: (event[:type] if event.is_a?(Hash))) { callback&.call(event) }
+    end
+  end
+end