samagotchi 0.63.0 → 0.64.0

data/lib/samagotchi/tools/delegate_cursor.rb

@@ -10,9 +10,14 @@ module Samagotchi
     # What a parent was already told about one delegate child: the newest
     # reply it was given (+reply_file+, ReplyWait's cursor) and the child as
     # it was then (+messages+, +question_id+, +last_turn+: ReplyWait's
-    # baseline). nil +messages+ means no baseline.
-    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages) do
-      def self.empty = new(reply_file: nil, last_turn: nil, question_id: nil, messages: nil)
+    # baseline). nil +messages+ means no baseline. +turn+: the enqueued_id
+    # of the child's turn the last follow-up went to (Delegate.follow_up),
+    # whose own reply a wait takes (ReplyWait's turn:); nil once that turn
+    # was reported, or when unknown (a new child, an older worker).
+    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages, :turn) do
+      def initialize(reply_file: nil, last_turn: nil, question_id: nil, messages: nil, turn: nil) = super
+
+      def self.empty = new
 
       # @param baseline [Hash, nil] ReplyWait.baseline_of's
       def with_baseline(baseline)
@@ -93,7 +98,7 @@ module Samagotchi
         return DelegateCursor.empty unless data.is_a?(Hash)
 
         DelegateCursor.new(reply_file: data["reply_file"], last_turn: data["last_turn"],
-                           question_id: data["question_id"], messages: data["messages"])
+                           question_id: data["question_id"], messages: data["messages"], turn: data["turn"])
       end
 
       def path(parent_id, state_dir:)

data/lib/samagotchi/tools/delegate_wait.rb

@@ -72,7 +72,8 @@ module Samagotchi
           started = monotonic
           wait = ReplyWait.call(child_id, state_dir: sd, cursor: cursor.reply_file, timeout: [left, 0].max,
                                           poll_interval: poll_interval, cancelled: cancelled, baseline: baseline,
-                                          owner_grace: owner_grace, interject: others && -> { others.poll })
+                                          owner_grace: owner_grace, interject: others && -> { others.poll },
+                                          turn: cursor.turn)
           left -= monotonic - started
           unless wait.status == :waiting_for_answer && DelegateRelay.relayable?(relay, wait.question)
             outcomes.concat(relayed_outcomes.delete(key) || [])
@@ -143,7 +144,9 @@ module Samagotchi
       # gave, and the child as that same look loaded it (a fresh load could
       # swallow a turn that ended in between), so a later wait looks for a
       # later turn and a question already reported isn't reported again.
-      # Nothing moves on a timeout or a cancel.
+      # The follow-up's turn (DelegateCursor#turn) is done with once its end
+      # was reported; a question keeps it. Nothing moves on a timeout or a
+      # cancel.
       # @param wait [ReplyWait::Result]
       # @return [DelegateCursor, nil] the new cursor
       def advance(parent_id, child_id, wait, state_dir:)
@@ -151,6 +154,7 @@ module Samagotchi
 
         DelegateCursors.update(parent_id, child_id, state_dir: state_dir) do |cursor|
           cursor = cursor.with(reply_file: wait.file) if wait.status == :done
+          cursor = cursor.with(turn: nil) unless wait.status == :waiting_for_answer
           cursor.with_baseline(ReplyWait.baseline_of(wait.session))
         end
       end
@@ -187,20 +191,28 @@ module Samagotchi
 
       # Point the cursor at the newest reply now, so only a later one counts
       # (a follow-up sent to a child that already answered), and take the
-      # child's baseline before the follow-up goes in.
+      # child's baseline before the follow-up goes in. No turn yet
+      # (#mark_turn, once it went in).
       # @param child [Session] the child as loaded before sending
       def mark_seen(parent_id, child, state_dir:)
         newest = ReplyWait.newest_reply(child.id, state_dir: state_dir)
         DelegateCursors.update(parent_id, child.id, state_dir: state_dir) do |cursor|
