samagotchi 0.84.0 → 0.85.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5e180d3ef3bc5dd32bd646d471b1ef88e11083aba16f6908a8c4588b0173b4c
-  data.tar.gz: b337e5690f3094d5f3b0e8528aacbedab734211c9be60ed5ff314f6eb4299ea7
+  metadata.gz: d533709ed93dac5a1a65a9c023e83a50aef691542faffb1cdeefe6bfca51b5f1
+  data.tar.gz: 90cbb0c9256e751f64a36b854d6049098b694a8824a34230895e83eb383f8f74
 SHA512:
-  metadata.gz: 4ce619eccbfc69729b160a2b19c65d3b8e91d0f2b641fb6d4eb288d8fd12e9a147529745a8a3b5272270a2fabec6e597f423086c6574cb06f689816b32550568
-  data.tar.gz: 4a9922290d92cabab3aac30f17292119cc6e778243a7e1b57bd8260423a27446b34b978346056566619f8e358da8dabbd9e80f8bc3aa9fc198dab99e9b27b38c
+  metadata.gz: 90149bcdee28e2c2aa74c011d361aee78b652f4a0ef03c966a2fa11324181b67b8a926e3a1fe94d6d7cc8b92e62edf5d7fc67f444ebec0923fe58f7338c3c65d
+  data.tar.gz: 8884e65ab2e6a0506e15dab8ea701dda33f3a149dc6168e770ad2b885dadf7789f0d4cf2df8c22a258239b74f3da8d384c356cd72db2c66ff8154eb31819acea

data/CHANGELOG.md

@@ -8,6 +8,25 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.85.0] - 2026-10-18
+
+### Added
+
+- A message queued for after the running turn can be taken back before it runs: the × on its bubble in the web,
+  `/unqueue` in an attached terminal (its newest queued line). Its text comes back into the input to change and send
+  again. Every UI drops it, and a `chi send --queue --wait` on it ends with `removed` (exit 1). `/queue` is now listed
+  in the attached terminal's Tab and `/help` too.
+
+### Fixed
+
+- On a phone, a queued message's text gets the bubble's full width, with its origin and after-turn badge above it.
+- A plugin's `ctx.settings` reads a session's `--set` values again after a failed read, instead of keeping config.yml's
+  alone until the worker restarts.
+- A `before_generation` hook now runs before the generation starts (`:generation_started`) in both loops: a question
+  it asks (the cost-cap's) no longer counts in the generation's time or leaves an empty generation on Stop.
+
+Update with `chi update` (the system bundle 0.85.0), then restart `chi web`.
+
 ## [0.84.0] - 2026-10-18
 
 ### Added
@@ -3389,7 +3408,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.84.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.85.0...HEAD
+[0.85.0]: https://github.com/dm1try/samagotchi/compare/v0.84.0...v0.85.0
 [0.84.0]: https://github.com/dm1try/samagotchi/compare/v0.83.0...v0.84.0
 [0.83.0]: https://github.com/dm1try/samagotchi/compare/v0.82.0...v0.83.0
 [0.82.0]: https://github.com/dm1try/samagotchi/compare/v0.81.0...v0.82.0

data/docs/architecture.md

@@ -281,6 +281,15 @@ process that already owns the `Engine`); every worker starts it, and it exposes:
   saved messages, or the running turn's accumulator); answers once the
   task is gone: `200 {status, stop_reason, task_id}`, `404 task_not_found`, `409 not_running`.
   The worker names it in its sidecar features (`task_stop`).
