samagotchi 0.64.0 → 0.65.0

data/lib/samagotchi/self_report.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-require "uri"
 require_relative "version"
 require_relative "config"
 require_relative "context_window"
@@ -16,8 +13,7 @@ require_relative "thinking"
 require_relative "reasoning_history"
 require_relative "served_model"
 require_relative "host_registry"
-require_relative "llm/http"
-require_relative "llm/api_key"
+require_relative "llm/adapters"
 require_relative "tools/memory"
 require_relative "hooks/loader"
 require_relative "memory_bundle/provenance"
@@ -273,7 +269,9 @@ module Samagotchi
       entry = HostRegistry.new(env: env).resolve(model).entry
       return "-" unless entry
 
-      entry.chat? ? "chat (api: openai)" : "native (raw prompt)"
+      return "native (raw prompt)" unless entry.chat?
+
+      entry.dialect ? "chat (api: #{entry.api}, dialect: #{entry.dialect})" : "chat (api: #{entry.api})"
     end
 
     NO_PROPS = "reported per turn (the server has no /props)"
@@ -281,7 +279,7 @@ module Samagotchi
     # chi self's one server call: a single-model llama.cpp answers any name
     # with the model it loaded, and its /props names it (model_alias). One
     # GET with the probe's short timeouts; a remote host isn't asked. A local
-    # chat host (api: openai) has no /props, so it gets a GET <base>/models
+    # chat host (api: openai or anthropic) has no /props, so it gets its model list
     # with the same timeouts: up/down and the ids it serves.
     def served_model_for(model, env)
       registry = HostRegistry.new(env: env)
@@ -306,36 +304,28 @@ module Samagotchi
       "unknown (#{e.class})"
     end
 
-    # A local chat host's reachability: one GET <base>/models with the
-    # native probe's short timeouts (Client's /props probe), no retry. Up
-    # with the ids it serves, down when it doesn't answer.
+    # A local chat host's reachability: its model list through its own
+    # adapter (LLM::Adapters, not the registry's cached one) with the native
+    # probe's short timeouts (Client's /props probe), no retry. Up with the
+    # ids it serves, down when it doesn't answer.
     def chat_served_model_for(entry, bare, env)
-      uri = URI("#{entry.openai_base_url}/models")
-      request = Net::HTTP::Get.new(uri)
-      http = LLM::HTTP.new(label: entry.name, open_timeout: Client::CONTEXT_WINDOW_PROBE_OPEN_TIMEOUT,
-                           read_timeout: Client::CONTEXT_WINDOW_PROBE_READ_TIMEOUT,
-                           retry_policy: LLM::HTTP::RetryPolicy.none,
-                           api_key: LLM::ApiKey.for(entry.api_key_env, host: entry.host, env: env))
-      response = http.fetch(uri, request, retries: false, check_status: false, log_fields: { purpose: "models" })
-      return "down (HTTP #{response.code})" unless response.code.to_s == "200"
-
-      ids = chat_model_ids(response.body)
+      adapter = LLM::Adapters.for(entry, open_timeout: Client::CONTEXT_WINDOW_PROBE_OPEN_TIMEOUT,
+                                         timeout: Client::CONTEXT_WINDOW_PROBE_READ_TIMEOUT, retries: false, env: env)
+      ids = adapter.list_models.map(&:id).reject(&:empty?)
       return "up (no models listed)" if ids.empty?
 
       note = ids.any? { |id| id.casecmp?(bare.to_s) } ? "" : " (not #{bare})"
       "up: #{ids.join(", ")}#{note}"
+    rescue LLM::ProviderError => e
+      # A status (an error, or a 3xx such as a proxy's login page) is down;
+      # a 200 whose body isn't a model list (ProtocolError) is up.
+      return "down (HTTP #{e.status})" if e.status
+
+      e.is_a?(LLM::ProtocolError) ? "up (no models listed)" : "down (the server didn't answer; is it running?)"
     rescue StandardError
       "down (the server didn't answer; is it running?)"
     end
 
-    def chat_model_ids(body)
-      parsed = JSON.parse(body.to_s)
-      data = parsed.is_a?(Hash) ? parsed["data"] : parsed
-      Array(data).filter_map { |raw| raw.is_a?(Hash) ? (raw["id"] || raw[:id]).to_s : raw.to_s }.reject(&:empty?)
-    rescue JSON::ParserError
-      []
-    end
-
     # Offline, so no /props probe: where nothing is configured, a native
     # llama.cpp host's chat template decides at runtime.
     def profile_for(model, env)