-          cursor.with(reply_file: newest).with_baseline(ReplyWait.baseline_of(child))
+          cursor.with(reply_file: newest, turn: nil).with_baseline(ReplyWait.baseline_of(child))
         end
       end
 
+      # The follow-up went in: the child's turn it joins, whose reply the
+      # wait takes (DelegateCursor#turn).
+      # @param turn [String, nil]
+      def mark_turn(parent_id, child_id, turn, state_dir:)
+        DelegateCursors.update(parent_id, child_id, state_dir: state_dir) { |cursor| cursor.with(turn: turn) }
+      end
+
       # A new child's baseline: as spawned, before its first turn ran.
       # @param child [Session] the session spawn_session returned
       def mark_started(parent_id, child, state_dir:)
         DelegateCursors.update(parent_id, child.id, state_dir: state_dir) do |cursor|
-          cursor.with_baseline(ReplyWait.baseline_of(child, question_id: nil))
+          cursor.with(turn: nil).with_baseline(ReplyWait.baseline_of(child, question_id: nil))
         end
       end
 

data/lib/samagotchi/tools/execute.rb

@@ -32,6 +32,10 @@ module Samagotchi
       # stopped the turn: its cancel reason is :signal.
       NOT_RUN_ON_SIGNAL = "Error: not run, a signal to chi stopped the turn"
       STOPPED_BY_SIGNAL = "Error: command stopped by a signal to chi"
+      # The same two when a session stop (chi sessions stop, the web's stop,
+      # a parent stopping its delegate) canceled the turn: :session_stopped.
+      NOT_RUN_ON_SESSION_STOP = "Error: not run, the session was stopped"
+      STOPPED_BY_SESSION_STOP = "Error: command stopped as the session was stopped"
       # The first words of a command killed at the limit in kill mode (hooks
       # match on it).
       TIMEOUT_PREFIX = "Error: command timed out after"
@@ -79,7 +83,8 @@ module Samagotchi
       # @param cancelled [#call] true once the user stopped the turn: the
       #   command is killed (or not started) and its output so far returned
       # @param stop_reason [#call] the stop's reason (:signal: a signal to
-      #   chi, which the result then names instead of the user)
+      #   chi, :session_stopped: a session stop, which the result then names
+      #   instead of the user)
       # @param env [Hash, nil] added to the command's environment
       # @param on_timeout [Symbol, String, nil] :task or :kill (ON_TIMEOUT);
       #   nil reads execute.on_timeout
@@ -116,16 +121,18 @@ module Samagotchi
         # a long command, and return whatever it printed before it was killed.
         stopped_result("#{TIMEOUT_PREFIX} #{timeout_sec}s\n#{TIMEOUT_HINT}", e)
       rescue CommandCancelled => e
-        first = signal?(stop_reason) ? STOPPED_BY_SIGNAL : STOPPED_BY_USER
+        first = STOPPED_BY.fetch(stop_reason.call, STOPPED_BY_USER)
         stopped_result("#{first} after #{e.elapsed.round}s (killed; rerun it if still needed)", e)
       rescue StandardError => e
         "Error: #{e.message}"
       end
 
       # What a command the turn's stop kept from starting returns.
-      def self.not_run(stop_reason) = signal?(stop_reason) ? NOT_RUN_ON_SIGNAL : NOT_RUN_ON_STOP
+      def self.not_run(stop_reason) = NOT_RUN.fetch(stop_reason.call, NOT_RUN_ON_STOP)
 
-      def self.signal?(stop_reason) = stop_reason.call == :signal
+      # The texts above by the stop's reason; any other is the user's Stop.
+      NOT_RUN = { signal: NOT_RUN_ON_SIGNAL, session_stopped: NOT_RUN_ON_SESSION_STOP }.freeze
+      STOPPED_BY = { signal: STOPPED_BY_SIGNAL, session_stopped: STOPPED_BY_SESSION_STOP }.freeze
 
       # execute.on_timeout, or the caller's: :task (the default) or :kill.
       def self.on_timeout_mode(value)

