samagotchi 0.63.0 → 0.65.0

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/turn_note.rb

@@ -136,13 +136,27 @@ module Samagotchi
     # text cut to its last STEP_CHARS. Never
     # sent: the payload builders send a system message's content, and the
     # copies for hooks, plugins and the recap drop it (AnswerDisplay.strip).
-    def empty(retries: 0, steps: [])
+    # +refusal+: the provider refused the answer (ModelResult#refusal:
+    # {category:} or {}), kept on the marker and said in the note.
+    def empty(retries: 0, steps: [], refusal: nil)
       marker = { retries: retries.to_i }
       marker[:steps] = steps.map { |step| capped_step(step) } unless steps.empty?
-      message("the previous turn ended with no visible answer (thinking only, or nothing). The user's last message is still unanswered.")
+      marker[:refusal] = refusal if refusal
+      what = if refusal
+               "the previous turn's answer was refused by the provider#{refusal_category(refusal)}"
+             else
+               "the previous turn ended with no visible answer (thinking only, or nothing)"
+             end
+      message("#{what}. The user's last message is still unanswered.")
         .merge(EMPTY_ANSWER => marker)
     end
 
+    # " (cyber)" for a refusal that names its category (either key type), else "".
+    def refusal_category(refusal)
+      category = (refusal[:category] || refusal["category"] if refusal.is_a?(Hash)).to_s.strip
+      category.empty? ? "" : " (#{one_line(category)})"
+    end
+
     def capped_step(step)
       step.slice(:role, :content, :thinking).to_h do |key, value|
         [key, key == :role || !value.is_a?(String) ? value : tail_of(value)]
@@ -167,9 +181,12 @@ module Samagotchi
     end
 
     # The notice every UI shows for a turn that ended with no answer:
-    # "no answer: the model returned nothing (after 1 retry)" (turn_events.js
-    # emptyAnswerLine words it the same).
-    def empty_answer_line(retries)
+    # "no answer: the model returned nothing (after 1 retry)", or for a
+    # +refusal+ (the marker's) "no answer: refused by the provider (cyber)"
+    # (turn_events.js emptyAnswerLine words it the same).
+    def empty_answer_line(retries, refusal: nil)
+      return "no answer: refused by the provider#{refusal_category(refusal)}" if refusal
+
       count = retries.to_i
       after = if count.positive?
                 " (after #{count} #{count == 1 ? "retry" : "retries"})"

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -1944,7 +1944,8 @@ module Samagotchi
           did = step.is_a?(Hash) ? MessageParts.for_message(step, [], cwd: cwd) : nil
           { role: "assistant", content: "", parts: did } if did
         end
-        items << { role: "empty_answer", content: "", retries: (marker[:retries] || marker["retries"]).to_i }
+        refusal = marker[:refusal] || marker["refusal"]
+        items << { role: "empty_answer", content: "", retries: (marker[:retries] || marker["retries"]).to_i, refusal: refusal }.compact
       end
 
       # The last turn failed and its prompt went back to the user: the

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

@@ -103,8 +103,11 @@ export function addStarted(model, event = {}, now = null) {
   return { row, created: true };
 }
 
+// A replayed running call a snapshot timed (its elapsed_ms so far) started
+// that long before +now+; any other replayed start is no clock.
 function markStart(row, event, now) {
   if (now !== null && !event.replayed) row.startedAt = now;
+  else if (now !== null && event.elapsed_ms != null) row.startedAt = now - Number(event.elapsed_ms);
   else delete row.startedAt;
 }
 

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

@@ -76,6 +76,10 @@ import { createComposerCommands, routeComposerLine, routeSessionLine } from "./c
 import { composerAfterAck, dropEarlyRestores, restoreOnAck } from "./restore.js";
 import { createStreamHandlers } from "./stream_handlers.js";
 import { createListsView } from "./lists_view.js";
+import { createDeliveryControl, QUEUE_NEEDS_WORKER } from "./delivery_line.js";
+import { liveSlots } from "./stage_model.js";
+import { currentGen } from "./turn_model.js";
+import { toolName } from "./activity.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -251,6 +255,28 @@ const liveTurn = createLiveTurn({
   onTick: () => updateInfoBar(),
 });
 
+// The composer's delivery line while the open session's turn runs
+// (delivery_line.js): where a message typed now goes in, and the cut and
+// queue links.
+const deliveryControl = createDeliveryControl({
+  el: $("#deliveryLine"),
+  read: () => {
+    const turn = turnDom.current?.().turn || null;
+    const running = turn ? turn.gens.flatMap((g) => g.tools).reverse().find((r) => r.status === "running") : null;
+    return {
+      phase: turnDom.phase?.() || liveSlots(turn).phase,
+      gen: turn ? currentGen(turn) : null,
+      tool: running ? { name: toolName(running), startedAt: running.startedAt ?? null } : null,
+      cutAfter: liveTurn.cutAfter,
+      serverGen: liveTurn.serverGen,
+      canQueue: current.workerFeatures.includes("delivery"),
+      model: current.model,
+    };
+  },
+  composerEmpty: () => !promptEl.value.trim() && !chips.length,
+  send: (delivery) => handleSendTurn({ delivery }),
+});
+
 // This tab's id in the session's events: tells its own prompts from the
 // ones other clients (an attached TUI, another tab, reminders) sent.
 const clientId = newClientId();