data/lib/samagotchi/session.rb

@@ -722,14 +722,15 @@ module Samagotchi
         symbolize_empty_answer(message)
       end
 
-      # An empty-answer note's marker (TurnNote.empty) and its steps, as
-      # they were saved.
+      # An empty-answer note's marker (TurnNote.empty), its steps and its
+      # refusal, as they were saved.
       def symbolize_empty_answer(message)
         marker = message[:empty_answer]
         return message unless marker.is_a?(Hash)
 
         marker = marker.transform_keys(&:to_sym)
         marker[:steps] = marker[:steps].map { |step| step.is_a?(Hash) ? step.transform_keys(&:to_sym) : step } if marker[:steps].is_a?(Array)
+        marker[:refusal] = marker[:refusal].transform_keys(&:to_sym) if marker[:refusal].is_a?(Hash)
         message.merge(empty_answer: marker)
       end
 

data/lib/samagotchi/session_metrics.rb

@@ -883,7 +883,7 @@ module Samagotchi
       payload = event[:payload]
       payload = {} unless payload.is_a?(Hash)
 
-      @mutex.synchronize { note_first_chunk(payload, event) }
+      @mutex.synchronize { note_first_chunk(event) }
       usage = TokenUsage.from_payload(payload)
       if usage
         @mutex.synchronize { note_server_usage(usage) if @turn }
@@ -915,21 +915,16 @@ module Samagotchi
       turn.gen_had_server = true
     end
 
-    # The first chunk with content, reasoning or a tool call starts the
-    # generation's decode clock (an estimated speed runs from it). Caller
-    # holds the mutex.
-    def note_first_chunk(payload, event)
+    # The first chunk with content, reasoning or a tool call (the loop marks
+    # its event tool_call: true, whatever the wire) starts the generation's
+    # decode clock (an estimated speed runs from it). Caller holds the mutex.
+    def note_first_chunk(event)
       return unless @turn && @turn.gen_open && @turn.gen_first_chunk_at.nil?
-      return unless !event[:content].to_s.empty? || tool_call_delta?(payload)
+      return unless !event[:content].to_s.empty? || event[:tool_call]
 
       @turn.gen_first_chunk_at = monotonic_time
     end
 
-    def tool_call_delta?(payload)
-      choice = payload["choices"].is_a?(Array) ? payload["choices"].first : nil
-      choice.is_a?(Hash) && choice["delta"].is_a?(Hash) && !Array(choice["delta"]["tool_calls"]).empty?
-    end
-
     def event_content_chars(payload, event)
       len = payload_content(payload, event).length
       len.positive? ? len : nil

data/lib/samagotchi/steer_cut.rb

@@ -82,6 +82,10 @@ module Samagotchi
       @waiting.epoch
     end
 
+    # The running generation's phase (GenerationPhase::Snapshot), nil with
+    # none running.
+    def generation_snapshot = @phase.snapshot
+
     # The turn's stream: the generation's phase follows it, and a thinking
     # chunk rechecks a waiting message. +progress+: a chunk's lanes
     # (.lanes), read from it when not given.

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -260,13 +260,17 @@ module Samagotchi
           take_session_state(event[:session_state_snapshot] || {})
           return render_snapshot(event[:snapshot] || {}, reset: event[:type] == :reset)
         when :turn_enqueued then show_enqueued(event)
-        when :turn_started then start_turn(event)
+        when :turn_started
+          @status.take_event(event)
+          start_turn(event)
         when :turn_completed
+          @status.take_event(event)
           complete_turn(event)
           refresh_children
           own_turn_ended(event)
         # The renderer says how it ended (the REPL's words too).
         when :turn_canceled, :turn_failed
+          @status.take_event(event)
           @renderer.call(event)
           end_turn
           refresh_children
@@ -1239,7 +1243,7 @@ module Samagotchi
         # A turn that ended with no answer: its notice, as live.
         empty = messages.drop(from + 1).filter_map { |m| TurnNote.empty_answer(m) }.last
         if empty
-          @screen.commit(format_empty_answer_line(empty[:retries] || empty["retries"]))
+          @screen.commit(format_empty_answer_line(empty[:retries] || empty["retries"], empty[:refusal] || empty["refusal"]))
         elsif failed
           # A failed turn whose steps stayed: the line the live view left,
           # and no step text as if it were the answer (the web keeps a
