webbee 0.3.9__tar.gz → 0.3.11__tar.gz

{webbee-0.3.9 → webbee-0.3.11}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.3.11
+
+- Type-ahead queue: send follow-ups while Webbee is working — they queue and
+  run after the current turn; the toolbar shows how many are waiting.
+- Up-arrow recalls your last message to edit and resend.
+
+## 0.3.10
+
+- Remote instructions picked up by an idle terminal now carry a dedup id, so
+  an at-least-once delivery can never run — or bill — the same instruction
+  twice.
+
 ## 0.3.9
 
 - Internal restructure: the session engine was split into focused modules

{webbee-0.3.9 → webbee-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.9
+Version: 0.3.11
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io

{webbee-0.3.9 → webbee-0.3.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.9"
+version = "0.3.11"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "MIT"

webbee-0.3.11/src/webbee/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.11"

{webbee-0.3.9 → webbee-0.3.11}/src/webbee/repl.py

@@ -214,14 +214,16 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         await _run_turn(line)
         return "continue"
 
-    async def _run_turn(line: str, surface: str = "") -> None:
+    async def _run_turn(line: str, surface: str = "", steer_iid: str = "") -> None:
         """ONE agent turn -- the SAME path for a typed line and an idle-steer
         pickup (liveness v2 §B), which threads the queued item's origin
-        `surface` into the turn so the kernel stamps provenance start-path.
-        Only the echo differs at the call sites: user_echo for a typed line,
-        foreign_turn for a remote one."""
+        `surface` (provenance) and dedup `steer_iid` (kernel dedup ring) into
+        the turn start-path. Only the echo differs at the call sites:
+        user_echo for a typed line, foreign_turn for a remote one."""
         _sink.begin_turn()
         kw = {"surface": surface} if surface else {}
+        if steer_iid:
+            kw["steer_iid"] = steer_iid
         try:
             text = await agent.run(line, _sink, marathon=not once,
                                    goal=(line if not once else ""), **kw)
@@ -236,11 +238,12 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
             return
         _sink.end_turn(text)
 
-    async def _steer_submit(text: str, surface: str) -> None:
+    async def _steer_submit(text: str, surface: str, steer_iid: str = "") -> None:
         """webbee.steer hands a drained remote instruction here: render it as
-        the remote user's own line, then run it as a normal turn."""
+        the remote user's own line, then run it as a normal turn (carrying the
+        item's dedup iid so the kernel can drop an at-least-once twin)."""
         _sink.foreign_turn(surface, "user", text)
-        await _run_turn(text, surface=surface)
+        await _run_turn(text, surface=surface, steer_iid=steer_iid)
 
     def _cancel_background() -> None:
         for _t in (watcher_task, steer_task):

{webbee-0.3.9 → webbee-0.3.11}/src/webbee/session.py

@@ -45,7 +45,7 @@ class AgentSession:
         return {"Authorization": f"Bearer {token}"}
 
     async def run(self, task: str, sink, *, marathon: bool = False, goal: str = "",
-                  surface: str = "") -> str:
+                  surface: str = "", steer_iid: str = "") -> str:
         import httpx
 
         from webbee.tools import LocalToolExecutor
@@ -72,6 +72,11 @@ class AgentSession:
             # [surface] tags). Additive-only -- a typed turn's body is
             # byte-identical to before.
             body["surface"] = surface
+        if steer_iid:
+            # steer-iid-dedup: a pickup also carries the queued item's dedup id
+            # so the kernel's ring can drop an at-least-once twin. Same
+            # additive-only contract -- a typed turn has none, key omitted.
+            body["steer_iid"] = steer_iid
         if marathon:
             body["marathon"] = True
             body["goal"] = goal

{webbee-0.3.9 → webbee-0.3.11}/src/webbee/steer.py

@@ -58,8 +58,9 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                           live_session_id=lambda: "",
                           interval: float = _POLL_INTERVAL) -> None:
     """Run forever (until cancelled): every ~`interval`s of idle time, drain
-    the pending-steer queue and hand the FIRST item to `submit(text, surface)`
-    -- the repl's normal turn path. Seams (all injected by the repl wiring):
+    the pending-steer queue and hand the FIRST item to
+    `submit(text, surface, steer_iid)` -- the repl's normal turn path. Seams
+    (all injected by the repl wiring):
       * is_busy()        -- sync; True while a turn is running. Checked BEFORE
                             the destructive fetch (never drain mid-turn) and
                             AGAIN right before submit (a locally-typed line
@@ -67,9 +68,12 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
                             backlog instead of being lost).
       * live_session_id()-- sync; the agent's gateway-issued session id once a
                             turn has run ("" before). Wins over derivation.
-      * submit(text, surface) -- async; renders the remote line and runs the
-                            turn. Runs INSIDE this task, so polling is
-                            naturally paused for the turn's whole duration."""
+      * submit(text, surface, steer_iid) -- async; renders the remote line and
+                            runs the turn. Runs INSIDE this task, so polling
+                            is naturally paused for the turn's whole duration.
+                            steer_iid = the queued item's dedup id ("" on an
+                            older gateway), threaded into the turn POST so the
+                            kernel's dedup ring can drop an at-least-once twin."""
     from webbee.thread import fetch_pending_steer
     derived = ""
     backlog: deque = deque()