data/lib/samagotchi/turn_checkpoint.rb

@@ -67,6 +67,7 @@ module Samagotchi
       @boundaries = 0
       @written_at = nil
       @started_at = nil
+      @enqueued_id = nil
     end
 
     # A turn begins (before Engine#run_turn and the worker's running save):
@@ -74,14 +75,18 @@ module Samagotchi
     # images, no turn id), marked at iteration 0, so a worker killed before
     # the loop's first boundary leaves the prompt and a mark the next one
     # settles. A continue turn (no prompt) is the history, marked.
+    # Every mark of the turn carries +enqueued_id+ (InterruptedTurn's).
     # @param prompt [String, nil]
-    def begin_turn(prompt: nil)
+    # @param enqueued_id [String, nil] the input the turn runs
+    def begin_turn(prompt: nil, enqueued_id: nil)
       @boundaries = 0
+      @enqueued_id = enqueued_id.to_s.empty? ? nil : enqueued_id.to_s
       @written_at = nil
       @started_at = Time.now.iso8601(3)
       messages = Array(@session.messages).dup
       messages << { role: "user", content: prompt } unless prompt.to_s.empty?
-      @session.turn_checkpoint = { messages: messages, marker: InterruptedTurn.new(started_at: @started_at, at: @started_at, iteration: 0) }
+      @session.turn_checkpoint = { messages: messages, marker: InterruptedTurn.new(started_at: @started_at, at: @started_at, iteration: 0,
+                                                                                   enqueued_id: @enqueued_id) }
     end
 
     # The turn ended (or never began): the session saves its own messages.
@@ -104,7 +109,8 @@ module Samagotchi
       # One level deep: the loop may edit an entry in place later (a
       # forget stub) while a save on another thread serializes this one.
       messages = conversation.map { |message| message.is_a?(Hash) ? message.dup : message } + merged
-      marker = InterruptedTurn.new(id: turn_id, started_at: @started_at, at: Time.now.iso8601(3), iteration: @boundaries)
+      marker = InterruptedTurn.new(id: turn_id, started_at: @started_at, at: Time.now.iso8601(3), iteration: @boundaries,
+                                   enqueued_id: @enqueued_id)
       @session.turn_checkpoint = { messages: messages, marker: marker }
       return false unless due? || !merged.empty?
 

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.63.0"
+  VERSION = "0.64.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/public/app.js

@@ -1741,6 +1741,7 @@ async function handleSendTurn() {
     updateInfoBar();
   }
   actionBtn.disabled = true;