+- `POST /session/:id/turn/dequeue` — `{enqueued_id, client_id?}`: take back a queued message
+  (one that waits for the running turn's end: `--queue`, Alt+Enter, `/queue TEXT`, or a message
+  with images) before a turn takes it (web route `POST /api/sessions/:id/turn/:enqueued_id/dequeue`,
+  the × on a queued bubble; `/unqueue` in the attached TUI). Under the event log, like its enqueue:
+  `SessionInbox.take_queued_input` claims the file as the drain does (one rename wins), deletes it,
+  leaves a tombstone (`input/removed/<enqueued_id>`, for `ReplyWait`'s `turn:`), and the Bridge
+  announces `:turn_dequeued`. `200 {status: "removed", enqueued_id, prompt}`, `409 already_started`
+  (a turn took it), `409 not_queued` (a next-step message: a drain may merge it any moment), `404
+  unknown_enqueued_id`. It never wakes the worker. The worker names it in its sidecar features (`unqueue`).
 - `POST /session/:id/relay` — the approval relay, on a delegated child's worker
   (`{action, relay_id, question_id}`): `opened` / `closed` (with a `reason`) set or clear the
   pending question's `relayed_to` mark (`QuestionDesk#annotate`, `:question_relay`); `answered`
@@ -404,7 +413,7 @@ session every 10 s, so a `kill -9` shows within a second. The summary (`Web::Ses
 shared with `/api/sessions` and the session view) carries `owner`, `project_root` and
 `bridge_up` (the sidecar is there *and* the lock is held: the page attaches its stream on it), and
 from that sidecar `worker_version` (the chi the worker runs) and `worker_features`
-(`Bridge::FEATURES`, what a client may ask of it beyond the routes: `restart`, `task_stop`, `reparent`,
+(`Bridge::FEATURES`, what a client may ask of it beyond the routes: `restart`, `task_stop`, `reparent`, `unqueue`,
 `delivery`, a worker that queues a message for after the turn; `SessionManager.deliver_turn` and
 the attached TUI refuse a queue to a worker without it, which would steer; `turn_ids`, a worker whose running
 turn's mark, continue turn and Stop carry the turn's `enqueued_id`, which `chi answer`, `chi send --wait` with no

data/docs/cli.md

@@ -607,6 +607,17 @@ REPL alike:
   sent after it still go in at the next step.
   At the open prompt (no turn running) `/cut TEXT` and `/queue TEXT` run TEXT
   as a normal prompt.
+- `/unqueue` (attached terminal) takes back the newest line this terminal
+  queued that hasn't started: `removed: <its first 60 characters>`, and its text
+  goes back into the input to change and send again (not over typed text: then
+  it is in the input history, ↑; not with input from a pipe; its images don't
+  come back), then the one before it on the next `/unqueue`; `(nothing queued: …)` when none waits,
+  `(not removed: it already started)` when its turn won the race, `(not removed:
+  it is already gone)` when another client removed it. Other terminals that
+  showed it say `(a queued message was removed)`; the web drops its bubble. A
+  worker older than it is not asked: `(/unqueue needs a newer worker: …)`. In
+  the plain REPL it answers with a note (its own queue is not touched), and the
+  web's composer points at the × on the bubble.
 - **The web composer** has a row above the text field in a session (always
   there, so the composer never changes height): the keys while idle, and while
   the turn runs the delivery line, where a message sent now goes in (`↳ goes in after this
@@ -616,7 +627,11 @@ REPL alike:
   **Alt+Enter** (Option+Enter) or `queue for after the turn` queues it, like
   `/queue TEXT`, and the bubble is dashed (`after this turn`), below the
   running turn's card with the commands queued for its end, until its turn
-  starts; `cut in now` cuts, like `/cut TEXT` (by click only: it throws the
+  starts; its **×** (`Remove from queue`, once the worker acked it) takes it
+  back before it runs, in every tab (a toast says why when it can't: it
+  already started, it is gone, no live worker), and puts its text back into an
+  empty composer to change and send again (a draft stays: the text is then in
+  the toast; images don't come back); `cut in now` cuts, like `/cut TEXT` (by click only: it throws the
   thinking away). Cut is enabled only while the step has streamed nothing but
   thinking and cutting is on for the model (the line says `cuts at about 0:25
   if you choose cut in now` until the thinking passes `steer_cut_after`, and

data/docs/configuration.md

@@ -1145,6 +1145,8 @@ Bridge acks `delivery: "queue"` while a turn runs (to an idle session the messag
 `next_step`). A worker whose sidecar doesn't name the `delivery` feature (older than queueing) would steer it, so the
 sender refuses it (`409 delivery_unavailable`, "restart it"), and so does a worker that answers the request with a
 400 `delivery_unavailable`.
+Until its turn starts, a queued message can be taken back: `/unqueue` in an attached terminal, the × on its bubble
+in the web ([sessions.md](sessions.md), *Removing a queued message*).
 
 ## Server errors
 

data/docs/hooks.md

@@ -52,7 +52,7 @@ The plugin class must respond to `#call(event)` — duck-typed, no base class re
 | `:session_start` | The first turn this chi process runs for the session (so again after `--resume`, a worker that idle-exited and woke, or a restart) | `{ type: :session_start, session_id: "..." }` |
 | `:before_turn` | Before each turn starts | `{ type: :before_turn, session_id: "...", prompt: "..." (nil on a continue), resumed: true \| false (true on a step-limit Continue, which resumes the run before it; false on every other turn, a reminder's or a wake's too), messages: [...] (the history before this turn) }` |
 | `:after_turn` | After a turn completed or was stopped once the model was asked (not after one that failed, was cut short by an interrupt signal (SIGINT), or was stopped before its `:before_turn` hooks) | `{ type: :after_turn, status: "completed" \| "canceled", present: (see [Presenting the answer](#presenting-the-answer-display-only)), refs: (see [Refs on the answer](#refs-on-the-answer-display-only)), messages: [...] (the conversation the turn stored; a cancelled or empty turn ends it with a `kind: turn_note` system message, and a context line is `kind: context`, see [sessions.md](sessions.md#notes-a-turn-leaves-for-the-model)) }` |
-| `:before_generation` | Before each LLM API call (both loops) | `{ type: :before_generation, iteration: N }` |
+| `:before_generation` | Before each LLM API call (both loops), before its `:generation_started`: the hook's time (a question it waits on) isn't the generation's | `{ type: :before_generation, iteration: N }` |
 | `:after_generation` | After LLM returns (both loops); not after a generation a hook cut (`stop_generation`) | `{ type: :after_generation, iteration: N, response: "...", messages: [...] (the conversation as sent) }` |
 | `:generation_progress` | While the response streams, in batches (see [Watching the stream](#watching-the-stream)) | `{ type: :generation_progress, iteration: N, thinking: "..." (new since the last fire), text: "..." (new visible text), thinking_chars: N, text_chars: N (this generation so far), elapsed_ms: N, restarted: true (only on the first fire after a dropped stream was asked again) }` |
 | `:before_tool_call` | Before tool dispatch (and before `tool_call_started`) | `{ type: :before_tool_call, iteration: N, call: {...}, params: "...", guardrail: Verdict, context: {...}, targets: {...}, blocked: false, block_reason: nil }` |

data/docs/internals/engine.md

@@ -179,7 +179,7 @@ KernelLoop#run(messages, max_iterations:, on_stream_event:, cancel_controller:,
   │ 1. Queued input (user lines, plugin steers) goes in at the boundary (Steer.inject!)
   │ 2. Format the conversation as prompt text (Prompt.format_with_images); a context
   │    guidance line goes on the tail when the window fills past a threshold
-  │ 3. Stream one generation (:generation_started, :generation_chunk, :generation_completed)
+  │ 3. Fire :before_generation, then stream one generation (:generation_started, :generation_chunk, :generation_completed)
   │ 4. Parse tool calls (ToolCallParser for the profile):
   │    → Gemma 4:  <|tool_call>call:NAME{params}<tool_call|>
   │    → Qwen 3.6: <tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>
@@ -466,7 +466,8 @@ persistent observers (`Engine#subscribe`), which get a copy with a monotonic `ev
 metrics, the debug log, the thinking tails, and in a worker the Bridge, which streams to the web and the attached
 TUI. Errors in the sink or an observer are caught; they never break the turn.
 
-`Engine#announce` puts an event that belongs to no turn (`ANNOUNCEABLE_EVENTS`: `turn_enqueued`, `card`,
+`Engine#announce` puts an event that belongs to no turn (`ANNOUNCEABLE_EVENTS`: `turn_enqueued`, `turn_dequeued`
+(a queued message taken back before it ran, `{enqueued_id, client_id}`: the remover's), `card`,
 `hook_notice`, `guardrail_warning`, `plugin_init_started`, and more) to the observers only.
 
 Turn events (the main ones; `Events` in `events.rb` keeps the shared sets):

data/docs/sessions.md

@@ -4,6 +4,8 @@ Sessions are plain files — no DB. Each session is `~/.local/state/samagotchi/s
 
 **Input files:** a message for a session's worker waits in `input/<timestamp>.json` (`SessionInbox.write_input`: `prompt`, `client_id`, `enqueued_id`, and `images`, `no_interrupt` and `delivery` when they apply; `delivery` is written only for `"queue"`). While a turn runs, the worker merges them at each step boundary in name order, except a queued one or one with images: those wait for the turn's end and run one turn each, in name order, and a file after them still merges (`Worker#pending_input_drain`). A queue is sent only to a worker whose `bridge.json` names the `delivery` feature; an older one would steer it, so `SessionManager.deliver_turn` refuses it (409 `delivery_unavailable`), and any other 4xx the Bridge answers is a refusal too, never a fallback file (except a 413, a body over its size limit: that one still goes in as a file, its `delivery` kept). **Reply files:** a turn that ends with visible text leaves its reply in `output/<timestamp>.txt`, or `output/<timestamp>-<enqueued_id>.txt` when the turn ran an input file with an id (`SessionInbox.write_output`), and the session's `last_turn` keeps that `enqueued_id`; so a wait for one queued message (`chi send --queue --wait`, `ReplyWait`'s `turn:`) finds its own turn's reply or end, never another turn's. The names still sort by time, and every reader takes `*.txt`.
 
+**Removing a queued message:** a message queued for after the running turn (`chi send --queue`, the web's Alt+Enter, `/queue TEXT` in a terminal), or one with images (it waits for the turn's end too), can be taken back while it still waits: the worker's Bridge (`POST /session/:id/turn/dequeue {enqueued_id}`, the `unqueue` feature) deletes its input file and every UI drops it (`:turn_dequeued`). It is a race with the turn's end, decided by the same rename the worker uses to take the file: once a turn took it the answer is `409 already_started` (it runs), and an id the worker no longer knows is `404 unknown_enqueued_id`. A plain message sent without `--queue` is not removable (`409 not_queued`): a running turn's next step may take it at any moment. A wait for its turn (`chi send --queue --wait`, a delegate follow-up's wait) ends at once with `removed` (the tombstone `input/removed/<enqueued_id>` says so), and a `chi -p` run whose queued prompt went ends with exit 1. The `200` carries the removed `prompt`: the web and the attached terminal put it back into the composer to edit (not its images). The images a removed message named stay in the session's `images/`. Not removable: a queued session command (`/queue /model x`: it waits in the worker, not in `input/`), a message in a stopped worker's inbox (the next worker runs it), and the plain REPL's (`--no-shared`) own queue.
+
 **Retention (file-based, opt-out via env):**
 
 | Env | Default | Purpose |
@@ -207,7 +209,7 @@ chi send --new --continues last:3fa2 -m "new day"      # the next link of 3fa2's
 - `--new` prints `<full id>  started` on stdout. With `--wait` that line (and the `sent` line for an existing session) goes to stderr, so stdout is exactly the answer: the reply of the turn the message started, in full. It is the worker's `output/` file, the same one `delegate` reads; a turn that ends with only tool calls and no text has none.
 - `--wait` takes one session: `--new` or one id. A session with a running turn is refused (`busy: a turn is running; wait or attach`, exit 1): the message would merge into it, and its reply would come back as the answer. `--queue --wait` is the way in: the message runs as a turn of its own after the running one, and the wait is for that turn alone (the ack's `enqueued_id` names its reply file and its `last_turn`), so the running turn's reply and end, and a question it asks meanwhile, are not the answer (it keeps waiting through them; its `--timeout` still applies); a question its own turn asks is (exit 3). Two queued waits each get their own turn's answer. A session waiting for an answer is still refused. `--format json` adds `delivery`: `queue`, or `next_step` when the running turn ended before the message went in (it then ran at once, and the answer is still its own).
 - Exit codes with `--wait`: 0 answered; 3 the turn waits for an answer from you (a question, a hook's question, a guardrail approval, or the step-limit question: see [chi as a sub-agent](sub-agent.md#the-step-limit)), and the session keeps waiting: stderr gets the whole question (`waiting for an answer (approval): …`, its text, the numbered options, whether free text is allowed) and how to answer it (`chi answer ID --question QID --option N`, or `chi --attach ID`, the web); 4 `--timeout S` passed with the turn still running (it goes on; wait again); 1 the turn ended without a reply (canceled, failed or empty), the worker failed or vanished, or the session was stopped; 130 on Ctrl-C, which leaves the turn running (`still running: chi --attach ID`). There is no default timeout.
-- `--format json` (with `--wait`) prints one JSON object on stdout however the wait ends, for a script or a parent agent (see [chi as a sub-agent](sub-agent.md)): `{"status":"answered","session_id":…,"text":…}`; `{"status":"question",…,"question":{"id","kind","header","text","options","multi_select","allow_freeform","approval"},"answer_with":"chi answer ID --question QID --option N"}`, where `kind` is `question` (the model's), `hook` or `approval` (with the tool, command, cwd, rule, reason and offered scopes); `{"status":"running",…,"detail":…}` (exit 4, and on Ctrl-C); and `failed`, `canceled`, `no_answer`, `error`, `worker_gone` or `stopped` with a `detail` line (exit 1); `failed` adds `error_kind` and `retryable`, `canceled` adds `cancel_reason` and `stopped_by`, when known. A failure before the wait (no such session, a busy one) is `error` too. A usage error (exit 2) prints no JSON.
+- `--format json` (with `--wait`) prints one JSON object on stdout however the wait ends, for a script or a parent agent (see [chi as a sub-agent](sub-agent.md)): `{"status":"answered","session_id":…,"text":…}`; `{"status":"question",…,"question":{"id","kind","header","text","options","multi_select","allow_freeform","approval"},"answer_with":"chi answer ID --question QID --option N"}`, where `kind` is `question` (the model's), `hook` or `approval` (with the tool, command, cwd, rule, reason and offered scopes); `{"status":"running",…,"detail":…}` (exit 4, and on Ctrl-C); and `failed`, `canceled`, `removed` (a `--queue --wait` message taken back before it ran), `no_answer`, `error`, `worker_gone` or `stopped` with a `detail` line (exit 1); `failed` adds `error_kind` and `retryable`, `canceled` adds `cancel_reason` and `stopped_by`, when known. A failure before the wait (no such session, a busy one) is `error` too. A usage error (exit 2) prints no JSON.
 - `--wait ID` with no message (no `-m`, nothing piped) sends nothing: it waits for the session's next reply and prints and exits as above. With a turn running, that turn's reply (its `interrupted_turn` mark names it), not a turn's queued behind it; with the step-limit question standing, the reply of the turn its Continue runs; with an idle session whose last turn already ended, that ended turn is the answer: its reply, or its end when it left no reply — a turn that finished in the gap between waits is reported, not waited for. With none of those (or a worker whose `bridge.json` lacks `turn_ids`), the next reply of any turn. A running session is fine (that is the point), so after exit 3, 4 or 130 an agent waits again this way while the user answers in the web or `chi --attach`; the question pending when it starts doesn't count again. An idle session with no worker waits until something wakes one. With `--new`, or two ids, it is a usage error (exit 2).
 - `--set BUNDLE.KEY=VALUE` (with `--new`, repeatable) gives the new session a bundle setting of its own, as `chi --set` does (see *Bundle settings* below): `chi send --new --set cost-cap.cap=3 -m "…"` starts it with a $3 cap. A bundle or key the installed bundles don't offer is a usage error (exit 2), as is `--set` without `--new`.
 - `--continues ID` (with `--new`) starts the next link of that session's chain instead (see *Session chains*): in its folder, on its model (or the one `--model` names), LLM context, thinking level, toolkit and bundle settings, so `--dir`, `--llm-context*`, `--thinking`, `--toolkit`, `--tool`, `--no-tool` and `--set` are refused beside it; `ID` may be a prefix or `last:ID`, the chain's latest link. Without a message the new link starts idle; `--wait` then has nothing to wait for (a usage error). It prints `<full id>  started (continues 3fa2c1d0)`, with `; 2 delegates moved` inside the parentheses when open delegates moved to it; a refusal (continued already, naming the next link; an open delegate that can't move; a turn running) is `chi send: refused: …`, exit 1, and a `--model` it can't start on is `chi send: could not start a session: …`, exit 1, nothing archived. A fallback to the default model (below) prints `chi send: warning: …`.

data/docs/sub-agent.md

@@ -59,7 +59,7 @@ Exit codes, both commands:
 | 0 | `not_continued` | (`chi answer`) a Stop answered the step-limit question; the turn's work so far stays |
 | 3 | `question` | chi waits for an answer: `question`, `answer_with` |
 | 4 | `running` | `--timeout` passed; the turn goes on, wait again |
-| 1 | `failed`, `canceled`, `limit`, `no_answer`, `error`, `worker_gone`, `stopped` | `detail` says what happened (`limit`: the turn ran out of steps and nobody can be asked, e.g. an older worker; `chi send ID -m '/continue yes'` continues it). `failed` adds `error_kind` (the provider error's kind: `credits`, `credits_held`, `rate_limited`, `server`, `auth`, `connection`, …) and `retryable` when known; `canceled` adds `cancel_reason` (`user`: a Stop in the web; `session_stopped`: a session stop, `chi sessions stop` or the web's; `hook`; `ctrl_c`; `manual`) and `stopped_by` (the hook that stopped it, e.g. `loop-guard`) when known |
+| 1 | `failed`, `canceled`, `limit`, `removed`, `no_answer`, `error`, `worker_gone`, `stopped` | `detail` says what happened (`limit`: the turn ran out of steps and nobody can be asked, e.g. an older worker; `chi send ID -m '/continue yes'` continues it; `removed`: the `--queue` message waited for was taken back before it ran, no turn ran for it). `failed` adds `error_kind` (the provider error's kind: `credits`, `credits_held`, `rate_limited`, `server`, `auth`, `connection`, …) and `retryable` when known; `canceled` adds `cancel_reason` (`user`: a Stop in the web; `session_stopped`: a session stop, `chi sessions stop` or the web's; `hook`; `ctrl_c`; `manual`) and `stopped_by` (the hook that stopped it, e.g. `loop-guard`) when known |
 | 2 | (no JSON) | usage error, or an option the question doesn't offer |
 | 130 | `running` | Ctrl-C; the turn goes on |
 

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -232,6 +232,9 @@ module Samagotchi
           queued[:images] = event[:images] if event[:images]
           queued[:delivery] = event[:delivery] if event[:delivery]
           @queued << queued
+        # Taken back before it ran (Bridge#handle_dequeue_turn).
+        when :turn_dequeued
+          dequeue([{ enqueued_id: event[:enqueued_id] }])
         when :recap_ready
           # One collected just as a turn started describes the chat before it.
           @recap = event[:recap] unless @turn

data/lib/samagotchi/bridge.rb

@@ -517,7 +517,10 @@ module Samagotchi
     # turn's end (Delivery::QUEUE_FEATURE). A worker without it would steer.
     # turn_ids: the running turn's checkpoint mark, a continue turn and a
     # Stop's last_turn carry the turn's enqueued_id (ReplyWait.own_turn).
-    FEATURES = ["restart", "task_stop", "reparent", Delivery::QUEUE_FEATURE, ReplyWait::TURN_IDS_FEATURE].freeze
+    # unqueue: POST turn/dequeue (#handle_dequeue_turn) takes a queued
+    # message back before it runs.
+    FEATURES = ["restart", "task_stop", "reparent", Delivery::QUEUE_FEATURE, ReplyWait::TURN_IDS_FEATURE,
+                SessionInbox::UNQUEUE_FEATURE].freeze
 
     # The routes, by method and what follows /session/:id/: a handler takes
     # the session id and the request body and returns [headers, status, body].
@@ -528,6 +531,7 @@ module Samagotchi
       %w[POST answer] => :handle_answer,
       %w[POST question/dismiss] => :handle_dismiss_question,
       %w[POST turn] => :handle_post_turn,
+      %w[POST turn/dequeue] => :handle_dequeue_turn,
       %w[POST command] => :handle_command,
       %w[POST exit] => :handle_exit_request,
       %w[POST recap] => :handle_recap,
@@ -932,6 +936,55 @@ module Samagotchi
       [{}, 202, ack]
     end
 
+    # POST /session/:id/turn/dequeue {enqueued_id, client_id?, deadline?}:
+    # take back a queued message (one that waits for the running turn's
+    # end: a queue or an image message) before a turn takes it. With the
+    # event log held, as its enqueue was, so :turn_dequeued always follows
+    # its :turn_enqueued; the file is claimed as the drain claims it (one
+    # rename wins), deleted, and its tombstone left for a wait on its turn
+    # (SessionInbox.take_queued_input). It never wakes the worker.
+    # 200 {status: "removed", enqueued_id, prompt}; 409 already_started (a
+    # turn took it, or the snapshot still lists it with no file left: taken,
+    # not announced yet), 409 not_queued (a next-step message: a drain may
+    # merge it any moment); 404 unknown_enqueued_id (never not_found: that is
+    # the unrouted path's, what a worker older than the route answers);
+    # 408 past its +deadline+ (see #handle_post_turn), nothing removed.
+    def handle_dequeue_turn(session_id, body)
+      parsed = parse_json(body)
+      return [{ "Allow" => "POST" }, 400, { error: "invalid_json" }] unless parsed.is_a?(Hash)
+
+      id = fetched(parsed, "enqueued_id").to_s.strip
+      return [{ "Allow" => "POST" }, 400, { error: "missing_fields", detail: "enqueued_id required" }] if id.empty?
+
+      deadline = fetched(parsed, "deadline")
+      return BAD_DEADLINE unless deadline_valid?(deadline)
+
+      client_id = fetched(parsed, "client_id")
+      taken, input = @engine.synchronize_events do
+        raise IntakeClosed if stopped?
+        next [:expired, nil] if expired?("dequeue_expired", deadline, sid: session_id, enqueued_id: id)
+
+        SessionInbox.take_queued_input(session_dir, id).tap do |status, _|
+          @engine.announce(type: :turn_dequeued, enqueued_id: id, client_id: client_id) if status == :removed
+        end
+      end
+      dequeue_reply(taken, id, input)
+    end
+
+    def dequeue_reply(taken, id, input)
+      case taken
+      when :removed then [{}, 200, { status: "removed", enqueued_id: id, prompt: input.prompt.to_s, session_id: @session_id }]
+      when :expired then deadline_passed("removal")
+      when :not_queued
+        [{}, 409, { error: "not_queued", detail: "only a message queued for after the turn can be removed", enqueued_id: id }]
+      when :claimed then [{}, 409, { error: "already_started", enqueued_id: id }]
+      else
+        return [{}, 409, { error: "already_started", enqueued_id: id }] if @accumulator.queued.any? { |q| q[:enqueued_id] == id }
+
+        [{}, 404, { error: "unknown_enqueued_id", enqueued_id: id }]
+      end
+    end
+
     # Read-only snapshot surface. AC #4: too-old reconnects re-derive state
     # from here.
     def handle_state(_session_id, _body = nil)

data/lib/samagotchi/bridge_client.rb

@@ -132,6 +132,18 @@ module Samagotchi
       post("question/dismiss", { id: id, deadline: deadline }, read_body: true)
     end
 
+    # POST /session/:id/turn/dequeue: take back a queued message (one that
+    # waits for the running turn's end) before it runs. 200 {status:
+    # "removed", enqueued_id, prompt}; 409 already_started (a turn took
+    # it) or not_queued (a next-step message); 404 unknown_enqueued_id; a
+    # 404 not_found: a worker older than the route (its sidecar lacks
+    # "unqueue"); 408 = too late.
+    # @param client_id [String, nil] the removing UI, in its :turn_dequeued
+    # @return [Response]
+    def dequeue(enqueued_id:, client_id: nil)
+      post("turn/dequeue", { enqueued_id: enqueued_id, client_id: client_id, deadline: deadline }, read_body: true)
+    end
+
     # POST /session/:id/turn. 202 = queued (body carries the enqueued_id the
     # Bridge also announced in :turn_enqueued), 408 deadline_passed = the
     # Bridge read it too late and dropped it (see DEADLINE_SHARE).

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.84.0
+version: 0.85.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/engine.rb

@@ -762,7 +762,7 @@ module Samagotchi
     # Event types #announce accepts: facts about the session's input queue,
     # a failed turn's prompt handed back and the continue offer, which live
     # UIs need in the event log, emitted outside any turn's stream.
-    ANNOUNCEABLE_EVENTS = %i[turn_enqueued input_merged prompt_restored continue_offered continue_resolved
+    ANNOUNCEABLE_EVENTS = %i[turn_enqueued turn_dequeued input_merged prompt_restored continue_offered continue_resolved
                              command_queued command_ran context_added card hook_notice guardrail_warning
                              plugin_init_started plugin_init_finished].freeze
 

data/lib/samagotchi/kernel_loop.rb

@@ -372,6 +372,11 @@ module Samagotchi
     # Ends with its :generation_completed (and, unless cut, the
     # after_generation hook).
     def generate(turn, request)
+      # Before the generation starts: a hook that waits (a question) isn't
+      # the generation's time, and a Stop there leaves none started.
+      fire_hook(:before_generation, { type: :before_generation, iteration: turn.iteration }) if @hooks
+      raise Client::RequestCancelled, turn.cancel_controller.reason if turn.cancel_controller&.cancelled?
+
       # Each ask splits its own stream (run_generation rebuilds the
       # splitter), so one that ended inside a thought or a tool call doesn't
       # leave the next one "inside" it.
@@ -383,7 +388,6 @@ module Samagotchi
       # streamed, for the log (a stuck thinking generation shows as
       # thinking_chars=N content_length=…).
       generation = Generation.new(usage: nil, served_model: nil, streamed_thinking: 0)
-      fire_hook(:before_generation, { type: :before_generation, iteration: turn.iteration }) if @hooks
       buffer_mark = generation.buffer_mark = turn.buffer.length
       # A cancel salvages only this generation's thinking: the earlier
       # steps' is on their own messages already.

data/lib/samagotchi/llm/chat_loop.rb

@@ -655,10 +655,14 @@ module Samagotchi
           @loop.apply_llm_context!(@conversation, context: @context, emit: method(:emit))
           window = @window = @loop.context_window(@model_name)
           observe_context(iteration, window)
+          # Before the generation starts: a hook that waits (a question)
+          # isn't the generation's time, and a Stop there leaves none started.
+          @loop.fire_hook(:before_generation, { type: :before_generation, iteration: iteration })
+          return [@cancel_controller.reason, "", ""] if @cancel_controller&.cancelled?
+
           retry_generation = @empty_retry.take_sampling!
           emit(type: :generation_started, iteration: iteration, context_window_tokens: window&.tokens,
                context_window_source: window&.source, price: @loop.price&.to_h)
-          @loop.fire_hook(:before_generation, { type: :before_generation, iteration: iteration })
           streamed = +""
           thought = +""
           generation_controller = nil

data/lib/samagotchi/log_subscriber.rb

@@ -16,6 +16,7 @@ module Samagotchi
     # One line each, with a few of their own fields (never text).
     ANNOUNCED = {
       turn_enqueued: %i[enqueued_id client_id],
+      turn_dequeued: %i[enqueued_id client_id],
       command_queued: %i[command_id client_id],
       command_ran: %i[command_id client_id status],
       input_merged: %i[count],

data/lib/samagotchi/parent_report.rb

@@ -34,8 +34,9 @@ module Samagotchi
     # @param result [ReplyWait::Result]
     # @return [String] answered, question, failed, canceled, limit (the
     #   turn ran out of iterations, nobody asked), not_continued (a Stop
-    #   answered the step-limit question), no_answer, error, worker_gone,
-    #   stopped or running
+    #   answered the step-limit question), removed (the queued message was
+    #   taken back before it ran), no_answer, error, worker_gone, stopped
+    #   or running
     def status(result)
       case result.status
       when :done then "answered"
@@ -46,6 +47,7 @@ module Samagotchi
         when "canceled" then "canceled"
         when "exhausted" then "limit"
         when "not_continued" then "not_continued"
+        when "removed" then "removed"
         else "no_answer"
         end
       when :error then "error"
@@ -258,6 +260,7 @@ module Samagotchi
       when "canceled" then "the turn was canceled"
       when "completed" then "the turn ended with no visible answer"
       when "not_continued" then "the turn was not continued (Stop); its work so far stays"
+      when "removed" then "the queued message was removed before it ran; no turn ran for it"
       when "exhausted"
         "the turn ran out of iterations#{" (#{result.limit} steps)" if result.limit} before it answered; " \
           "chi send #{session_id} -m '/continue yes' continues it, a message drops it"

data/lib/samagotchi/plugin/context.rb

@@ -111,8 +111,9 @@ module Samagotchi
         cached = @session_settings
         return cached.last if cached && cached.first == id
 
-        merged = id ? overlay(@settings, session_values) : @settings
-        @session_settings = [id, merged].freeze
+        values = session_values(id) if id
+        merged = id ? overlay(@settings, values || {}) : @settings
+        @session_settings = [id, merged].freeze unless id && values.nil?
         merged
       end
 
@@ -435,14 +436,17 @@ module Samagotchi
         nil
       end
 
-      # The session's own values for this bundle ({} without any, or when
-      # the Host can't tell them).
-      def session_values
+      # The session's own values for this bundle ({} without any; nil when
+      # the Host couldn't tell them, so #settings can retry).
+      def session_values(id)
         values = @host.setup&.call&.bundle_settings
         values.is_a?(Hash) ? values.fetch(@bundle, {}) : {}
       rescue StandardError => e
-        @log.warn("session_settings_unread", error: "#{e.class}: #{e.message}")
-        {}
+        unless (@session_settings_unread ||= {}).key?(id)
+          @session_settings_unread[id] = true
+          @log.warn("session_settings_unread", error: "#{e.class}: #{e.message}")
+        end
+        nil
       end
 
       def overlay(config, values)

data/lib/samagotchi/reply_wait.rb

@@ -35,7 +35,9 @@ module Samagotchi
     #   reply (:no_reply): "failed", "canceled", "completed" (empty),
     #   "exhausted" (it ran out of iterations, with nobody asked whether to
     #   continue) or "not_continued" (a Stop answered the step-limit
-    #   question; no turn ran), from the session's last_turn; nil when unknown. With
+    #   question; no turn ran), from the session's last_turn, or "removed"
+    #   (turn:'s queued input was taken back before it ran, its tombstone:
+    #   SessionInbox.removed?; no turn ran); nil when unknown. With
     #   "failed", text is the failure's summary when the turn note has one.
     # @!attribute limit [Integer, nil] the iteration limit an "exhausted"
     #   turn ran out at
@@ -132,6 +134,11 @@ module Samagotchi
           claimed = waiting.nil?
         end
         session = Session.load(id, state_dir: state_dir)
+        # Taken back before it ran (POST turn/dequeue): no turn will come.
+        if turn && claimed && !seen_own && SessionInbox.removed?(session_dir, turn)
+          return Result.new(status: :no_reply, outcome: "removed", session: session)
+        end
+
         if turn && !seen_own && session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == turn
           seen_own = true
           own_base = session.last_turn&.ended_at

data/lib/samagotchi/session_commands.rb

@@ -123,13 +123,16 @@ module Samagotchi
       # /cut TEXT and /queue TEXT while a turn runs: a delivery the UIs parse
       # themselves (ComposerRoute.steer_choice) before any command check; the
       # entries exist for Tab completion and /help. The web composer sends
-      # /cut too. /queue is a real after-the-turn list only in the local
-      # REPL (the attached TUI's worker doesn't skip queued files yet), so
-      # it is offered there.
+      # /cut too (its queue is Alt+Enter). Both terminals queue: the REPL in
+      # its own list, the attached TUI's worker in its input files.
       registry.register("/cut", "cut the running generation and go in now (/cut TEXT)",
                         local: true, uis: %i[repl attached web], match: ->(text) { text.casecmp?("/cut") || text.match?(%r{\A/cut\s+\S}) })
       registry.register("/queue", "run as the next turn after this one (/queue TEXT)",
-                        local: true, uis: [:repl], match: ->(text) { text.casecmp?("/queue") || text.match?(%r{\A/queue\s+\S}) })
+                        local: true, uis: %i[repl attached], match: ->(text) { text.casecmp?("/queue") || text.match?(%r{\A/queue\s+\S}) })
+      # Takes back the newest message this attached TUI queued, before it
+      # runs (the worker's POST turn/dequeue); the web has × on the bubble.
+      registry.register("/unqueue", "remove your newest queued message before it runs", local: true, uis: [:attached],
+                                                                                          match: ->(text) { text.casecmp?("/unqueue") })
       registry
     end
 

data/lib/samagotchi/session_inbox.rb

@@ -6,6 +6,7 @@ require "time"
 require "securerandom"
 require_relative "atomic_file"
 require_relative "delivery"
+require_relative "log"
 require_relative "session"
 
 module Samagotchi
@@ -276,5 +277,72 @@ module Samagotchi
     rescue Errno::ENOENT, Errno::EACCES
       nil
     end
+
+    # Where a removed queued input leaves its tombstone: input/removed/<id>,
+    # an empty file outside the *.json glob, so a wait for that input's
+    # turn (ReplyWait's turn:) learns it will never run (#removed?).
+    REMOVED_DIR = "removed"
+    # The worker's sidecar feature for POST turn/dequeue (Bridge::FEATURES).
+    UNQUEUE_FEATURE = "unqueue"
+
+    # Take back the unclaimed input file carrying +enqueued_id+ before a
+    # turn takes it (the Bridge's POST turn/dequeue, under the event log):
+    # only one that waits for the turn's end (a queue or an image message,
+    # #waits_for_turn_end?); a next-step file may be merged at any boundary.
+    # The file is claimed first, as the drain does (the rename is the race's
+    # one winner), then deleted, and its tombstone written.
+    # @return [Array(Symbol, Input)] [:removed, the input it held],
+    #   [:not_queued, nil] for a next-step file, [:claimed, nil] when a
+    #   turn took it (its *.json.processing is there), [:none, nil] for
+    #   none
+    def self.take_queued_input(session_dir, enqueued_id)
+      id = enqueued_id.to_s
+      return [:none, nil] if id.empty?
+
+      find_new_input_files(session_dir).sort.each do |file|
+        data = JSON.parse(File.read(file))
+        next unless data.is_a?(Hash) && data["enqueued_id"] == id
+        return [:not_queued, nil] unless Array(data["images"]).any? || Delivery.queue?(data["delivery"])
+
+        claimed = claim_input_file(file) or return [:claimed, nil]
+        input = read_input(claimed)
+        mark_removed(session_dir, id)
+        FileUtils.rm_f(claimed)
+        return [:removed, input]
+      rescue JSON::ParserError, SystemCallError
+        next
+      end
+      claimed_input?(session_dir, id) ? [:claimed, nil] : [:none, nil]
+    end
+
+    # Whether a claimed input file (*.json.processing: a turn's, now or
+    # left by a crash) carries +id+.
+    def self.claimed_input?(session_dir, id)
+      Dir.glob(File.join(session_dir, INPUT_DIR, "*.json.processing")).any? do |file|
+        data = JSON.parse(File.read(file))
+        data.is_a?(Hash) && data["enqueued_id"] == id
+      rescue JSON::ParserError, SystemCallError
+        false
+      end
+    end
+    private_class_method :claimed_input?
+
+    def self.mark_removed(session_dir, id)
+      return unless ENQUEUED_ID_NAME.match?(id)
+
+      dir = File.join(session_dir, INPUT_DIR, REMOVED_DIR)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, id), "")
+    rescue SystemCallError => e
+      Log.warn(:bridge, "removed_tombstone_write_failed", error: e.class.name, msg: e.message)
+    end
+    private_class_method :mark_removed
+
+    # @return [Boolean] whether the queued input +enqueued_id+ was removed
+    #   before it ran (#take_queued_input's tombstone)
+    def self.removed?(session_dir, enqueued_id)
+      id = enqueued_id.to_s
+      ENQUEUED_ID_NAME.match?(id) && File.exist?(File.join(session_dir, INPUT_DIR, REMOVED_DIR, id))
+    end
   end
 end

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -5,6 +5,7 @@ require_relative "../composer_route"
 require_relative "event_renderer"
 require_relative "formatting"
 require_relative "../prompt_history"
+require_relative "../session_inbox"
 require_relative "attached_view"
 require_relative "status_row"
 require_relative "input_support"
@@ -149,6 +150,10 @@ module Samagotchi
         # Prompts this run sent, by enqueued_id: only those come back into
         # the input when their turn fails (a replayed event must not).
         @sent_ids = Set.new
+        # This run's prompts queued for after the running turn (their ack
+        # said queue), oldest first, until their turn starts or they are
+        # removed: /unqueue takes back the newest.
+        @my_queued = []
         @wait_at_eof = wait_at_eof
         # Sent and not ended yet (by enqueued_id), the ones merged into the
         # running turn, whether the input has ended, and whether one of this
@@ -260,6 +265,7 @@ 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_dequeued then turn_dequeued(event)
         when :turn_started
           @status.take_event(event)
           start_turn(event)
@@ -419,6 +425,8 @@ module Samagotchi
           show_stats
         elsif local == :recap
           show_recap
+        elsif local == :unqueue
+          unqueue_newest
         elsif route.kind == :command
           # The history keeps !cmds, as the REPL's does (prompts: #send_prompt).
           persist_recent_history(text) if PromptHistory.shell_line?(text)
@@ -620,6 +628,58 @@ module Samagotchi
       QUEUE_RUNS_NOW = "(the turn had ended: runs as the next turn)"
       # /queue to a worker from before queueing, which would steer it.
       QUEUE_NEEDS_NEWER_WORKER = "(/queue needs a newer worker: restart it with chi sessions restart, then send again)"
+      UNQUEUE_NEEDS_NEWER_WORKER = "(/unqueue needs a newer worker: restart it with chi sessions restart)"
+      NOTHING_QUEUED = "(nothing queued: /queue TEXT queues a message for after the running turn)"
+      UNQUEUE_REFUSED = { "already_started" => "(not removed: it already started)",
+                          "unknown_enqueued_id" => "(not removed: it is already gone)",
+                          "not_queued" => "(not removed: it goes in at the next step)" }.freeze
+
+      # /unqueue: take back the newest prompt this run queued for after the
+      # turn, before it runs (POST turn/dequeue). Its :turn_dequeued comes
+      # to every UI; here the reply says what became of it. A worker whose
+      # sidecar lacks "unqueue" is not asked.
+      def unqueue_newest
+        return @screen.commit(UNQUEUE_NEEDS_NEWER_WORKER) unless worker_unqueues?
+
+        id = @my_queued.last
+        return @screen.commit(NOTHING_QUEUED) unless id
+
+        reply = @client.dequeue(enqueued_id: id, client_id: @client_id)
+        error = reply.json&.fetch("error", nil)
+        return @screen.commit(UNQUEUE_NEEDS_NEWER_WORKER) if reply.status == 404 && error == "not_found"
+
+        # Removed, started or gone: no longer this run's to take back.
+        @my_queued.delete(id) if [200, 404, 409].include?(reply.status)
+        return unqueued(reply.json&.fetch("prompt", nil).to_s) if reply.status == 200
+
+        @screen.commit(UNQUEUE_REFUSED[error] || "could not remove the queued message (#{[reply.status, error].compact.join(" ")})")
+      rescue SystemCallError, IOError => e
+        @screen.commit("could not remove the queued message (#{worker_down(e)})")
+      end
+
+      # The removal's line, and its text back in the input to change and
+      # send again (as a failed turn's prompt comes back, #restore_prompt):
+      # not over typed text, and not for lines from a pipe. Its images are
+      # not put back.
+      def unqueued(prompt)
+        @screen.commit("removed: #{first_line_clip(prompt)}")
+        return if @wait_at_eof || prompt.strip.empty?
+
+        @screen.commit("(the removed message is in the input history: ↑)") unless @reader&.prefill(prompt)
+      end
+
+      def first_line_clip(text, max = 60)
+        line = text.to_s.strip.lines.first.to_s.strip
+        line.length > max ? "#{line[0, max]}…" : line
+      end
+
+      # Whether the attached worker takes queued messages back (its sidecar
+      # names SessionInbox::UNQUEUE_FEATURE). No sidecar to read: true, its Bridge
+      # answers (an older one's 404 not_found says so).
+      def worker_unqueues?
+        sidecar = WorkerSidecar.read(Session.session_dir(@client.session_id, state_dir: @state_dir))
+        sidecar.nil? || sidecar.features.include?(SessionInbox::UNQUEUE_FEATURE)
+      end
 
       # A command queued for after the running turn (command_queued with
       # waits): its line now (another client's) and a note; its command_ran
@@ -760,6 +820,7 @@ module Samagotchi
           enqueued_id = reply.json&.fetch("enqueued_id", nil)
           @sent_ids << enqueued_id if enqueued_id
           @open_ids << enqueued_id if enqueued_id && @wait_at_eof
+          @my_queued << enqueued_id if enqueued_id && reply.json&.fetch("delivery", nil) == Delivery::QUEUE
           note = sent_note(reply.json, delivery: delivery, images: images, running: running)
           @screen.commit(note) if note
           return
@@ -1095,6 +1156,12 @@ module Samagotchi
 
       def render_snapshot(snapshot, reset:)
         @view.finish_thinking_spinner
+        queued = Array(snapshot[:queued])
+        known_queued = @my_queued.to_set
+        @my_queued = queued.filter_map do |entry|
+          id = entry[:enqueued_id]
+          id if id && (known_queued.include?(id) || (entry.key?(:client_id) && own?(entry[:client_id])))
+        end
         # A new worker's first snapshot is the session as it now stands.
         moved = @worker_changed
         reset ||= moved
@@ -1131,7 +1198,7 @@ module Samagotchi
         # A question between turns (the step-limit one) belongs to no turn.
         ask(snapshot[:pending_question]) if snapshot[:current_turn].nil? && snapshot[:pending_question]
         render_snapshot_cards(cards.select { |card| card[:current] }, joining: !reset)
-        Array(snapshot[:queued]).each do |entry|
+        queued.each do |entry|
           next if own?(entry[:client_id])
 
           @shown_enqueued << entry[:enqueued_id]
@@ -1453,10 +1520,31 @@ module Samagotchi
         @screen.commit(event[:delivery] == Delivery::QUEUE ? "#{line} #{QUEUED_NOTE}" : line)
       end
 
+      # A queued prompt was taken back before it ran (the web's ×, /unqueue
+      # in a terminal). One of this run's (wait_at_eof) will have no turn:
+      # it ends the wait, as a failed one does. Another client's shown
+      # line says so.
+      def turn_dequeued(event)
+        id = event[:enqueued_id]
+        @my_queued.delete(id)
+        if @open_ids.delete?(id)
+          if own?(event[:client_id])
+            @own_empty = true
+            @screen.commit("(removed before it ran)")
+          else
+            @own_failed = true
+            @screen.commit("(your queued message was removed before it ran)")
+          end
+        elsif @shown_enqueued.delete?(id)
+          @screen.commit("(a queued message was removed)")
+        end
+      end
+
       def start_turn(event)
         @running = true
         @joined_mid_turn = false
         origin = event[:origin] || {}
+        @my_queued.delete(origin[:enqueued_id])
         if event[:prompt].nil?
           # A continue turn (after the offer's yes) has no prompt to show; a
           # reminder turn shows its reminders (:reminder_injected).

data/lib/samagotchi/terminal_ui.rb

@@ -67,6 +67,8 @@ module Samagotchi
     COMMAND_QUEUED = "(queued: runs after this turn)"
     # /detach is the attached terminal's; the REPL owns its session.
     REPL_DETACH_NOTE = "(not attached: this session runs in this terminal; /exit ends it)"
+    # /unqueue is the attached terminal's (its worker's queued input files).
+    REPL_UNQUEUE_NOTE = "(/unqueue is the attached terminal's; here a line queued with /queue TEXT runs after the turn)"
     IMAGE_LINE_WAITS = "(a line with images runs as the next turn)"
 
     # Raised when another process (a `chi web` worker or another chi) owns the
@@ -1159,6 +1161,7 @@ module Samagotchi
       case local_command(input)
       when :stats then @surface.commit("\nmodel> session stats:\n#{format_session_metrics(@engine.stats_snapshot)}")
       when :recap then @surface.commit("\nmodel> #{handle_recap_command}")
+      when :unqueue then @surface.commit(REPL_UNQUEUE_NOTE)
       else return false
       end
       true

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -166,6 +166,7 @@ module Samagotchi
         ["GET", %r{\A/api/sessions/([^/]+)/output\z}, :handle_output],
         ["POST", %r{\A/api/sessions/([^/]+)/cancel\z}, :handle_cancel],
         ["POST", %r{\A/api/sessions/([^/]+)/tasks/([^/]+)/stop\z}, :handle_task_stop],
+        ["POST", %r{\A/api/sessions/([^/]+)/turn/([^/]+)/dequeue\z}, :handle_dequeue_turn],
         ["POST", %r{\A/api/sessions/([^/]+)/stop\z}, :handle_stop],
         ["POST", %r{\A/api/sessions/([^/]+)/restart\z}, :handle_restart],
         ["POST", %r{\A/api/sessions/([^/]+)/archive\z}, :handle_archive],
@@ -1339,6 +1340,33 @@ module Samagotchi
         error_response(404, "not_found", e.message)
       end
 
+      # POST /api/sessions/:id/turn/:enqueued_id/dequeue {client_id?}: the ×
+      # on a queued bubble takes the message back before it runs
+      # (Bridge#handle_dequeue_turn). Straight to the live worker, never
+      # through deliver_turn: a removal must not wake one, and a stopped
+      # worker's queued file is the next worker's (503 not_live). 200
+      # {status, enqueued_id, prompt}; 409 already_started / not_queued and
+      # 404 unknown_enqueued_id pass through; the rest as every relay.
+      def handle_dequeue_turn(req, id, enqueued_id)
+        @session_class.load(id, state_dir: default_state_dir)
+        body = request_body(req)
+        parsed = body.nil? || body.strip.empty? ? nil : parse_json(body)
+        client_id = (parsed["client_id"] if parsed.is_a?(Hash))
+
+        request = ->(client) { client.dequeue(enqueued_id: enqueued_id, client_id: client_id) }
+        relay(id, bridge_client(id), request, what: "the message was not removed", cant: "remove queued messages") do |reply|
+          body = reply.json || {}
+          case reply.status
+          when 200 then json_response(200, { status: body["status"], enqueued_id: enqueued_id, prompt: body["prompt"].to_s, session_id: id })
+          when 409 then json_response(409, { error: body["error"] || "already_started", detail: body["detail"], enqueued_id: enqueued_id, session_id: id }.compact)
+          when 404
+            json_response(404, { error: "unknown_enqueued_id", enqueued_id: enqueued_id, session_id: id }) if body["error"] == "unknown_enqueued_id"
+          end
+        end
+      rescue ArgumentError => e
+        error_response(404, "not_found", e.message)
+      end
+
       def handle_stop(_req, id)
         # Bounded, so a Rack thread isn't held long; a worker still exiting
         # after it just means an immediate resume finds it (rare).

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

@@ -92,6 +92,7 @@ import { currentGen } from "./turn_model.js";
 import { toolName } from "./activity.js";
 import { toastBottom } from "./toast_place.js";
 import { createToasts } from "./toasts.js";
+import { createUnqueue } from "./unqueue.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -1801,6 +1802,22 @@ composerEl.addEventListener("drop", (e) => {
   e.preventDefault();
   addImageFiles(files);
 });
+// The × on a message queued for after the turn takes it back (unqueue.js).
+const unqueue = createUnqueue({
+  sessionId: () => selected,
+  clientId,
+  toast: (text) => showToast(text),
+  // Edit: the removed text back into an empty composer (never over a draft).
+  putBack: (text) => {
+    if (promptEl.value.trim() || chips.length) return false;
+    openForVisit();
+    promptEl.value = text;
+    fitPrompt();
+    promptEl.focus();
+    return true;
+  },
+});
+turnRoots().forEach((root) => root.addEventListener("click", (e) => { unqueue.onClick(e); }));
 turnRoots().forEach((root) => root.addEventListener("click", (e) => {
   const img = e.target.closest("img.thumb");
   if (!img) return;

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

@@ -13,6 +13,13 @@ import { linkedLine } from "./notice_links.js";
 import { hookNoticeLabel, isReportClient, promptOps } from "./turn_events.js";
 import { drawCommandBubble } from "./commands.js";
 
+export function removeQueuedBubble(bubble) {
+  if (!bubble) return;
+  const slot = bubble.parentElement?.classList.contains("ts-queued") ? bubble.parentElement : null;
+  bubble.remove();
+  if (slot && slot.childElementCount === 0) slot.remove();
+}
+
 // A prompt that started a turn: not a line steered into a running one.
 export const TURN_PROMPT = ".bubble.user:not(.steered)";
 
@@ -205,6 +212,8 @@ export function createBubbles({
           setBubbleState(bubble, null);
           started = bubble;
         }
+      } else if (op.op === "remove") {
+        removeQueuedBubble(bubbleById(op.enqueuedId));
       } else if (op.op === "steer") {
         const bubble = bubbleById(op.enqueuedId);
         if (bubble) setBubbleState(bubble, "steered");

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

@@ -110,6 +110,7 @@ const WEB_LOCAL_REPLIES = {
   "/exit": "/exit: close the tab to leave; stop in the session bar stops the worker",
   "/quit": "/quit: close the tab to leave; stop in the session bar stops the worker",
   "/recap": "/recap: not in the web yet; a recap shows here by itself when you come back to an idle session, and /recap in a terminal (chi --attach) makes one now",
+  "/unqueue": "/unqueue: a terminal's command; here the × on a message queued for after the turn removes it",
   "/stats": "/stats: not in the web yet; each turn shows its time, the session bar the context use and speed (hover ctx for tokens and cost), and /stats in a terminal (chi --attach) has the rest",
 };
 

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

@@ -169,6 +169,17 @@ export function stopTask(id, taskId, opts = {}) {
   });
 }
 
+// Takes back a message queued for after the running turn (the × on its
+// bubble): 200 {status, enqueued_id, prompt}; 409 already_started /
+// not_queued, 404 unknown_enqueued_id, 503 no live worker.
+export function dequeueTurn(id, enqueuedId, { clientId = null } = {}, opts = {}) {
+  return api(`/api/sessions/${encodeURIComponent(id)}/turn/${encodeURIComponent(enqueuedId)}/dequeue`, {
+    method: "POST",
+    body: JSON.stringify(clientId ? { client_id: clientId } : {}),
+    ...opts,
+  });
+}
+
 // Hands the session to a new worker on the newest chi installed: 200
 // {status, from_version, version}, or 409 with the reason in words (detail).
 export function restartSession(id, opts = {}) {

data/lib/samagotchi/web/public/index.html

@@ -120,6 +120,12 @@ main{flex:1;display:flex;flex-direction:column;gap:16px;padding:16px;overflow:au
 .bubble.user.queued .state-badge::before{background:var(--accent);box-shadow:0 0 0 1px var(--accent-ring)}
 .bubble.user.steered .state-badge::before{background:var(--accent);box-shadow:0 0 0 1px var(--accent-ring)}
 .bubble.user.failed .state-badge::before{background:var(--danger);box-shadow:0 0 0 1px color-mix(in srgb,var(--danger) 40%,transparent)}
+/* The × on a message queued for after the turn (unqueue.js): only once the bubble has its enqueued_id; a 32px tap target around a small mark */
+.bubble.user .state-badge button.unqueue{position:relative;display:inline-flex;align-items:center;justify-content:center;width:16px;height:16px;margin:0 -3px 0 0;padding:0;border:0;border-radius:50%;background:transparent;color:var(--text-muted);font-size:14px;line-height:1;cursor:pointer}
+.bubble.user .state-badge button.unqueue::before{content:"\00d7"}
+.bubble.user .state-badge button.unqueue::after{content:"";position:absolute;inset:-8px}
+.bubble.user .state-badge button.unqueue:hover:not(:disabled){background:var(--danger-bg-dim);color:var(--danger-text);filter:none}
+.bubble.user:not([data-enqueued-id]) .state-badge button.unqueue{display:none}
 .bubble.user .origin-label{font-size:11px;color:var(--text-3);text-transform:uppercase;letter-spacing:.04em;flex-shrink:0}
 .bubble.user .user-message{flex:1;min-width:0}
 .bubble.user blockquote{border-left:3px solid var(--border-strong);padding-left:10px;color:var(--text-3);margin:2px 0 6px}
@@ -847,6 +853,9 @@ body.stage-view .turn-stage{position:absolute;left:0;right:0;bottom:100%;margin-
 .turn-stage .turn-work.outline>.gen.folded{display:block}
 .turn-stage .ts-cloud-body .gen:first-of-type{margin-top:0;border-top:0}
 @media(max-width:600px){
+  .bubble.user.queued[data-delivery="queue"]{flex-wrap:wrap}
+  .bubble.user.queued[data-delivery="queue"] .origin-label,.bubble.user.queued[data-delivery="queue"] .state-badge{order:0}
+  .bubble.user.queued[data-delivery="queue"] .user-message{order:1;flex-basis:100%}
   .ts-status{padding-left:10px}
   .ts-scroll{padding:8px 10px 10px}
   .ts-foot{padding:0 10px 10px}

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

@@ -410,6 +410,10 @@ export function createStageView({
     }
   }
 
+  function ensureQueuedSlot() {
+    if (!queuedSlot.isConnected) stage.appendChild(queuedSlot);
+  }
+
   function emptySlots() {
     for (const slot of [promptSlot, extras, answer, tail, cloudBody, queuedSlot, timingSlot]) slot.replaceChildren();
     slotsView.reset();
@@ -535,6 +539,7 @@ export function createStageView({
       // The lines still queued behind this turn went into the history with
       // the turn before (the hand-off at this turn_started, or an earlier
       // one): back below this turn's card, as a reload places them.
+      ensureQueuedSlot();
       queuedSlot.append(...waiting.filter((el) => !el.isConnected), ...historyEl.querySelectorAll(QUEUED_CHILDREN));
       view.turnStarted(data || {});
       show();
@@ -616,6 +621,7 @@ export function createStageView({
       const where = placeFor({ live: holding, handingOff: false, kind: placeKind(el) });
       if (where === "history") return false;
       if (where === "queued") {
+        ensureQueuedSlot();
         queuedSlot.appendChild(el);
         scheduleRefresh();
         return true;

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

@@ -116,6 +116,9 @@ export function createStreamHandlers(deps) {
       showSteers(data.steers);
     },
     turn_enqueued: (data) => applyPromptOps(data),
+    // A queued message taken back before it ran (the × here or in another
+    // tab, /unqueue in a terminal): its bubble goes, in every tab.
+    turn_dequeued: (data) => applyPromptOps(data),
     turn_started: (data) => keepFollowing(historyEl, () => {
       if (stream.takeGuess()) {
         // A replay of a turn the render drew: re-read and stream from there.

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

@@ -247,6 +247,8 @@ export function initWaitLine({ tasks } = {}) {
 //   tag   — this tab's own local echo gets its enqueued_id
 //   start — the bubble's turn started (drops the "queued" badge)
 //   steer — the bubble was merged into the running turn
+//   remove — the queued message was taken back before it ran (turn_dequeued,
+//           whoever removed it): its bubble goes
 //   report — the merge brought a delegate child's report (origin
 //           child:<id8>, no bubble anywhere): its text gets a labelled one
 // `known(enqueuedId)` says whether a bubble carries that id already;
@@ -276,6 +278,8 @@ export function promptOps(event, { myId, known, unmatchedMerge = false, wakeStar
       }
       return [withImages({ op: "add", enqueuedId: id, prompt: event.prompt, state: "started", label: clientLabel(origin.client_id) }, event.images)];
     }
+    case "turn_dequeued":
+      return event.enqueued_id ? [{ op: "remove", enqueuedId: event.enqueued_id }] : [];
     case "input_merged": {
       const ops = (event.origins || []).filter((o) => o && o.enqueued_id).map((o) =>
         known(o.enqueued_id) ? { op: "steer", enqueuedId: o.enqueued_id } : { op: "steer", enqueuedId: o.enqueued_id, unmatched: true },

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

@@ -184,9 +184,17 @@ export function badgeText(state, delivery = null) {
   return (state === "queued" && QUEUED_BADGES[delivery]) || BADGES[state];
 }
 
+// A message queued for after the turn (delivery queue) can be taken back
+// while it waits: the badge carries its ×, shown once the bubble has its
+// enqueued_id (style.css; an echo before its ack has none) and handled by
+// unqueue.js. Not a next-step line: a step boundary may merge it any moment.
 export function stateBadgeTemplate(state, delivery = null) {
   const text = badgeText(state, delivery);
-  return text ? html`<span class="state-badge">${text}</span>` : nothing;
+  if (!text) return nothing;
+  const remove = state === "queued" && delivery === "queue"
+    ? html`<button type="button" class="unqueue" title="Remove from queue" aria-label="Remove from queue"></button>`
+    : nothing;
+  return html`<span class="state-badge">${text}${remove}</span>`;
 }
 
 // A `!cmd`'s saved user message (the worker appends "!(<command>)\n<output>"

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

@@ -0,0 +1,56 @@
+// The × on a message queued for after the running turn (its badge,
+// turn_html.js stateBadgeTemplate): POST …/turn/:enqueued_id/dequeue
+// (Bridge#handle_dequeue_turn) takes it back before it runs. The bubble
+// goes with the turn_dequeued every tab gets (bubbles.js op "remove"), and
+// here at the 200 already. Its text comes back (edit): into an empty
+// composer, to change and send again; over a draft only in a toast (the
+// draft stays). Its images don't come back. A refusal keeps it and says why
+// in a toast. No confirm: nothing is lost. Pure but for the
+// injected calls, so `node --test` covers it; app.js binds onClick to the
+// turn roots.
+import { dequeueTurn as postDequeue } from "./data.js";
+import { removeQueuedBubble } from "./bubbles.js";
+
+// Why a removal didn't happen, in words.
+export function unqueueFailureText(error) {
+  if (error?.code === "already_started") return "Not removed: it already started";
+  if (error?.code === "not_queued") return "Not removed: it goes in at the running turn's next step";
+  if (error?.status === 404 && error?.code === "unknown_enqueued_id") return "Not removed: it is already gone";
+  return `Not removed: ${error?.message || "the worker did not answer"}`;
+}
+
+// The removed text in a toast, clipped.
+const SHOWN = 200;
+function clipped(text) {
+  const line = String(text || "").replace(/\s+/g, " ").trim();
+  return line.length > SHOWN ? `${line.slice(0, SHOWN)}\u2026` : line;
+}
+
+// +sessionId+ is read at each click (the open session); +clientId+ is this
+// tab's (the turn_dequeued names who removed it); +putBack(text)+ fills the
+// composer when it is empty and says whether it did.
+export function createUnqueue({ sessionId, clientId = null, dequeue = postDequeue, toast = () => {}, putBack = () => false }) {
+  // A click on a queued bubble's ×; any other click is left alone.
+  async function onClick(e) {
+    const button = e.target?.closest?.("button.unqueue");
+    if (!button || button.disabled) return null;
+    const bubble = button.closest(".bubble.user");
+    const enqueuedId = bubble?.dataset.enqueuedId;
+    const id = sessionId();
+    if (!enqueuedId || !id) return null;
+    e.stopPropagation?.();
+    button.disabled = true;
+    try {
+      const result = await dequeue(id, enqueuedId, { clientId });
+      removeQueuedBubble(bubble);
+      const text = String(result?.prompt || "");
+      if (text.trim() && !putBack(text)) toast(`Removed (your draft stays): ${clipped(text)}`);
+      return result;
+    } catch (error) {
+      if (button.isConnected) button.disabled = false;
+      toast(unqueueFailureText(error));
+      return null;
+    }
+  }
+  return { onClick };
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.84.0
+  version: 0.85.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -691,6 +691,7 @@ files:
 - lib/samagotchi/web/public/turn_html.js
 - lib/samagotchi/web/public/turn_model.js
 - lib/samagotchi/web/public/turn_view.js
+- lib/samagotchi/web/public/unqueue.js
 - lib/samagotchi/web/public/update_notice.js
 - lib/samagotchi/web/public/vendor/directive-helpers.js
 - lib/samagotchi/web/public/vendor/directive.js