@@ -97,7 +101,8 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
             if is_busy():
                 backlog.appendleft(item)  # a local line won the race -- defer, don't drop
                 continue
-            await submit(text, str(item.get("surface") or "telegram"))
+            await submit(text, str(item.get("surface") or "telegram"),
+                         str(item.get("iid") or ""))
             if _cancel_absorbed():
                 raise asyncio.CancelledError
         except asyncio.CancelledError:

{webbee-0.3.9 → webbee-0.3.11}/src/webbee/tui.py

@@ -2,11 +2,15 @@
 output_pane.py) fills the top; a bordered input box + toolbar are pinned at
 the very bottom and never move while the output scrolls (mouse wheel /
 PageUp). `run_session` also drives step-navigation (Up/Down + Enter) over the
-pinned box when the input is empty and no turn is running. Pure helpers
-(next_mode/build_toolbar) are unit-tested; the Application is TTY/headless-
-smoke verified. Grounded in prompt_toolkit 3.0.52."""
+pinned box when the input is empty and no turn is running; in every other
+state Up/Down recall submitted lines (readline-style), and Enter while a turn
+runs QUEUES the line (Claude-Code type-ahead: it runs after the current
+turn). Pure helpers (next_mode/build_toolbar/the *_action functions) are
+unit-tested; the Application is TTY/headless-smoke verified. Grounded in
+prompt_toolkit 3.0.52."""
 import asyncio
 import re
+from collections import deque
 
 from webbee.output_pane import OutputPane  # noqa: F401 — re-exported (webbee.tui.OutputPane)
 from webbee.render import _fmt_tokens
@@ -64,13 +68,16 @@ def next_mode(mode: str) -> str:
 
 def build_toolbar(mode: str, tokens: int, credits: int, *, busy: bool = False,
                   current: str = "", elapsed: float = 0.0, tools: int = 0,
-                  consent: bool = False) -> list:
+                  consent: bool = False, queued: int = 0) -> list:
     """The status line under the pinned input box, as prompt_toolkit formatted
     text (per-segment styled). Three states: consent (awaiting a reply), busy
     (a turn is running — an ANIMATED coloured spinner + the current action in
     accent, so it pops, not grey), and idle (mode value coloured PER MODE —
     default cyan / plan purple / autopilot yellow — + SESSION spend + the
-    Shift + TAB hint). Style classes are defined in run_session's Style."""
+    Shift + TAB hint). `queued` = type-ahead lines waiting to run after the
+    current turn; when >0 a subtle `⋯N queued` segment shows in the busy AND
+    idle states. Style classes are defined in run_session's Style."""
+    q = f" · ⋯{queued} queued" if queued else ""
     if consent:
         return [("class:tb.consent", "  approve? type y / n / a reply · Enter to send")]
     if busy:
@@ -79,13 +86,13 @@ def build_toolbar(mode: str, tokens: int, credits: int, *, busy: bool = False,
         if current:
             frags += [("class:tb.dim", " · "), ("class:tb.action", current)]
         frags.append(("class:tb.dim",
-                      f" · {elapsed:.0f}s · {tools} · {_fmt_tokens(tokens)} tok"
+                      f" · {elapsed:.0f}s · {tools} · {_fmt_tokens(tokens)} tok{q}"
                       f"   ·   Esc/Ctrl-C to stop"))
         return frags
     return [("class:tb.dim", "  mode: "),
             (f"class:tb.mode.{mode}", mode),
             ("class:tb.dim",
-             f"   ·   {_fmt_tokens(tokens)} tok · {_fmt_tokens(credits)} credits   ·   Shift + TAB: switch mode")]
+             f"   ·   {_fmt_tokens(tokens)} tok · {_fmt_tokens(credits)} credits{q}   ·   Shift + TAB: switch mode")]
 
 
 def _escape_action(sel: dict, turn: dict, is_busy, stop_turn, event, buf=None) -> None:
@@ -122,15 +129,67 @@ def _interrupt_action(turn: dict, is_busy, stop_turn, event) -> None:
         t.cancel()                          # cancel the running turn; dock survives
 
 
+def _submit_line(text: str, buf, pending, busy: bool, start) -> str:
+    """Route ONE non-empty submitted line (dependency-injected, same testing
+    philosophy as _escape_action). Records it into the buffer's history first
+    (up-arrow recall), then: busy → QUEUE it (Claude-Code type-ahead — the
+    line is never erased or dropped; it runs after the current turn); idle →
+    `start(text)` (today's normal submit). Returns "queued" | "started"."""
+    buf.history.append_string(text)
+    if busy:
+        pending.append(text)
+        return "queued"
+    start(text)
+    return "started"
+
+
+def _drain_pending(pending, start) -> bool:
+    """Turn-completion drain: pop the OLDEST queued type-ahead line and hand
+    it to `start` — the SAME path a typed line takes, so a persistent
+    marathon receives it as a `new_task` into the running session. ONE item
+    per completion; the rest stay queued FIFO (each finished turn drains the
+    next). Returns True when a drain happened."""
+    if not pending:
+        return False
+    start(pending.popleft())
+    return True
+
+
+def _arrow_up_action(event, buf, sel: dict, n: int, busy: bool) -> None:
+    """Up key. Step-navigation EXACTLY as before when steps exist + input is
+    empty + idle; in EVERY other state (busy, or text present, or no steps)
+    recall an older submitted line into the buffer (readline-style)."""
+    if n and not buf.text and not busy:
+        sel["i"] = (n - 1) if sel["i"] is None else max(0, sel["i"] - 1)
+        event.app.invalidate()
+        return
+    buf.history_backward()
+    event.app.invalidate()
+
+
+def _arrow_down_action(event, buf, sel: dict, n: int, busy: bool) -> None:
+    """Down key — mirror of _arrow_up_action: step-nav on the same exact
+    gate, otherwise cycle history forward."""
+    if n and not buf.text and not busy:
+        sel["i"] = 0 if sel["i"] is None else min(n - 1, sel["i"] + 1)
+        event.app.invalidate()
+        return
+    buf.history_forward()
+    event.app.invalidate()
+
+
 async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
                       is_busy, consent_pending, resolve_consent, steps_nav=None,
                       stop_turn=None) -> bool:
     """The full-screen dock: `pane` fills the top (scrollable), a bordered input
     box + toolbar are FIXED at the bottom. Enter either resolves a pending
     consent reply (ICNLI: raw verbatim) or starts a turn as a BACKGROUND task
-    (the box stays fixed during it). When `steps_nav` is given and the input is
-    empty and no turn is running, Up/Down move a step selection (toolbar shows
-    `step k/N`) and Enter expands it via `steps_nav["expand"]`; Esc clears it.
+    (the box stays fixed during it); while a turn runs, Enter QUEUES the line
+    (type-ahead — it starts right after the current turn; the toolbar shows
+    `⋯N queued`). When `steps_nav` is given and the input is empty and no turn
+    is running, Up/Down move a step selection (toolbar shows `step k/N`) and
+    Enter expands it via `steps_nav["expand"]`; Esc clears it. In every other
+    state Up/Down recall submitted lines (readline-style history).
     Returns True on clean exit; False if prompt_toolkit is unavailable (caller
     uses the plain fallback loop)."""
     try:
@@ -147,12 +206,24 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
 
     buf = Buffer(multiline=False)
     turn = {"task": None}
+    pending: deque = deque()   # type-ahead queue: lines submitted while a turn runs
+
+    def _start_turn(text):
+        turn["task"] = get_app().create_background_task(_run_turn(text))
 
     async def _run_turn(text):
+        done = False
         try:
             await on_line(text)
+            done = True
         finally:
             turn["task"] = None
+            if done:
+                # Type-ahead drain: the turn finished normally (an Esc/Ctrl-C
+                # stop counts — repl._run_turn absorbs the cancel) → submit the
+                # oldest queued line through the SAME path a typed line takes.
+                # A propagating exception (dock teardown) leaves the queue be.
+                _drain_pending(pending, _start_turn)
             get_app().invalidate()
 
     kb = KeyBindings()
@@ -178,9 +249,12 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
             idx, sel["i"] = sel["i"], None
             event.app.create_background_task(steps_nav["expand"](idx))
             return
-        if _busy_live() or not text.strip():
+        if not text.strip():
             return
-        turn["task"] = event.app.create_background_task(_run_turn(text))
+        # Non-empty line: record for up-arrow recall, then queue-while-busy
+        # (type-ahead — runs after the current turn) or start a turn now.
+        if _submit_line(text, buf, pending, _busy_live(), _start_turn) == "queued":
+            event.app.invalidate()             # toolbar shows the new depth
 
     @kb.add("s-tab")
     def _cycle(event):
@@ -206,17 +280,11 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
 
     @kb.add("up")
     def _step_up(event):
-        n = _nav_count()
-        if n and not buf.text and not _busy_live():
-            sel["i"] = (n - 1) if sel["i"] is None else max(0, sel["i"] - 1)
-            event.app.invalidate()
+        _arrow_up_action(event, buf, sel, _nav_count(), _busy_live())
 
     @kb.add("down")
     def _step_down(event):
-        n = _nav_count()
-        if n and not buf.text and not _busy_live():
-            sel["i"] = 0 if sel["i"] is None else min(n - 1, sel["i"] + 1)
-            event.app.invalidate()
+        _arrow_down_action(event, buf, sel, _nav_count(), _busy_live())
 
     @kb.add("escape")
     def _step_clear(event):
@@ -239,7 +307,8 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
         st = status()
         return build_toolbar(mode_getter(), st["tokens"], st["credits"], busy=st["busy"],
                              current=st["current"], elapsed=st["elapsed"],
-                             tools=st["tools"], consent=st["consent"])
+                             tools=st["tools"], consent=st["consent"],
+                             queued=len(pending))
 
     # Dynamic height: EXACTLY the rows the wrapped input needs (1→10), so the box
     # grows as you type and shrinks back — never a fixed huge block. Enter still

{webbee-0.3.9 → webbee-0.3.11}/tests/test_repl.py