+  const sentTo = selected;
   try {
     for (const chip of sending) {
       if (!chip.ref) chip.ref = await uploadImage(selected, chip.file, chip.name);
@@ -1787,6 +1788,11 @@ async function handleSendTurn() {
       updateComposerMode();
       return;
     }
+    // A stale tab sent into a session deleted meanwhile: the start page
+    // says so, and the line stays in the composer.
+    if (e.code === "not_found") return leaveGoneSession(sentTo, "not_found");
+    // A /queue to a worker that can't queue (it would steer): its words, the text kept.
+    if (e.code === "delivery_unavailable") return addCommandBubble({ label: null, line, text: e.body?.detail || e.message, failed: true });
     alert(e.message);
   } finally {
     actionBtn.disabled = current.owner === "tui";

data/lib/samagotchi/web/public/commands.js

@@ -23,16 +23,17 @@ export function sessionCommandLine(text, commands) {
 }
 
 // /cut TEXT and /queue TEXT: the UIs' own words for a delivery (listed
-// for Tab and /help, never run as commands; TerminalUI::Formatting's
-// STEER_CHOICE: the word, then any whitespace and the text). During a
+// for Tab and /help, never run as commands; ComposerRoute::STEER_CHOICE
+// (spec/fixtures/composer_routes.json): the word, then any whitespace and the text). During a
 // turn /cut TEXT is the text sent as a cut (POST /turn, delivery "cut"),
-// as chi send --cut does; /queue isn't in the web yet (the page says so,
-// as the attached TUI does). With no running turn both are the text as a
-// normal turn. The bare word gets the usage line.
+// as chi send --cut does, and /queue TEXT the text queued to run as a turn
+// of its own after this one (delivery "queue"; a worker that can't queue
+// refuses it, and the page shows the refusal's detail). With no running
+// turn both are the text as a normal turn. The bare word gets the usage
+// line.
 // @return {{send: string, delivery?: string} | {reply: string} | null}
 //   null: not a delivery line
 export const STEER_CHOICE_USAGE = "(/cut and /queue need a message: /cut TEXT, /queue TEXT)";
-export const QUEUE_UNAVAILABLE_WEB = "(/queue isn't available in the web yet; a plain message goes in at the running turn's next step, and /cut TEXT cuts in)";
 const STEER_CHOICE = /^\/(cut|queue)(?:\s+([\s\S]*))?$/;
 
 export function steerChoiceRoute(text, { running = false } = {}) {
@@ -41,8 +42,7 @@ export function steerChoiceRoute(text, { running = false } = {}) {
   const message = (match[2] || "").trim();
   if (!message) return { reply: STEER_CHOICE_USAGE };
   if (!running) return { send: message };
-  if (match[1] === "queue") return { reply: QUEUE_UNAVAILABLE_WEB };
-  return { send: message, delivery: "cut" };
+  return { send: message, delivery: match[1] };
 }
 
 // A line that is one word: a slash and a name, no spaces, no second slash

data/lib/samagotchi/web/public/composer.js

@@ -7,8 +7,8 @@ import { sessionCommandLine, startPageReplyOrHint, steerChoiceRoute, unknownComm
 
 // Where a composer line goes, in the order the page reads it:
 //   1. /cut TEXT, /queue TEXT (steerChoiceRoute): during a turn in a session
-//      the text as a cut, or the page's own answer; else the text goes on
-//      as the line.
+//      the text as a cut or queued for after the turn; else the text goes
+//      on as the line.
 //   2. On the start page (+session+ false): the page's own reply or a typo
 //      hint (startPageReplyOrHint) needs no session; anything else makes one.
 //   3. In a session (routeSessionLine): a session command, the page's own
@@ -21,7 +21,7 @@ import { sessionCommandLine, startPageReplyOrHint, steerChoiceRoute, unknownComm
 //                            +send+ again in it (routeSessionLine, with its
 //                            commands)
 //   {command}                POST /command
-//   {send, delivery}         POST /turn (+delivery+ "cut" or null)
+//   {send, delivery}         POST /turn (+delivery+ "cut", "queue" or null)
 export function routeComposerLine(text, { session = true, running = false, commands = [], images = 0 } = {}) {
   const choice = steerChoiceRoute(text, { running: running && session });
   if (choice?.reply) return { reply: choice.reply, line: text };

data/lib/samagotchi/web/public/timing.js

@@ -33,7 +33,8 @@ export function liveDurationText(durationMs) {
 
 // A cancel's reason as the terminal UIs name it too (Formatting::
 // CANCEL_REASONS); anything else as it is. Both sides: spec/shared/labels_matrix.json.
-const CANCEL_REASONS = { ctrl_c: "Ctrl-C", user: "stopped", hook: "by a hook", worker_stopped: "worker stopped" };
+const CANCEL_REASONS = { ctrl_c: "Ctrl-C", user: "stopped", hook: "by a hook", worker_stopped: "worker stopped",
+  session_stopped: "session stopped" };
 
 // The line a canceled turn ends with: "■ canceled (stopped)", live from
 // turn_canceled's reason and after a re-render from the turn record's

data/lib/samagotchi/web/public/turn_model.js

@@ -222,13 +222,23 @@ export function genLabelParts(gen) {
   if (line) return { head: cut(line), calls, repeats: true };
   if (first?.title) return { head: cut(`${toolName(first)} ${first.title}`), calls, repeats: true };
   if (gen.tools.length) {
-    const names = [...new Set(gen.tools.map(toolName))];
-    const head = `working with ${names.slice(0, LABEL_TOOLS).join(", ")}${names.length > LABEL_TOOLS ? ", …" : ""}`;
-    return { head, calls, repeats: false };
+    // A plugin label that is a verb ("echoing", the default "calling
+    // tool") is the head itself when every call has one; among other
+    // tools it gives way to its tool's name ("working with read, echo").
+    const verbs = gen.tools.every(isVerbLabel);
+    const names = [...new Set(gen.tools.map((r) => (verbs || !isVerbLabel(r) ? toolName(r) : r.tool || "tool")))];
+    const list = `${names.slice(0, LABEL_TOOLS).join(", ")}${names.length > LABEL_TOOLS ? ", …" : ""}`;
+    return { head: verbs ? list : `working with ${list}`, calls, repeats: false };
   }
   return { head: "thinking", calls: "", repeats: false };
 }
 
+// A plugin tool's label that reads as a verb (its first word ends in
+// "ing": "echoing", "calling tool"), not as a name ("chrome: screenshot").
+function isVerbLabel(row) {
+  return /^[a-z]+ing\b/i.test(String(row?.label || ""));
+}
+
 // A step that said something (its text is not the turn's answer): a row of
 // its own in a finished block's outline.
 export function isNarrated(gen) {

data/lib/samagotchi/worker.rb

@@ -900,7 +900,7 @@ module Samagotchi
       @reporting_turn = reports_to_parent?(turn_args[:origin])
       restores = @turn_flow.restores
       begin
-        @checkpoint.begin_turn(prompt: prompt)
+        @checkpoint.begin_turn(prompt: prompt, enqueued_id: turn_args[:origin]&.dig(:enqueued_id))
         @session.status = Session::STATUS_RUNNING
         # A continue that moved this session to the chain's new link wrote
         # the new parent beside it (Session::PARENT_FILE): this turn's
@@ -929,7 +929,7 @@ module Samagotchi
       # no reply: its text is what came before its last tool calls, and a
       # wait (chi send --wait) gets the question instead.
       unless response.nil? || response.strip.empty? || @continue_offer.awaiting?
-        SessionInbox.write_output(@session_dir, response)
+        SessionInbox.write_output(@session_dir, response, enqueued_id: turn_args[:origin]&.dig(:enqueued_id))
       end
       save_or_log(:turn) { save_session }
       # The reports the turn merged were read unless its end took the turn
@@ -1045,10 +1045,12 @@ module Samagotchi
       @pending_input_drain ||= lambda do
         # An iteration boundary: tell whoever sent a command now that it waits.
         refuse_queued_commands(mid_turn: true)
-        # A line with images runs as its own next turn (steering merges text
-        # only), and so does anything queued after it, to keep the order.
+        # A queued line or one with images runs as its own turn after this
+        # one (steering merges text only): skipped here, not a barrier, so a
+        # line sent after it still goes in at this boundary. Only the files
+        # claimed below reach @merged_this_turn and the checkpoint.
         files = SessionInbox.find_new_input_files(@session_dir).sort
-                            .take_while { |input_file| !SessionInbox.waits_for_turn_end?(input_file) }
+                            .reject { |input_file| SessionInbox.waits_for_turn_end?(input_file) }
         merged = files.filter_map do |input_file|
           claimed_file = SessionInbox.claim_input_file(input_file)
           next unless claimed_file

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.63.0
+  version: 0.64.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -235,6 +235,7 @@ files:
 - lib/samagotchi/client_id.rb
 - lib/samagotchi/command_steps.rb
 - lib/samagotchi/commands/registry.rb
+- lib/samagotchi/composer_route.rb
 - lib/samagotchi/config.rb
 - lib/samagotchi/config_text_edit.rb
 - lib/samagotchi/context_absorber.rb