webbee 0.3.10__tar.gz → 0.3.12__tar.gz

{webbee-0.3.10 → webbee-0.3.12}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.12
+
+- Queued messages are now visible — when you type while Webbee is working,
+  your message shows as `⋯ queued: …` right away, the toolbar shows the count,
+  and it runs (clearly) after the current turn. New `/queue` and `/queue clear`
+  to see and manage what's waiting — they work even mid-turn.
+- Stopping a turn (Esc/Ctrl-C) no longer auto-runs the queue: it stays put,
+  visible, until you clear it or a next turn finishes naturally.
+- Task lists now render in full — every to-do with its status (✓ done ·
+  ▶ doing · ○ next), redrawn on each update, so you always see the whole plan
+  and where Webbee is in it.
+
+## 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

{webbee-0.3.10 → webbee-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.10
+Version: 0.3.12
 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.10 → webbee-0.3.12}/pyproject.toml

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

webbee-0.3.12/src/webbee/__init__.py

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

{webbee-0.3.10 → webbee-0.3.12}/src/webbee/commands.py

@@ -10,6 +10,7 @@ _HELP = """Commands:
   /mode [default|plan|autopilot]   consent mode (no arg — show current)
   /cost  (=/usage)   tokens + credits this session
   /status            cwd · git · surface · tokens · version
+  /queue [clear]     messages queued while Webbee works (clear drops them all)
   /steps [N]         last turn's steps; N expands one (also: Up/Down + Enter)
   /checkpoints       the reversibility time machine — list workspace checkpoints
   /rollback <ref>    restore the workspace to a checkpoint (id, cp-N or N)
@@ -30,6 +31,7 @@ class CommandContext:
     session_tokens: int
     session_credits: int
     git_branch: str
+    queued: tuple = ()   # snapshot of the dock's type-ahead queue, oldest first
 
 
 @dataclass(frozen=True)
@@ -78,6 +80,23 @@ def dispatch(line: str, ctx: CommandContext) -> SlashResult:
         return SlashResult(handled=True, action="sessions")
     if cmd == "/logout-others":
         return SlashResult(handled=True, action="logout_others")
+    if cmd == "/queue":
+        # ctx.queued is the live deque's snapshot (threaded by the repl the
+        # same way /status reads session state); the repl clears the actual
+        # deque on action="queue_clear" — the message here already carries
+        # the honest drop count.
+        if args and args[0].lower() == "clear":
+            n = len(ctx.queued)
+            return SlashResult(handled=True, action="queue_clear",
+                               message=(f"Queue cleared ({n} dropped)." if n
+                                        else "Queue is already empty."))
+        if not ctx.queued:
+            return SlashResult(handled=True, action="queue",
+                               message="Queue is empty — press Enter while Webbee is working to queue a message.")
+        lines = "\n".join(f"  {i}. {t}" for i, t in enumerate(ctx.queued, 1))
+        return SlashResult(handled=True, action="queue",
+                           message=(f"Queued ({len(ctx.queued)}) — runs in order, "
+                                    f"one per finished turn:\n{lines}"))
     if cmd == "/steps":
         if args:
             return SlashResult(handled=True, action="step_detail", arg=args[0])

{webbee-0.3.10 → webbee-0.3.12}/src/webbee/frames.py

@@ -250,3 +250,26 @@ def marathon_note(frame: dict) -> str:
         head = f"📋 Todos {done}/{total}"
         return f"{head} — now: {current}" if current else head
     return str(frame.get("type", ""))
+
+
+def render_todo_frame(frame: dict, sink) -> None:
+    """Full-checklist render for a `todo` FACT (I-WEBBEE-CODE-TODO-SCRATCHPAD).
+    The kernel republishes the WHOLE list on every todo_write, so route it to
+    sink.todos(items, total, done) — the sink redraws the complete current
+    checklist inline (Claude-Code-style: the latest full list always sits in
+    the scrollback). Guarded like the other optional sink hooks: a minimal
+    sink without `todos` degrades to the old one-line marathon_note, and a
+    render error must never break the frame loop in session.run()."""
+    todos = frame.get("todos") if isinstance(frame.get("todos"), list) else []
+    total = frame.get("total", len(todos))
+    done = frame.get("completed", 0)
+    render = getattr(sink, "todos", None)
+    try:
+        if render is not None:
+            render(todos, total, done)
+        else:
+            note = getattr(sink, "note", None)
+            if note is not None:
+                note(marathon_note(frame))
+    except Exception:
+        pass

{webbee-0.3.10 → webbee-0.3.12}/src/webbee/render.py

@@ -215,6 +215,40 @@ class RichSink:
         self.console.print(_pad(Text(_clean(message), style=_BEE)))
         self._nudge()
 
+    def todos(self, items: list, total: int, done: int) -> None:
+        """Claude-Code-style checklist for the coding TODO scratchpad. The
+        kernel republishes the FULL list on every todo_write, so each update
+        re-renders the whole current plan inline — the latest complete list
+        always sits in the scrollback (deliberately NOT a pinned sticky panel:
+        inline re-render can't fight the dock layout). Order preserved, one
+        line per item: ✓ completed (dim, struck) · ▶ in progress (bold, so
+        "what's happening now" pops) · ○ pending (muted). Defensive: malformed
+        items are skipped, unknown statuses render as pending, bad counts
+        degrade to a bare header — never raises."""
+        try:
+            head = f"📋 Todos ({int(done)}/{int(total)})"
+        except (TypeError, ValueError):
+            head = "📋 Todos"
+        body = Text()                          # empty base style — segments below
+        body.append(head, style=f"bold {_BEE}")   # carry their OWN, no bleed-through
+        for item in (items if isinstance(items, (list, tuple)) else ()):
+            if not isinstance(item, dict):
+                continue                       # malformed entry — skip, never raise
+            content = _clean(item.get("content", "")).strip()
+            if not content:
+                continue
+            status = str(item.get("status", "") or "")
+            if status == "completed":
+                glyph, g_style, t_style = "✓", "green", "dim strike"
+            elif status == "in_progress":
+                glyph, g_style, t_style = "▶", f"bold {_BEE}", "bold"
+            else:                              # pending / unknown -> not started yet
+                glyph, g_style, t_style = "○", "grey66", "grey66"
+            body.append(f"\n  {glyph} ", style=g_style)
+            body.append(content, style=t_style)
+        self.console.print(_pad(body))
+        self._nudge()
+
     def user_echo(self, text: str) -> None:
         """Commit the just-sent user message as its own clearly-readable line
         with a background bar (NOT boxed like the live input) so it stands out
@@ -222,6 +256,29 @@ class RichSink:
         self.console.print(_pad(Text(" ❯ " + _clean(text) + " ", style="bold white on grey30")))
         self._nudge()
 
+    def queued_echo(self, text: str) -> None:
+        """Type-ahead visibility (the #1 queue fix): the line you pressed
+        Enter on while a turn was running, committed to the scrollback the
+        MOMENT it queues — so you SEE exactly what's waiting, in order.
+        Muted-but-visible (quieter than user_echo's bar, louder than dim
+        chrome). When it drains, queued_run + the normal user_echo mark it
+        as the active turn."""
+        self.console.print(_pad(Text.assemble(
+            ("⋯ queued: ", f"bold {_BEE}"),
+            (_clean(text), "italic grey66"))))
+        self._nudge()
+
+    def queued_run(self, remaining: int) -> None:
+        """The tiny lifecycle marker printed right before a drained queued
+        line starts: `▶ running queued message` (+ how many still wait) — a
+        drain is never a silent start; the drained text's normal ❯ user_echo
+        follows immediately."""
+        tail = f" · {remaining} still queued" if remaining else ""
+        self.console.print(_pad(Text.assemble(
+            ("▶ ", f"bold {_BEE}"),
+            (f"running queued message{tail}", "italic grey66"))))
+        self._nudge()
+
     def foreign_turn(self, surface: str, role: str, text: str) -> None:
         """One tagged line for a turn that lives on ANOTHER surface (a
         Telegram/panel-steered turn on the shared stream, or a replayed prior

{webbee-0.3.10 → webbee-0.3.12}/src/webbee/repl.py

@@ -2,6 +2,7 @@ import asyncio
 import contextlib
 import os
 import sys
+from collections import deque
 
 from webbee import __version__
 from webbee.account import login_device_flow
@@ -80,6 +81,10 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
     # inject sink/read_line and take the plain fallback loop.
     use_dock = sink is None and read_line is input and sys.stdin.isatty()
     state = {"mode": mode, "logged_in": False}
+    # Type-ahead queue: OWNED here and shared with tui.run_session, so /queue
+    # and /queue clear (dispatched through CommandContext.queued, same
+    # mechanism /status uses for session state) see the live deque.
+    pending_queue: deque = deque()
     _sink = None         # assigned by _boot
     agent = None         # assigned by _boot
     intel = None         # assigned by _boot -- IntelService, or None (off/base-install/boot failure)
@@ -96,7 +101,8 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                               surface="terminal", logged_in=state["logged_in"],
                               session_tokens=getattr(_sink, "session_tokens", 0),
                               session_credits=getattr(_sink, "session_credits", 0),
-                              git_branch=state.get("git_branch", "-"))
+                              git_branch=state.get("git_branch", "-"),
+                              queued=tuple(pending_queue))
 
     async def _handle(line: str) -> str:
         """Process one input line. Returns 'exit' or 'continue'."""
@@ -198,6 +204,11 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                 except Exception as e:
                     _sink.note(f"Remote control unavailable: {type(e).__name__}")
                 return "continue"
+            if res.action == "queue_clear":
+                # dispatch built the message (with the drop count) from the
+                # ctx snapshot; here we drop the live deque — the toolbar
+                # count follows on the sink's redraw below.
+                pending_queue.clear()
             if res.action == "clear":
                 _sink.clear()
                 _sink.note(res.message)
@@ -314,6 +325,8 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                             "expand": lambda i: _handle(f"/steps {i + 1}"),
                         },
                         stop_turn=lambda: agent.stop(),
+                        pending=pending_queue, queued_echo=_sink.queued_echo,
+                        queued_run=_sink.queued_run,
                     )
                 finally:
                     _cancel_background()

{webbee-0.3.10 → webbee-0.3.12}/src/webbee/session.py

@@ -15,6 +15,7 @@ from webbee.frames import (
     handle_tool_request,
     marathon_note,
     render_foreign_frame,
+    render_todo_frame,
 )
 
 
@@ -226,14 +227,20 @@ class AgentSession:
                     elif ftype == "marathon_complete":  # U4 — the whole GOAL is done: terminal
                         return frame.get("text", "")
 
-                    elif ftype in _MARATHON_FACT_TYPES:  # U4 — marathon plan/milestone/pause
-                        # Facts-only; render ONE human-readable line. Guarded: a
-                        # minimal sink (no `note`) simply drops the fact rather than
-                        # crashing the turn (the stream reader already tolerates
-                        # unknown frame types by ignoring them).
-                        _note = getattr(sink, "note", None)
-                        if _note is not None:
-                            _note(marathon_note(frame))
+                    elif ftype in _MARATHON_FACT_TYPES:  # U4 — marathon plan/milestone/pause/todo
+                        # Facts-only. A `todo` fact carries the FULL list -> the
+                        # dedicated full-checklist render (falls back to the old
+                        # one-line note on a minimal sink). The other facts render
+                        # ONE human-readable line. Guarded: a minimal sink (no
+                        # `note`) simply drops the fact rather than crashing the
+                        # turn (the stream reader already tolerates unknown frame
+                        # types by ignoring them).
+                        if ftype == "todo":
+                            render_todo_frame(frame, sink)
+                        else:
+                            _note = getattr(sink, "note", None)
+                            if _note is not None:
+                                _note(marathon_note(frame))
                         if ftype == "marathon_paused":
                             # Parked (out-of-credits / consent / runaway) -> end the
                             # turn so the dock leaves "working"; the note shows why, and

{webbee-0.3.10 → webbee-0.3.12}/src/webbee/tui.py

@@ -2,11 +2,17 @@
 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: echoed AT ONCE as `⋯ queued:`,
+counted in the toolbar, run after the current turn — natural completion only,
+a user STOP preserves the queue; /queue lists it, /queue clear drops it).
+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 +70,17 @@ 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 the `⋯N queued` segment renders in the ACCENT class
+    (tb.working, NOT dim) in the busy AND idle states, so the depth is
+    noticeable at a glance. Style classes are defined in run_session's Style."""
+    q = [("class:tb.working", 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 +89,15 @@ 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"   ·   Esc/Ctrl-C to stop"))
+                      f" · {elapsed:.0f}s · {tools} · {_fmt_tokens(tokens)} tok"))
+        frags += q
+        frags.append(("class:tb.dim", "   ·   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")]
+            ("class:tb.dim", f"   ·   {_fmt_tokens(tokens)} tok · {_fmt_tokens(credits)} credits"),
+            *q,
+            ("class:tb.dim", "   ·   Shift + TAB: switch mode")]
 
 
 def _escape_action(sel: dict, turn: dict, is_busy, stop_turn, event, buf=None) -> None:
@@ -105,6 +117,7 @@ def _escape_action(sel: dict, turn: dict, is_busy, stop_turn, event, buf=None) -
         if t is not None and not t.done():
             if stop_turn is not None:
                 event.app.create_background_task(stop_turn())
+            turn["stopped"] = True   # user STOP → the type-ahead queue must NOT auto-run
             t.cancel()                       # cancel the running turn; dock survives
         return
     sel["i"] = None
@@ -119,18 +132,96 @@ def _interrupt_action(turn: dict, is_busy, stop_turn, event) -> None:
     if t is not None and not t.done():
         if is_busy() and stop_turn is not None:
             event.app.create_background_task(stop_turn())
+        turn["stopped"] = True   # user STOP → the type-ahead queue must NOT auto-run
         t.cancel()                          # cancel the running turn; dock survives
 
 
+def _submit_line(text: str, buf, pending, busy: bool, start, queued_echo=None) -> str:
+    """Route ONE submitted line (dependency-injected, same testing philosophy
+    as _escape_action). Whitespace never queues nor starts ("ignored"). A real
+    line is recorded 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) and echo it into the transcript
+    via `queued_echo` (sink.queued_echo, EXACTLY once per queue action — the
+    queue must be visible, never a silent deque); idle → `start(text)`
+    (today's normal submit). Returns "ignored" | "queued" | "started"."""
+    if not text.strip():
+        return "ignored"
+    buf.history.append_string(text)
+    if busy:
+        pending.append(text)
+        if queued_echo is not None:
+            queued_echo(text)
+        return "queued"
+    start(text)
+    return "started"
+
+
+def _drain_pending(pending, start, mark=None) -> 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). `mark` (sink.queued_run) announces the handoff — `▶ running queued
+    message` — right before the drained line's normal ❯ user-echo, so a drain
+    is never a silent start. Returns True when a drain happened."""
+    if not pending:
+        return False
+    text = pending.popleft()
+    if mark is not None:
+        mark(len(pending))
+    start(text)
+    return True
+
+
+def _is_queue_command(text: str) -> bool:
+    """PURE. `/queue` and its subcommands MANAGE the type-ahead queue, so they
+    must run exactly when the queue matters — mid-turn. The Enter handler
+    routes them past the busy gate (they never type-ahead-queue themselves)."""
+    parts = (text or "").strip().lower().split()
+    return bool(parts) and parts[0] == "/queue"
+
+
+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:
+                      stop_turn=None, pending=None, queued_echo=None,
+                      queued_run=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 — `queued_echo` commits it to the transcript at once, the
+    toolbar shows `⋯N queued` in accent, and it starts right after the current
+    turn with a `queued_run` marker). `pending` is the queue deque — the repl
+    passes its OWN so /queue and /queue clear (dispatched through the normal
+    command layer) see and manage the live queue; /queue itself always runs
+    immediately, even mid-turn. 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 +238,32 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
 
     buf = Buffer(multiline=False)
     turn = {"task": None}
+    if pending is None:
+        pending = deque()   # type-ahead queue: lines submitted while a turn runs
+
+    def _start_turn(text):
+        turn.pop("stopped", None)   # a stale stop flag must never eat the next natural drain
+        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
+            # DRAIN RULE: natural completion ONLY. A user STOP (Esc/Ctrl-C sets
+            # turn["stopped"] before cancelling; repl._run_turn absorbs the
+            # cancel so on_line still returns) means "I'm taking control" — the
+            # queue is PRESERVED, stays visible (toolbar accent + /queue), and
+            # never auto-runs; /queue clear drops it, and the next NATURAL
+            # completion resumes draining. A propagating exception (dock
+            # teardown) also leaves the queue be.
+            stopped = turn.pop("stopped", False)
+            if done and not stopped:
+                # Submit the oldest queued line through the SAME path a typed
+                # line takes; queued_run announces it — never a silent start.
+                _drain_pending(pending, _start_turn, mark=queued_run)
             get_app().invalidate()
 
     kb = KeyBindings()
@@ -178,9 +289,21 @@ 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
+        if _is_queue_command(text):
+            # Queue MANAGEMENT runs NOW, even mid-turn (it never queues
+            # itself): a display-only background task — the handler only
+            # reads/clears the shared deque and prints, so it can't collide
+            # with the live turn and never touches turn["task"].
+            buf.history.append_string(text)
+            event.app.create_background_task(on_line(text))
             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 — echoed AT ONCE as `⋯ queued:` + accent toolbar depth,
+        # runs after the current turn) or start a turn now.
+        if _submit_line(text, buf, pending, _busy_live(), _start_turn, queued_echo) == "queued":
+            event.app.invalidate()             # toolbar shows the new depth
 
     @kb.add("s-tab")
     def _cycle(event):
@@ -206,17 +329,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 +356,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.10 → webbee-0.3.12}/tests/test_commands.py

@@ -152,3 +152,37 @@ def test_notify_command_dispatches():
 def test_help_mentions_notify():
     from webbee.commands import dispatch
     assert "/notify" in dispatch("/help", _anyctx()).message
+
+
+# ── /queue — manage the dock's type-ahead queue (0.3.12) ─────────────────────
+# The queue snapshot rides in CommandContext.queued (threaded by the repl the
+# same way /status reads session state); dispatch stays pure.
+
+
+def test_queue_lists_pending_numbered_in_order():
+    r = dispatch("/queue", _ctx(queued=("fix the tests", "deploy it")))
+    assert r.handled and r.action == "queue"
+    assert "1. fix the tests" in r.message and "2. deploy it" in r.message
+    assert r.message.index("fix the tests") < r.message.index("deploy it")
+    assert not NO_CYRILLIC.search(r.message)
+
+
+def test_queue_empty_shows_hint():
+    r = dispatch("/queue", _ctx())
+    assert r.handled and r.action == "queue" and "empty" in r.message.lower()
+
+
+def test_queue_clear_reports_drop_count():
+    r = dispatch("/queue clear", _ctx(queued=("a", "b", "c")))
+    assert r.handled and r.action == "queue_clear"
+    assert "3 dropped" in r.message
+
+
+def test_queue_clear_when_already_empty():
+    r = dispatch("/queue clear", _ctx())
+    assert r.handled and r.action == "queue_clear"
+    assert "already empty" in r.message.lower()
+
+
+def test_help_mentions_queue():
+    assert "/queue" in dispatch("/help", _ctx()).message

{webbee-0.3.10 → webbee-0.3.12}/tests/test_marathon.py

@@ -152,8 +152,9 @@ def _run_marathon_capture_post(monkeypatch, tmp_path, goal="build X", frames=Non
     monkeypatch.setattr(httpx, "AsyncClient", FakeAsyncClient)
 
     class NoteSink:
-        def __init__(self): self.notes = []
+        def __init__(self): self.notes = []; self.todo_lists = []
         def note(self, msg): self.notes.append(msg)
+        def todos(self, items, total, done): self.todo_lists.append((items, total, done))
         def thinking(self, msg): self.thinks = getattr(self, "thinks", []) + [msg]
         def tool_start(self, *a): ...
         def tool_result(self, *a): ...
@@ -293,6 +294,7 @@ def test_normal_run_omits_marathon_fields(monkeypatch, tmp_path):
         def panel_release(self, *a): ...
         def progress(self, *a): ...
         def usage(self, *a): ...
+        def todos(self, items, total, done): self.todo_lists = getattr(self, "todo_lists", []) + [(items, total, done)]
 
     async def token_provider(): return "tok"
 
@@ -339,3 +341,64 @@ def test_todo_fact_renders_progress_line():
 def test_todo_fact_degrades_on_missing_fields():
     from webbee.frames import marathon_note
     assert "0/0" in marathon_note({"type": "todo"})          # never crashes
+
+
+# --- todo full-checklist routing (render_todo_frame) --------------------------
+
+
+def test_todo_fact_streams_full_list_to_sink_todos(monkeypatch, tmp_path):
+    # A streamed `todo` FACT routes to sink.todos with the FULL ordered list +
+    # correct done/total — NOT the old one-line note.
+    items = [
+        {"content": "map the repo", "status": "completed"},
+        {"content": "fix the bug", "status": "in_progress"},
+        {"content": "run tests", "status": "pending"},
+    ]
+    _, _, sink = _run_marathon_capture_post(monkeypatch, tmp_path, frames=[
+        {"type": "todo", "task_id": "OURS", "total": 3, "completed": 1, "todos": items},
+        {"type": "marathon_complete", "task_id": "OURS", "text": "done"},
+    ])
+    assert sink.todo_lists == [(items, 3, 1)]
+    assert not any("📋" in n for n in sink.notes)      # no duplicate one-liner
+
+
+def test_render_todo_frame_falls_back_to_note_without_todos_hook():
+    # Back-compat: a minimal sink WITHOUT `todos` still gets the old one-line note.
+    from webbee.frames import render_todo_frame
+
+    class NoteOnly:
+        def __init__(self): self.notes = []
+        def note(self, m): self.notes.append(m)
+
+    s = NoteOnly()
+    render_todo_frame({"type": "todo", "total": 2, "completed": 1, "todos": [
+        {"content": "x", "status": "completed"},
+        {"content": "y", "status": "in_progress"}]}, s)
+    assert s.notes == ["📋 Todos 1/2 — now: y"]
+
+
+def test_render_todo_frame_never_breaks_the_frame_loop():
+    from webbee.frames import render_todo_frame
+
+    class Boom:
+        def todos(self, *a): raise RuntimeError("ui bug")
+
+    render_todo_frame({"type": "todo"}, Boom())        # must not raise
+
+    class Bare:                                        # neither todos nor note
+        ...
+
+    render_todo_frame({"type": "todo", "todos": "junk"}, Bare())   # must not raise
+
+
+def test_marathon_plan_and_milestone_still_one_line_notes(monkeypatch, tmp_path):
+    # The split is todo-ONLY: plan/milestone/pause stay on the note path even
+    # when the sink HAS a todos hook.
+    _, _, sink = _run_marathon_capture_post(monkeypatch, tmp_path, frames=[
+        {"type": "marathon_plan", "task_id": "OURS", "milestone_count": 1, "goal": "g"},
+        {"type": "milestone", "task_id": "OURS", "index": 1, "title": "t", "status": "done"},
+        {"type": "marathon_complete", "task_id": "OURS", "text": "done"},
+    ])
+    assert any("Marathon plan" in n for n in sink.notes)
+    assert any("Milestone" in n for n in sink.notes)
+    assert sink.todo_lists == []