@@ -590,10 +590,11 @@ class SurfaceAgent(FakeAgent):
     with a typed turn (the plain fallback read_line is sync)."""
     session_id = "marathon-user-1-rab12cd34ef56"
 
-    async def run(self, task, sink, *, marathon=False, goal="", surface=""):
+    async def run(self, task, sink, *, marathon=False, goal="", surface="",
+                  steer_iid=""):
         self.tasks.append(task)
         self.runs.append({"task": task, "marathon": marathon, "goal": goal,
-                          "surface": surface})
+                          "surface": surface, "steer_iid": steer_iid})
         await asyncio.sleep(0)
         return f"answer:{task}"
 
@@ -606,7 +607,7 @@ def test_steer_pickup_renders_remote_line_and_runs_tagged_turn(monkeypatch):
                          marathon=True, live_session_id=lambda: "", **kw):
         captured["marathon"] = marathon
         captured["live_sid"] = live_session_id()
-        await submit("push the fix", "telegram")
+        await submit("push the fix", "telegram", "iid-42")
 
     monkeypatch.setattr(SP, "poll_idle_steer", spy_poller)
 
@@ -617,9 +618,11 @@ def test_steer_pickup_renders_remote_line_and_runs_tagged_turn(monkeypatch):
     sink, agent = _run(read_line=_lines("hello", "again", "/exit"), agent=agent)
     # the remote user's line renders tagged with its origin surface...
     assert ("telegram", "user", "push the fix") in getattr(sink, "foreign", [])
-    # ...and the SAME turn path ran it, threading surface into the turn kwargs
+    # ...and the SAME turn path ran it, threading surface + the item's dedup
+    # iid into the turn kwargs (steer-iid-dedup pickup path)
     steer_runs = [r for r in agent.runs if r["task"] == "push the fix"]
     assert steer_runs and steer_runs[0]["surface"] == "telegram"
+    assert steer_runs[0]["steer_iid"] == "iid-42"
     assert steer_runs[0]["marathon"] is True          # normal marathon turn
     # a picked-up turn ends like any other -- end_turn fired, dock leaves busy
     assert "answer:push the fix" in sink.turns

{webbee-0.3.9 → webbee-0.3.11}/tests/test_session.py

@@ -961,3 +961,24 @@ def test_run_omits_surface_key_for_plain_typed_turns(monkeypatch):
     # to before -- no `surface` key at all.
     body = _run_turn_capture_body(monkeypatch)
     assert "surface" not in body
+
+
+def test_run_threads_steer_iid_into_session_post_body(monkeypatch):
+    # steer-iid-dedup pickup path: a picked-up remote instruction carries the
+    # queue entry's dedup id so the kernel ring can drop an at-least-once twin.
+    body = _run_turn_capture_body(monkeypatch, surface="telegram", steer_iid="iid-42")
+    assert body["steer_iid"] == "iid-42"
+    assert body["surface"] == "telegram"
+
+
+def test_run_omits_steer_iid_key_for_plain_typed_turns(monkeypatch):
+    # A typed turn has no dedup id -- key omitted, body byte-identical to today.
+    body = _run_turn_capture_body(monkeypatch)
+    assert "steer_iid" not in body
+
+
+def test_run_omits_steer_iid_key_when_pickup_item_had_none(monkeypatch):
+    # Older gateway: /pending-steer items without `iid` -> "" -> key omitted.
+    body = _run_turn_capture_body(monkeypatch, surface="telegram", steer_iid="")
+    assert "steer_iid" not in body
+    assert body["surface"] == "telegram"

{webbee-0.3.9 → webbee-0.3.11}/tests/test_steer.py

@@ -85,7 +85,7 @@ def test_poll_submits_first_item_with_surface(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=lambda: False,
@@ -97,6 +97,50 @@ def test_poll_submits_first_item_with_surface(monkeypatch):
     assert polled[0] == "marathon-user-1-rlive"
 
 
+def test_poll_passes_item_iid_to_submit(monkeypatch):
+    # steer-iid-dedup pickup path: /pending-steer items carry the queue entry's
+    # `iid`; the poller must hand it to submit so the turn POST carries
+    # steer_iid and the kernel's dedup ring can drop an at-least-once twin.
+    submitted = []
+
+    async def fake_fetch(cfg, tp, session_id):
+        return [{"text": "push the fix", "surface": "telegram", "ts": 1,
+                 "iid": "iid-42"}]
+
+    import webbee.thread as TH
+    monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
+
+    async def submit(text, surface, steer_iid=""):
+        submitted.append((text, surface, steer_iid))
+
+    _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=lambda: False,
+                              submit=submit, live_session_id=lambda: "marathon-u-r1",
+                              interval=0.01),
+           until=lambda: submitted)
+    assert submitted[0] == ("push the fix", "telegram", "iid-42")
+
+
+def test_poll_item_without_iid_submits_empty_iid(monkeypatch):
+    # An older gateway's items carry no `iid` -- submit gets "" (the turn POST
+    # then omits steer_iid entirely), never a crash.
+    submitted = []
+
+    async def fake_fetch(cfg, tp, session_id):
+        return [{"text": "resume", "surface": "telegram", "ts": 2}]
+
+    import webbee.thread as TH
+    monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
+
+    async def submit(text, surface, steer_iid=""):
+        submitted.append((text, surface, steer_iid))
+
+    _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=lambda: False,
+                              submit=submit, live_session_id=lambda: "marathon-u-r1",
+                              interval=0.01),
+           until=lambda: submitted)
+    assert submitted[0] == ("resume", "telegram", "")
+
+
 def test_poll_no_items_never_submits(monkeypatch):
     polled = []
     submitted = []
@@ -108,7 +152,7 @@ def test_poll_no_items_never_submits(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=lambda: False,
@@ -132,7 +176,7 @@ def test_poll_silent_on_network_error_and_recovers(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", flaky_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     # No exception escapes the poller; the tick after the blip succeeds.
@@ -156,7 +200,7 @@ def test_poll_never_fetches_while_busy(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     ticks = {"n": 0}
@@ -192,7 +236,7 @@ def test_multi_item_drain_runs_in_order_one_per_tick_nothing_lost(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     # The gateway drain returns each item exactly ONCE -- items 2..n of a batch
@@ -221,7 +265,7 @@ def test_item_deferred_not_lost_when_turn_starts_mid_tick(monkeypatch):
     def is_busy():
         return busy_answers.pop(0) if busy_answers else False
 
-    async def submit(text, surface):
+    async def submit(text, surface, steer_iid=""):
         submitted.append((text, surface))
 
     _drive(SP.poll_idle_steer(_Cfg(), _tp, workspace=".", is_busy=is_busy,
@@ -245,7 +289,7 @@ def test_poller_exits_when_submitted_turn_absorbs_the_cancel(monkeypatch):
     import webbee.thread as TH
     monkeypatch.setattr(TH, "fetch_pending_steer", fake_fetch)
 
-    async def swallowing_submit(text, surface):
+    async def swallowing_submit(text, surface, steer_iid=""):
         in_submit.set()
         try:
             await asyncio.sleep(3600)

{webbee-0.3.9 → webbee-0.3.11}/tests/test_tui.py

@@ -412,3 +412,222 @@ def test_real_escape_with_clean_buffer_still_stops_the_turn():
     turn = {"task": task}
     _escape_action({"i": None}, turn, lambda: True, None, event, buf=_FakeBuf("draft reply"))
     assert task.cancelled == [1]             # normal Esc behavior unchanged
+
+
+# ── Unit Q (0.3.11): type-ahead queue + up-arrow history recall ───────────────
+# Enter while a turn runs used to ERASE the typed line (buf.reset() before the
+# busy gate). Now it queues (Claude-Code type-ahead): the line runs after the
+# current turn, the toolbar shows the depth, and up-arrow recalls submitted
+# lines to edit/resend. Handlers delegate to module-level *_action helpers —
+# same DI testing philosophy as _escape_action/_interrupt_action above.
+
+from collections import deque   # noqa: E402
+
+
+class _RecBuf:
+    """Buffer stand-in for _submit_line: records history appends."""
+    def __init__(self, text=""):
+        self.text = text
+        class _H:
+            def __init__(self): self.items = []
+            def append_string(self, s): self.items.append(s)
+        self.history = _H()
+
+
+def test_enter_while_busy_queues_line_not_erased():
+    from webbee.tui import _submit_line
+    buf = _RecBuf()
+    pending = deque()
+    started = []
+    assert _submit_line("deploy the fix", buf, pending, True, started.append) == "queued"
+    assert list(pending) == ["deploy the fix"]      # preserved, NOT erased
+    assert started == []                             # and NOT run mid-turn
+    assert buf.history.items == ["deploy the fix"]   # recallable via up-arrow
+
+
+def test_submit_while_idle_starts_turn_immediately():
+    # Idle + non-empty = today's normal submit, byte-identical behavior.
+    from webbee.tui import _submit_line
+    buf = _RecBuf()
+    pending = deque()
+    started = []
+    assert _submit_line("hello", buf, pending, False, started.append) == "started"
+    assert started == ["hello"] and not pending
+    assert buf.history.items == ["hello"]            # typed turns are recallable too
+
+
+def test_toolbar_shows_queue_depth_busy_and_idle():
+    busy = _txt(build_toolbar("default", 0, 0, busy=True, elapsed=1.0, queued=2))
+    assert "⋯2 queued" in busy and "working" in busy
+    idle = _txt(build_toolbar("default", 0, 0, queued=1))
+    assert "⋯1 queued" in idle and "Shift + TAB" in idle
+
+
+def test_toolbar_hides_queue_segment_when_empty():
+    assert "queued" not in _txt(build_toolbar("default", 0, 0, busy=True, elapsed=1.0))
+    assert "queued" not in _txt(build_toolbar("default", 0, 0))
+
+
+def test_turn_completion_drains_oldest_queued_to_submit_path():
+    from webbee.tui import _drain_pending
+    started = []
+    pending = deque(["first", "second"])
+    assert _drain_pending(pending, started.append) is True
+    assert started == ["first"]                      # OLDEST goes out…
+    assert list(pending) == ["second"]               # …one per completion, rest stay
+
+
+def test_drain_with_empty_queue_is_a_noop():
+    from webbee.tui import _drain_pending
+    started = []
+    assert _drain_pending(deque(), started.append) is False
+    assert started == []
+
+
+def test_fifo_order_across_multiple_queued():
+    from webbee.tui import _drain_pending, _submit_line
+    buf = _RecBuf()
+    pending = deque()
+    started = []
+    for t in ("a", "b", "c"):
+        _submit_line(t, buf, pending, True, started.append)
+    assert started == []                             # nothing runs mid-turn
+    while _drain_pending(pending, started.append):   # successive turn completions
+        pass
+    assert started == ["a", "b", "c"]                # strict FIFO
+
+
+def test_up_arrow_recalls_last_submitted_line():
+    from prompt_toolkit.buffer import Buffer
+
+    from webbee.tui import _arrow_up_action, _submit_line
+
+    async def scenario():
+        buf = Buffer(multiline=False)
+        _submit_line("fix the flaky test", buf, deque(), True, lambda t: None)
+        buf.load_history_if_not_yet_loaded()   # BufferControl does this each repaint
+        await buf._load_history_task           # loader fills the working lines
+        event = _FakeEvent()
+        sel = {"i": None}
+        _arrow_up_action(event, buf, sel, 0, True)   # busy → history, never step-nav
+        assert buf.text == "fix the flaky test"
+        assert sel["i"] is None                       # step selection untouched
+    asyncio.run(scenario())
+
+
+def test_down_arrow_cycles_history_forward():
+    from prompt_toolkit.buffer import Buffer
+
+    from webbee.tui import _arrow_down_action, _arrow_up_action
+
+    async def scenario():
+        buf = Buffer(multiline=False)
+        buf.history.append_string("older")
+        buf.history.append_string("newer")
+        buf.load_history_if_not_yet_loaded()
+        await buf._load_history_task
+        event = _FakeEvent()
+        _arrow_up_action(event, buf, {"i": None}, 0, True)
+        _arrow_up_action(event, buf, {"i": None}, 0, True)
+        assert buf.text == "older"
+        _arrow_down_action(event, buf, {"i": None}, 0, True)
+        assert buf.text == "newer"
+    asyncio.run(scenario())
+
+
+def test_up_arrow_with_text_present_pulls_history_not_steps():
+    # The step-nav gate requires EMPTY input — with a draft in the box the
+    # arrow edits history even when idle with steps present.
+    from prompt_toolkit.buffer import Buffer
+
+    from webbee.tui import _arrow_up_action
+
+    async def scenario():
+        buf = Buffer(multiline=False)
+        buf.history.append_string("submitted earlier")
+        buf.text = "draf"
+        buf.load_history_if_not_yet_loaded()
+        await buf._load_history_task
+        event = _FakeEvent()
+        sel = {"i": None}
+        _arrow_up_action(event, buf, sel, 3, False)   # idle + steps, but text present
+        assert buf.text == "submitted earlier"
+        assert sel["i"] is None                        # no step selection created
+    asyncio.run(scenario())
+
+
+def test_up_arrow_during_step_nav_still_navigates_steps():
+    # Idle + empty input + steps present = EXACTLY today's step-navigation.
+    from prompt_toolkit.buffer import Buffer
+
+    from webbee.tui import _arrow_down_action, _arrow_up_action
+
+    buf = Buffer(multiline=False)                     # empty input, no history touch
+    sel = {"i": None}
+    event = _FakeEvent()
+    _arrow_up_action(event, buf, sel, 3, False)
+    assert sel["i"] == 2 and buf.text == ""           # selection moves, no history pull
+    _arrow_up_action(event, buf, sel, 3, False)
+    assert sel["i"] == 1
+    _arrow_down_action(event, buf, sel, 3, False)
+    assert sel["i"] == 2
+    assert event.app.invalidated is True
+
+
+def test_dock_end_to_end_type_ahead_queues_then_drains_fifo():
+    # Drive the REAL Application (pipe input + dummy output): Enter while a
+    # turn runs queues the lines instead of erasing them, the drain in
+    # _run_turn's finally submits them one per turn-completion, FIFO, through
+    # the SAME on_line path a typed line takes; Ctrl-D exits when idle.
+    import time
+
+    from prompt_toolkit.application import create_app_session
+    from prompt_toolkit.input import create_pipe_input
+    from prompt_toolkit.output import DummyOutput
+
+    from webbee import tui
+
+    async def _until(pred, timeout=5.0):
+        t0 = time.time()
+        while not pred():
+            assert time.time() - t0 < timeout, "timed out"
+            await asyncio.sleep(0.01)
+
+    async def scenario():
+        pane = tui.OutputPane(width=80)
+        ran = []
+        gate = asyncio.Event()
+        busy = {"v": False}
+
+        async def on_line(text):
+            busy["v"] = True
+            ran.append(text)
+            await gate.wait()
+            busy["v"] = False
+
+        def status():
+            return {"tokens": 0, "credits": 0, "busy": busy["v"], "current": "",
+                    "elapsed": 0.0, "tools": 0, "consent": False}
+
+        with create_pipe_input() as pipe:
+            with create_app_session(input=pipe, output=DummyOutput()):
+                task = asyncio.create_task(tui.run_session(
+                    pane=pane, on_line=on_line, mode_getter=lambda: "default",
+                    on_cycle=lambda: None, status=status,
+                    is_busy=lambda: busy["v"],
+                    consent_pending=lambda: False, resolve_consent=lambda t: None))
+                await asyncio.sleep(0.05)
+                pipe.send_text("first\r")
+                await _until(lambda: ran == ["first"])      # turn 1 is running
+                pipe.send_text("second\r")                   # typed WHILE busy → queue
+                pipe.send_text("third\r")
+                await asyncio.sleep(0.1)
+                assert ran == ["first"]                      # nothing runs mid-turn
+                gate.set()                                   # let the turns finish
+                await _until(lambda: ran == ["first", "second", "third"])   # FIFO
+                await _until(lambda: not busy["v"])
+                pipe.send_text("\x04")                       # Ctrl-D exit (idle)
+                ok = await asyncio.wait_for(task, 5)
+        assert ok is True
+
+    asyncio.run(scenario())

webbee-0.3.9/src/webbee/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.9"