@@ -552,8 +578,9 @@ function updateComposerMode() {
   }
   const running = liveTurn.running && !!selected;
   cancelBtn.style.display = running ? "" : "none";
+  syncDeliveryLine();
   if (running) {
-    setPlaceholder("Running… a message now steers this turn · Enter to send · Shift+Enter newline", "Steer the turn…");
+    setPlaceholder("Running… a message goes in at the next step · Enter to send · Alt+Enter queues", "Steer the turn…");
     composeHintEl.textContent = SEND_HINT;
     actionBtn.textContent = "Send";
     emptyEl.classList.add("hidden");
@@ -574,7 +601,8 @@ function updateComposerMode() {
     actionBtn.disabled = true;
     emptyEl.classList.add("hidden");
   } else {
-    setPlaceholder("Message chi… · Enter to send · Shift+Enter newline · ↑ history", "Message chi…");
+    // The keys are in the delivery line's row above.
+    setPlaceholder("Message chi…", "Message chi…");
     composeHintEl.textContent = SEND_HINT;
     actionBtn.textContent = "Send";
     actionBtn.disabled = false;
@@ -582,6 +610,14 @@ function updateComposerMode() {
   }
 }
 
+// The delivery line's row in a session (delivery_line.js): the key hint
+// while idle, where a message goes in while the turn runs.
+function syncDeliveryLine() {
+  // A terminal owns the session: the composer is off, so is its row.
+  if (!selected || current.owner === "tui") deliveryControl.show("off");
+  else deliveryControl.show(liveTurn.running && current.owner !== "tui" ? "running" : "idle");
+}
+
 function setTurnRunning(running) {
   liveTurn.running = !!running;
   updateComposerMode();
@@ -790,6 +826,9 @@ function renderSessionView(data, { kept = [] } = {}) {
   });
   // Marked replayed: a call's duration isn't timed from the replay's clock.
   replay.forEach((event) => streamHandlers[event.type]?.({ ...event, replayed: true }));
+  // A join mid-generation: the worker's word on it clocks the delivery line.
+  const gen = data.current_turn?.generation;
+  liveTurn.serverGen = gen ? { ...gen, at: Date.now() } : null;
   if (!data.current_turn) {
     setTurnRunning(current.status === "running");
     if (liveTurn.running && current.timing.activeTurn?.started_at) liveTurn.timing.start(current.timing.activeTurn.started_at, activeTurnId);
@@ -997,11 +1036,13 @@ function endTurnView(kind, endText = null, { emptyAnswer = null, stopped = false
 // prompts are echoed at send (data-own) and tagged by their turn_enqueued.
 
 // The bubble a reload draws (turn_html.js), with this page's own fields.
-function makeUserBubble(prompt, { state = null, label = null, enqueuedId = null, own = false, images = null } = {}) {
+// +delivery+: how it went into a running turn (next_step, cut, queue): its
+// queued badge says what it waits for.
+function makeUserBubble(prompt, { state = null, label = null, enqueuedId = null, own = false, images = null, delivery = null } = {}) {
   const hint = historyEl.querySelector(".hint");
   if (hint) hint.remove();
   const div = elementOf(userBubbleTemplate({ content: prompt }, {
-    label, state, own, enqueuedId, key: normalize(prompt), thumbs: thumbsTemplate(selected, images),
+    label, state, own, enqueuedId, delivery, key: normalize(prompt), thumbs: thumbsTemplate(selected, images),
   }));
   const follow = isNearBottom();
   appendToHistory(div);
@@ -1018,7 +1059,17 @@ function setBubbleState(bubble, state) {
   }
   bubble.classList.add(state);
   bubble.dataset.userState = state;
-  bubble.append(elementOf(stateBadgeTemplate(state)));
+  bubble.append(elementOf(stateBadgeTemplate(state, bubble.dataset.delivery || null)));
+}
+
+// A bubble's delivery changed (the ack's cut: off goes in at the next
+// step; a queue to a turn that ended meanwhile is just the next turn): its
+// badge follows.
+function setBubbleDelivery(bubble, delivery) {
+  if ((bubble.dataset.delivery || null) === (delivery || null)) return;
+  if (delivery) bubble.dataset.delivery = delivery;
+  else delete bubble.dataset.delivery;
+  if (bubble.dataset.userState) setBubbleState(bubble, bubble.dataset.userState);
 }
 
 function bubbleById(enqueuedId) {
@@ -1047,15 +1098,18 @@ function applyPromptOps(event) {
     if (op.op === "report") {
       liveTurn.unmatchedMerge = "report";
     } else if (op.op === "add") {
-      const bubble = makeUserBubble(op.prompt, { state: op.state, label: op.label, enqueuedId: op.enqueuedId, images: op.images });
+      const bubble = makeUserBubble(op.prompt, { state: op.state, label: op.label, enqueuedId: op.enqueuedId, images: op.images, delivery: op.delivery });
       if (op.state === "started") started = bubble;
       if (event.type === "pending_input_merged") liveTurn.wakeStart = false;
     } else if (op.op === "tag") {
       if (bubbleById(op.enqueuedId)) continue;
       const echo = untaggedOwnBubble(op.prompt);
-      if (echo) echo.dataset.enqueuedId = op.enqueuedId;
+      if (echo) {
+        echo.dataset.enqueuedId = op.enqueuedId;
+        if (op.delivery) setBubbleDelivery(echo, op.delivery);
+      }
       // Re-rendered from a snapshot: the echo is gone, the prompt still queued.
-      else makeUserBubble(op.prompt, { state: "queued", own: true, enqueuedId: op.enqueuedId, images: op.images });
+      else makeUserBubble(op.prompt, { state: "queued", own: true, enqueuedId: op.enqueuedId, images: op.images, delivery: op.delivery });
     } else if (op.op === "start") {
       const bubble = bubbleById(op.enqueuedId) || untaggedOwnBubble(op.prompt);
       // A resync (a new worker woken by this page's send) re-rendered the
@@ -1683,10 +1737,14 @@ function handleCreate() {
   return handleSendTurn();
 }
 
-async function handleSendTurn() {
+// +delivery+: the composer's choice for a running turn (Alt+Enter: queue;
+// a delivery-line link: cut or queue); else the armed one; a typed /cut or
+// /queue wins over both.
+async function handleSendTurn({ delivery: chosen = null } = {}) {
   if (current.owner === "tui") return;
   let prompt = turnText(promptEl.value, chips);
   if (!prompt) return;
+  const armed = deliveryControl.take();
   // An image-only send's text is its placeholders: not for ↑.
   const typed = promptEl.value.trim() !== "";
   // The composer holds the line as typed until the ack (composerAfterAck).
@@ -1727,20 +1785,25 @@ async function handleSendTurn() {
   }
   if (route.command) return composerCommands.send(route.command);
   prompt = route.send;
-  const delivery = route.delivery;
+  const running = liveTurn.running && !!selected;
+  const delivery = route.delivery || (running ? chosen || armed : null);
   const hint = historyEl.querySelector(".hint");
   if (hint) hint.remove();
   // Sending moves a finished turn out of the stage at once (else the echo
   // would land among its rows); into a running one it is a queued row there.
   turnDom.handOff?.({ immediate: true });
   const sending = chips.slice();
-  const echo = makeUserBubble(prompt, { state: "queued", own: true, images: sending });
+  // Into a running turn the echo says what it waits for (its delivery); a
+  // line with images always waits for the turn's end (the worker queues it).
+  const shownDelivery = running ? (sending.length ? "queue" : delivery || "next_step") : null;
+  const echo = makeUserBubble(prompt, { state: "queued", own: true, images: sending, delivery: shownDelivery });
   if (!turnDom.holds?.()) historyEl.scrollTop = historyEl.scrollHeight;
   if (!current.firstPreview || current.firstPreview==="—") {
     current.firstPreview = firstPreview(prompt);
     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);
@@ -1755,6 +1818,11 @@ async function handleSendTurn() {
       return;
     }
     if (ack?.enqueued_id) sentIds.add(ack.enqueued_id);
+    // A cut the worker didn't take (no thinking-only step: cut off) goes in
+    // at the next step; a queue whose turn ended meanwhile is the next turn.
+    if (ack?.cut === "off" || (ack?.delivery === "next_step" && echo.dataset.delivery === "queue")) {
+      setBubbleDelivery(echo, ack.cut === "off" ? "next_step" : null);
+    }
     refreshHistory();
     // A turn that failed fast was restored before this ack: its prompt
     // (and images) go back into the composer, without replacing text typed
@@ -1787,6 +1855,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";
@@ -2112,10 +2185,20 @@ function historyKey(e) {
 promptEl.addEventListener("keydown", (e) => {
   if (commandList.handleKey(e)) return;
   if (historyKey(e)) return;
-  if (e.key === "Enter" && !e.shiftKey) {
+  // Esc lets go of a choice armed on the delivery line.
+  if (e.key === "Escape" && deliveryControl.disarm()) {
+    e.preventDefault();
+    return;
+  }
+  // An IME's Enter picks the composition, it doesn't send.
+  if (e.key === "Enter" && !e.shiftKey && !e.isComposing) {
     e.preventDefault();
     if (!selected) handleCreate();
-    else handleSendTurn();
+    // Alt/Option+Enter: queued for after the running turn (D6), only to a
+    // worker that queues (else it would steer): the text stays, a note says why.
+    else if (e.altKey && liveTurn.running && !current.workerFeatures.includes("delivery")) {
+      addCommandBubble({ label: null, line: promptEl.value.trim(), text: QUEUE_NEEDS_WORKER, failed: true });
+    } else handleSendTurn(e.altKey ? { delivery: "queue" } : {});
   }
 });
 $("#infoStopBtn").addEventListener("click", async () => {

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 };