@@ -1379,6 +1383,8 @@ module Samagotchi
       def render_current_turn(turn)
         @running = !turn.nil?
         @joined_mid_turn = @running
+        # A turn running at the join: the status row's steer hint.
+        @status.update(running: @running)
         return unless turn
 
         continues = turn[:prompt].nil?

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -179,7 +179,8 @@ module Samagotchi
         end
         # No answer: chi's muted notice, never an empty answer line.
         if summary[:empty_answer]
-          @view.print_line(@view.format_empty_answer_line(summary.dig(:empty_answer, :retries)))
+          empty = summary[:empty_answer]
+          @view.print_line(@view.format_empty_answer_line(empty[:retries], empty[:refusal]))
         else
           @view.print_line(summary[:output])
         end

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -135,9 +135,10 @@ module Samagotchi
       end
 
       # "no answer: the model returned nothing (after 1 retry)", dim like the
-      # retry row: a turn that ended with no answer (TurnNote.empty_answer_line).
-      def format_empty_answer_line(retries)
-        paint(TurnNote.empty_answer_line(retries), 90)
+      # retry row: a turn that ended with no answer, or "no answer: refused
+      # by the provider (cyber)" for a +refusal+ (TurnNote.empty_answer_line).
+      def format_empty_answer_line(retries, refusal = nil)
+        paint(TurnNote.empty_answer_line(retries, refusal: refusal), 90)
       end
 
       # "↻ retrying (503) in 4.0s, 2/5": the live status while the provider

data/lib/samagotchi/terminal_ui/status_row.rb

@@ -28,7 +28,15 @@ module Samagotchi
       #   preloaded             its --memory list (shown until a turn
       #                         records them as used)
       #   muted                 its --mute list
-      FIELDS = %i[model default_model served parent_id children context used_memories preloaded muted].freeze
+      #   running               a turn runs: the row trails STEER_HINT
+      FIELDS = %i[model default_model served parent_id children context used_memories preloaded muted running].freeze
+
+      # The tail while a turn runs: where a typed line goes (the next step)
+      # and the two other choices. Dropped whole first when the row is cut.
+      STEER_HINT = " · typing goes in at the next step (/cut, /queue)"
+
+      # The turn events that end a turn (the hint goes).
+      TURN_END_EVENTS = %i[turn_completed turn_canceled turn_failed].freeze
 
       # @param surface [Surface] with #columns
       def initialize(surface)
@@ -77,13 +85,16 @@ module Samagotchi
 
       # Take what a turn event says about the row (the Engine's events in
       # the REPL, the Bridge's in attached mode): ctx, the memories used,
-      # the model the server served. Other events change nothing.
+      # the model the server served, whether a turn runs (the steer
+      # hint). Other events change nothing.
       def take_event(event)
         case event[:type]
         when :context_status then update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
         when :used_memories_updated then update(used_memories: Array(event[:used_memory_names]))
         when :generation_completed
           update(served: [event[:served_model], event[:requested_model], event[:served_expected_by]]) if event[:served_model]
+        when :turn_started then update(running: true)
+        when *TURN_END_EVENTS then update(running: false)
         end
       end
 
@@ -119,11 +130,21 @@ module Samagotchi
                     status_context_text(estimate: @values[:context]),
                     status_memory_text(Array(@values[:used_memories]) | Array(@values[:preloaded]), MEMORY_LIMIT),
                     status_memory_text(@values[:muted], MEMORY_LIMIT, label: "muted")].reject(&:empty?)
-        status_rows(segments, width)
+        status_rows(with_steer_hint(segments, width), width)
       end
 
       private
 
+      # +segments+ with STEER_HINT after the last while a turn runs, when
+      # the whole row fits +width+ with it: on a narrow terminal the hint
+      # goes first, whole, before anything else is cut.
+      def with_steer_hint(segments, width)
+        return segments unless @values[:running] && segments.any?
+        return segments if "status> #{segments.join(" | ")}#{STEER_HINT}".length > width
+
+        segments[0..-2] + ["#{segments.last}#{STEER_HINT}"]
+      end
+
       # `⑂ 2 running · 1 waiting`, the counts there are; "" with neither (no
       # children, or all ended). Not "not reported": a REPL parent is never
       # given its children's replies (no wakes there), and a worker moves

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.64.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,14 +1785,18 @@ 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);
@@ -1756,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
@@ -2118,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 () => {