webbee 0.3.12__tar.gz → 0.3.13__tar.gz

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

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.3.13
+
+- The message queue is now a live panel above the input — you see exactly
+  what's waiting, press ↑ to pull the last one back for editing (it leaves
+  the queue and returns when you resend), or click one to edit it. The
+  transcript stays clean.
+- Cleaner welcome screen — just the essentials (who you are, your plan, how
+  to start) plus a clear word on privacy: your work is never sold and never
+  used to train models, and PII is masked before it reaches the model.
+
 ## 0.3.12
 
 - Queued messages are now visible — when you type while Webbee is working,

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

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

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

webbee-0.3.13/src/webbee/__init__.py

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

webbee-0.3.13/src/webbee/queue_panel.py

@@ -0,0 +1,101 @@
+"""The LIVE pending-queue panel pinned between the output pane and the input
+box (0.3.13 — replaces the static `⋯ queued:` scrollback echoes, which
+scrolled away, duplicated and never updated). The builders here are PURE
+(unit-tested without an Application); tui.run_session mounts them in a
+ConditionalContainer that occupies ZERO rows while the queue is empty, so
+the empty-queue dock is pixel-identical to before. Item rows carry a
+per-fragment mouse handler (prompt_toolkit 3.0.52 3-tuple fragments,
+verified in venv) firing on MOUSE_UP only — a PASSIVE consumer of the
+clicks that already flow under the ?1000/?1002 button-event tracking; it
+enables nothing at the terminal level, so the 0.3.3 mouse-flood fix
+(?1003 any-event stays off, tui.configure_mouse_modes) is untouched.
+Split out of tui.py to keep both files under the file-size ceiling."""
+
+QP_MAX_ITEMS = 5   # newest items shown; deeper queues add one `… +K more` row
+
+
+def one_line(text: str, width: int) -> str:
+    """PURE. Collapse whitespace/newlines so a queued item costs EXACTLY one
+    panel row, truncating with `…` when it would overflow `width` columns
+    (width<=0 = no truncation — headless/unknown terminal)."""
+    t = " ".join((text or "").split())
+    if width > 0 and len(t) > width:
+        t = t[:max(1, width - 1)] + "…"
+    return t
+
+
+def queue_height(pending) -> int:
+    """PURE. Rows the panel needs: 1 header + one per SHOWN item + one
+    `… +K more` row when the queue is deeper than QP_MAX_ITEMS. 0 when empty
+    (the ConditionalContainer hides the panel then anyway). The cap keeps the
+    output pane dominant on small terminals; the toolbar's `⋯N queued`
+    segment stays the truth-teller for the full depth."""
+    n = len(pending)
+    if not n:
+        return 0
+    return 1 + min(n, QP_MAX_ITEMS) + (1 if n > QP_MAX_ITEMS else 0)
+
+
+def pull_item(pending, buf, index: int) -> bool:
+    """The ONE pull-to-edit implementation (serves BOTH the ↑ key — newest,
+    index len(pending)-1 — and a panel-row click — that row's index): move
+    pending[index] OUT of the queue and into the input buffer for editing,
+    cursor at the end. Guards, identical on both paths: a buffer with ANY
+    text is never clobbered, and a stale index (the queue drained between
+    render and click) is ignored. Returns True when a pull happened (the
+    caller invalidates)."""
+    if buf.text or not (0 <= index < len(pending)):
+        return False
+    item = pending[index]
+    del pending[index]
+    buf.text = item
+    buf.cursor_position = len(item)
+    return True
+
+
+def _item_handler(pull, index: int):
+    """One row's mouse handler: MOUSE_UP (a click, not a drag/press) pulls
+    THAT queued item into the input via `pull(index)`; every other event
+    falls through (NotImplemented) so wheel scroll etc. keep today's
+    behavior. Mirrors OutputPane._SelectControl's event discipline."""
+    def _h(mouse_event):
+        from prompt_toolkit.mouse_events import MouseEventType
+        if mouse_event.event_type == MouseEventType.MOUSE_UP:
+            pull(index)
+            return None
+        return NotImplemented
+    return _h
+
+
+def queue_fragments(pending, pull=None, width: int = 0):
+    """PURE builder: the panel as prompt_toolkit formatted text, re-invoked
+    every redraw (same live mechanics as the toolbar) so every queue
+    add/edit/drain shows at once. Layout, top→bottom = drain order (FIFO —
+    the TOP row runs next; the BOTTOM row is the newest, the one ↑ pulls,
+    sitting right above the input):
+
+        ⋯ queued (N) · ↑ edit last · click to edit
+        … +K more            ← only when N > QP_MAX_ITEMS (the OLDEST hide)
+        older item           ← muted (qp.item)
+        newest item          ← accent (qp.last)
+
+    When `pull` is given each item row is a 3-tuple fragment carrying a
+    mouse handler that pulls exactly that item (see _item_handler). Empty
+    queue → [] (the panel is hidden)."""
+    items = list(pending)
+    n = len(items)
+    if not n:
+        return []
+    frags = [("class:qp.header", f" ⋯ queued ({n})"),
+             ("class:qp.item", " · ↑ edit last · click to edit")]
+    start = max(0, n - QP_MAX_ITEMS)
+    if start:
+        frags.append(("class:qp.item", f"\n   … +{start} more"))
+    for i in range(start, n):
+        style = "class:qp.last" if i == n - 1 else "class:qp.item"
+        row = "\n   " + one_line(items[i], width - 4 if width > 0 else 0)
+        if pull is None:
+            frags.append((style, row))
+        else:
+            frags.append((style, row, _item_handler(pull, i)))
+    return frags

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

@@ -44,6 +44,18 @@ _ICON = {"read_file": "📖", "grep": "🔎", "glob": "🗂️", "write_file": "
 _BEE = "yellow"       # bee-yellow brand accent — logo / 🐝 / notes / busy dot ONLY
 _ACCENT = "cyan"      # interactive chrome ONLY — live caret / mode / panel url
 
+# ---- welcome copy (single source of truth for the splash + its tests) ------
+# The privacy promise is claims-disciplined: every clause is TRUE and enforced
+# today — user data is never sold and never used to train any model (ours or
+# third-party; documented in the DPA), and PII is masked before tool output
+# re-enters the model (platform-enforced and covered by the platform's own
+# test suite). Deliberately NOT said: "we collect nothing" (sessions ARE
+# stored so Webbee can resume your work) and "guaranteed" (we say what is
+# enforced, not what is promised). Change the wording only with a source.
+WELCOME_PRIVACY = "🔒 Your work stays yours — never sold, never training data."
+WELCOME_PRIVACY_DETAIL = "PII is masked before it reaches the model."
+WELCOME_HINT = "Type a task — Webbee runs it to completion · /help · Ctrl-D to exit"
+
 
 def _fmt_tokens(n: int) -> str:
     """Compact count for the live toolbar: 900 -> '900', 2_100 -> '2.1k',
@@ -132,10 +144,13 @@ class RichSink:
 
     # ---- welcome ------------------------------------------------------------
     def welcome(self, account, cwd: str, surface: str) -> None:
-        """One-time launch splash: a centered WEBBEE CODE logo + imperal.io + an
-        honest account panel (who/plan/tier/member-since). Runs BEFORE the dock
-        starts. Clears the screen ONLY in the non-pane path (the full-screen
-        dock owns its own alternate screen — clearing there would corrupt it)."""
+        """One-time launch splash, trimmed to what a human actually needs:
+        the WEBBEE CODE logo (the brand), ONE identity line (who am I / plan —
+        plan status shows only when it needs attention), the privacy promise
+        (true, enforced claims only — see WELCOME_PRIVACY above), and one hint
+        line to get going. Runs BEFORE the dock starts. Clears the screen ONLY
+        in the non-pane path (the full-screen dock owns its own alternate
+        screen — clearing there would corrupt it)."""
         if self._on_output is None:
             self.console.clear()
         w = self.console.width
@@ -152,29 +167,24 @@ class RichSink:
         self.console.print(Text("ICNLI AI Cloud OS · Agent".center(w), style=f"bold {_ACCENT}"))
         self.console.print(Text("·  i m p e r a l . i o  ·".center(w), style="dim"))
         self.console.print()
-        rows = []
         if account.signed_in:
-            who = account.email + (f"   ·   @{account.nickname}" if account.nickname else "")
-            rows.append(("Signed in as", who))
+            who = account.email or ""
+            if account.nickname:
+                who += f" · @{account.nickname}"
             if account.plan:
-                plan = account.plan + (f" · {account.plan_status}" if account.plan_status else "")
-                plan += (f" · renews {account.plan_renews}" if account.plan_renews else "")
-                rows.append(("Plan", plan))
-            if account.dev_tier:
-                rows.append(("Developer", f"{account.dev_tier} tier"))
-            if account.member_since:
-                rows.append(("Member since", account.member_since))
+                who += f" · {account.plan} plan"
+                if account.plan_status and account.plan_status != "active":
+                    who += f" ({account.plan_status})"
+            label = "Signed in as "
+            pad = " " * max(0, (w - len(label) - len(who)) // 2)
+            self.console.print(Text.assemble((pad + label, "dim"), (who, "white")))
         else:
-            rows.append(("", "not signed in — /login"))
-        bw = max((len(label.ljust(14) + value) for label, value in rows), default=0)
-        pad = " " * max(0, (w - bw) // 2)
-        for label, value in rows:
-            self.console.print(Text.assemble((pad + label.ljust(14), "dim"), (value, "white")))
+            self.console.print(Text("not signed in — /login".center(w), style="dim"))
         self.console.print()
-        tip = "Type a task and Webbee runs it to completion · pauses if credits run low · --once = single turn"
-        self.console.print(Text(tip.center(w), style="dim"))
+        self.console.print(Text(WELCOME_PRIVACY.center(w), style="white"))
+        self.console.print(Text(WELCOME_PRIVACY_DETAIL.center(w), style="dim"))
         self.console.print()
-        self.console.print(Text("/help · Ctrl-D to exit".center(w), style="dim"))
+        self.console.print(Text(WELCOME_HINT.center(w), style="dim"))
         self.console.print()
         self._nudge()
 
@@ -256,18 +266,6 @@ 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

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

@@ -325,8 +325,7 @@ 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,
+                        pending=pending_queue, queued_run=_sink.queued_run,
                     )
                 finally:
                     _cancel_background()

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

@@ -4,17 +4,20 @@ 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; 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."""
+runs QUEUES the line (Claude-Code type-ahead: shown LIVE in the queue panel
+pinned above the input — see queue_panel.py — counted in the toolbar, run
+after the current turn — natural completion only, a user STOP preserves the
+queue; ↑ on an empty input pulls the newest queued line back for editing, a
+click pulls that item; /queue lists it, /queue clear drops it; the transcript
+stays clean — real turns only). 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.queue_panel import pull_item, queue_fragments, queue_height
 from webbee.render import _fmt_tokens
 
 _MODES = ("default", "plan", "autopilot")
@@ -136,22 +139,21 @@ 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, queued_echo=None) -> str:
+def _submit_line(text: str, buf, pending, busy: bool, start) -> 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"."""
+    dropped; it runs after the current turn) — the LIVE queue panel above the
+    input shows it at once (queue_panel.queue_fragments reads this deque every
+    redraw), NEVER a static scrollback echo (those scrolled away, duplicated
+    and went stale when edited); 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"
@@ -182,10 +184,22 @@ def _is_queue_command(text: str) -> bool:
     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)."""
+def _arrow_up_action(event, buf, sel: dict, n: int, busy: bool, pending=None) -> None:
+    """Up key — precedence: (1) QUEUE-PULL: pending items + an EMPTY buffer
+    (busy or idle — NOT busy-gated: the queue legally survives a user STOP
+    into idle, and pulling the newest to edit is exactly what you want after
+    an Esc) pull the NEWEST queued line out of the queue into the input for
+    editing; re-submit re-queues it at the tail (busy) or runs it (idle).
+    Repeated presses walk newest→oldest, one item per press; a buffer with
+    ANY text is never clobbered (history/step-nav serve it instead).
+    (2) Step-navigation EXACTLY as before (steps + empty input + idle —
+    reachable exactly when the queue is empty, i.e. today's behavior verbatim
+    in the queue-empty world). (3) Recall an older submitted line
+    (readline-style)."""
+    if pending and not buf.text:
+        pull_item(pending, buf, len(pending) - 1)   # newest — "edit the last thing I queued"
+        event.app.invalidate()
+        return
     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()
@@ -207,18 +221,21 @@ def _arrow_down_action(event, buf, sel: dict, n: int, busy: bool) -> None:
 
 async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
                       is_busy, consent_pending, resolve_consent, steps_nav=None,
-                      stop_turn=None, pending=None, queued_echo=None,
-                      queued_run=None) -> bool:
+                      stop_turn=None, pending=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); 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
+    (type-ahead — the LIVE queue panel pinned above the input shows it at
+    once and tracks every edit/drain, the toolbar shows `⋯N queued` in
+    accent, and it starts right after the current turn with a `queued_run`
+    marker — the transcript itself stays real-turns-only). ↑ on an empty
+    input pulls the newest queued line back into the box for editing (it
+    leaves the panel; re-submit re-queues/runs it); clicking a panel row
+    pulls THAT item. `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).
@@ -227,8 +244,9 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
     try:
         from prompt_toolkit.application import Application, get_app
         from prompt_toolkit.buffer import Buffer
+        from prompt_toolkit.filters import Condition
         from prompt_toolkit.key_binding import KeyBindings
-        from prompt_toolkit.layout import HSplit, Layout, Window
+        from prompt_toolkit.layout import ConditionalContainer, HSplit, Layout, Window
         from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
         from prompt_toolkit.layout.processors import BeforeInput
         from prompt_toolkit.styles import Style
@@ -300,10 +318,10 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
             event.app.create_background_task(on_line(text))
             return
         # 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
+        # (type-ahead — appears AT ONCE in the live queue panel + accent
+        # toolbar depth, runs after the current turn) or start a turn now.
+        if _submit_line(text, buf, pending, _busy_live(), _start_turn) == "queued":
+            event.app.invalidate()             # panel + toolbar show the new depth
 
     @kb.add("s-tab")
     def _cycle(event):
@@ -329,7 +347,7 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
 
     @kb.add("up")
     def _step_up(event):
-        _arrow_up_action(event, buf, sel, _nav_count(), _busy_live())
+        _arrow_up_action(event, buf, sel, _nav_count(), _busy_live(), pending)
 
     @kb.add("down")
     def _step_down(event):
@@ -376,11 +394,35 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
         # so the mode is obvious from the input line itself, not just the toolbar.
         return [(f"class:tb.mode.{mode_getter()}", "❯ ")]
 
+    def _pull_at(index: int) -> None:
+        """Mouse pull (a panel row's MOUSE_UP handler, queue_panel._item_handler):
+        move the CLICKED queued item into the input for editing — the SAME
+        pull_item the ↑ key uses, arbitrary index instead of newest (never
+        clobbers a typed draft, ignores a stale index)."""
+        if pull_item(pending, buf, index):
+            get_app().invalidate()
+
+    def _queue_fragments():
+        # Live like _toolbar: re-invoked every redraw, reads the shared deque.
+        import shutil
+        return queue_fragments(pending, pull=_pull_at,
+                               width=shutil.get_terminal_size((100, 24)).columns)
+
+    # The LIVE pending-queue panel — pinned BETWEEN the output pane and the
+    # input box; zero rows (hidden) while the queue is empty, so the empty
+    # state is pixel-identical to the panel-less dock. focusable=False keeps
+    # focus on the input even when a row is clicked.
+    queue_panel = ConditionalContainer(
+        content=Window(FormattedTextControl(_queue_fragments, focusable=False),
+                       height=lambda: queue_height(pending),
+                       always_hide_cursor=True, wrap_lines=False),
+        filter=Condition(lambda: bool(pending)))
+
     input_win = Window(
         BufferControl(buffer=buf, input_processors=[BeforeInput(_prompt_fragments)]),
         height=_input_height, wrap_lines=True)
     toolbar = Window(FormattedTextControl(_toolbar), height=1, always_hide_cursor=True)
-    root = HSplit([pane.window, Frame(input_win), toolbar])
+    root = HSplit([pane.window, queue_panel, Frame(input_win), toolbar])
     style = Style.from_dict({
         "frame.border": "#5f5f5f",           # muted grey chrome — furniture, not focus
         "prompt": "#00afd7 bold",            # cyan ❯ — the interactive accent
@@ -392,6 +434,9 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
         "tb.mode.default": "#00afd7",        # default — cyan
         "tb.mode.plan": "#af87ff",           # plan — purple
         "tb.mode.autopilot": "#e8a317 bold", # autopilot — yellow (auto-approving: caution)
+        "qp.header": "#e8a317 bold",         # queue-panel header — bee-yellow, pops
+        "qp.item": "#8a8a8a italic",         # older queued rows — muted (echoes grey66)
+        "qp.last": "#e8a317",                # newest row — the one ↑ pulls
     })
     app = Application(layout=Layout(root, focused_element=input_win), key_bindings=kb,
                       full_screen=True, mouse_support=True, style=style)

{webbee-0.3.12 → webbee-0.3.13}/tests/test_render.py

@@ -156,7 +156,7 @@ def test_usage_and_clear_still_work():
 
 # ---- WEBBEE CODE welcome + account panel + session /cost (Chunk 1 Task 2) --
 
-def test_welcome_full_account_aligned():
+def test_welcome_full_account_essentials_only():
     from webbee.account import Account
     from webbee.banner_art import WEBBEE_CODE
     s = _sink()
@@ -169,11 +169,40 @@ def test_welcome_full_account_aligned():
     # assert a stable fragment of the actual logo constant renders instead.
     assert WEBBEE_CODE.splitlines()[2] in out                  # ascii logo present
     assert "i m p e r a l . i o" in out  # letter-spaced brand caption, per Target welcome
-    assert "v@imperal.io" in out and "notvallium" in out
-    assert "pro" in out.lower() and "active" in out
-    assert "explorer" in out and "Apr 2026" in out
+    assert "v@imperal.io" in out and "notvallium" in out and "pro plan" in out
+    # trimmed: vanity rows are gone, and a healthy plan doesn't shout "active"
+    assert "explorer" not in out and "Apr 2026" not in out
+    assert "renews" not in out and "active" not in out
     assert "/help" in out
-    assert not NO_CYRILLIC.search(out)
+    assert not NO_CYRILLIC.search(out)   # English UI only
+
+
+def test_welcome_privacy_line_and_hint():
+    from webbee.account import Account
+    from webbee.render import WELCOME_HINT, WELCOME_PRIVACY, WELCOME_PRIVACY_DETAIL
+    s = _sink()
+    s.welcome(Account(signed_in=True, email="v@imperal.io"), "/x", "terminal")
+    out = s.console.export_text()
+    # the privacy promise renders verbatim (claims-disciplined copy, see render.py)
+    assert "🔒" in out
+    assert "Your work stays yours — never sold, never training data." in out
+    assert "PII is masked before it reaches the model." in out
+    # the old verbose tip collapsed into ONE crisp hint line
+    assert "Type a task" in out and "/help" in out and "Ctrl-D" in out
+    assert "credits run low" not in out and "--once" not in out
+    # constants stay in sync with what actually renders
+    for const in (WELCOME_PRIVACY, WELCOME_PRIVACY_DETAIL, WELCOME_HINT):
+        assert const.strip() in out
+    assert not NO_CYRILLIC.search(out)   # English UI only
+
+
+def test_welcome_plan_status_shown_only_when_abnormal():
+    from webbee.account import Account
+    s = _sink()
+    s.welcome(Account(signed_in=True, email="v@imperal.io", plan="pro",
+                      plan_status="past_due"), "/x", "terminal")
+    out = s.console.export_text()
+    assert "pro plan (past_due)" in out
 
 
 def test_welcome_signed_out_minimal():
@@ -181,7 +210,11 @@ def test_welcome_signed_out_minimal():
     s = _sink()
     s.welcome(Account(signed_in=False), "/x", "terminal")
     out = s.console.export_text()
-    assert "i m p e r a l . i o" in out  # letter-spaced brand caption, per Target welcome and "/login" in out
+    assert "i m p e r a l . i o" in out  # letter-spaced brand caption, per Target welcome
+    assert "/login" in out
+    # trust line shows for everyone, signed in or not
+    assert "never sold, never training data" in out
+    assert not NO_CYRILLIC.search(out)   # English UI only
 
 
 def test_session_credits_accumulates_across_turns():
@@ -430,7 +463,10 @@ def test_progress_and_thinking_strip_escapes():
     assert "\x1b[?1003h" not in out and "pwned" not in out
 
 
-# ── queued_echo / queued_run — the visible type-ahead queue (0.3.12) ──────────
+# ── queued_run — the drain marker (0.3.12; the `⋯ queued:` scrollback echo was
+# replaced by the LIVE queue panel in 0.3.13 — queue visibility now lives in
+# webbee.queue_panel, tested in test_tui.py; the transcript stays real-turns-only
+# plus this one-line drain provenance mark) ────────────────────────────────────
 
 
 def _rec_sink():
@@ -441,17 +477,11 @@ def _rec_sink():
     return RichSink(console=c, live_enabled=False, input_fn=lambda p: "", clock=lambda: 0.0), c
 
 
-def test_queued_echo_renders_the_text_as_a_transcript_line():
-    s, c = _rec_sink()
-    s.queued_echo("deploy the fix")
-    assert "⋯ queued: deploy the fix" in c.export_text()
-
-
-def test_queued_echo_strips_control_bytes():
-    s, c = _rec_sink()
-    s.queued_echo("evil\x1b[?1003htext")
-    out = c.export_text()
-    assert "\x1b[?1003h" not in out and "eviltext" in out
+def test_sink_has_no_queued_echo_anymore():
+    # The static scrollback echo is GONE (it scrolled away, duplicated and went
+    # stale when edited) — the live panel above the input owns queue visibility.
+    s, _ = _rec_sink()
+    assert not hasattr(s, "queued_echo")
 
 
 def test_queued_run_marker_announces_the_drain():

{webbee-0.3.12 → webbee-0.3.13}/tests/test_repl.py

@@ -20,7 +20,6 @@ class FakeSink:
     def abort(self): self.aborted = True
     def welcome(self, *a, **kw): ...
     def user_echo(self, text): self.echoed = getattr(self, "echoed", []) + [text]
-    def queued_echo(self, text): self.queued_echoes = getattr(self, "queued_echoes", []) + [text]
     def queued_run(self, remaining): self.queued_runs = getattr(self, "queued_runs", []) + [remaining]
     def sessions_table(self, rows): self.session_tables = getattr(self, "session_tables", []) + [rows]
     def foreign_turn(self, surface, role, text):

{webbee-0.3.12 → webbee-0.3.13}/tests/test_tui.py

@@ -633,42 +633,25 @@ def test_dock_end_to_end_type_ahead_queues_then_drains_fifo():
     asyncio.run(scenario())
 
 
-# ── 0.3.12: the queue is VISIBLE + managed ────────────────────────────────────
-# 0.3.11 queued mechanically but silently (only a dim toolbar count). Now:
-# queueing echoes `⋯ queued: <text>` into the transcript AT ONCE
-# (sink.queued_echo, exactly once per queue action), a drain announces itself
+# ── 0.3.12: the queue is VISIBLE + managed (0.3.13: visibility moved from the
+# static `⋯ queued:` scrollback echo — which scrolled away, duplicated and went
+# stale — into the LIVE queue panel above the input, webbee.queue_panel; the
+# panel section below covers it). A drain still announces itself
 # (sink.queued_run) right before the drained line's normal ❯ user-echo, the
 # toolbar segment is an ACCENT (tb.working, not dim), /queue // /queue clear
 # manage the shared deque even mid-turn, and a user STOP (Esc/Ctrl-C)
 # PRESERVES the queue — drain on natural completion only.
 
 
-def test_queue_echo_fires_exactly_once_with_the_text():
+def test_whitespace_never_queues():
     from webbee.tui import _submit_line
     buf = _RecBuf()
     pending = deque()
-    started, echoed = [], []
-    assert _submit_line("ship it", buf, pending, True, started.append, echoed.append) == "queued"
-    assert echoed == ["ship it"]                     # the #1 fix: you SEE what queued
-    assert list(pending) == ["ship it"] and started == []
-
-
-def test_idle_submit_does_not_fire_queued_echo():
-    from webbee.tui import _submit_line
-    started, echoed = [], []
-    assert _submit_line("go", _RecBuf(), deque(), False, started.append, echoed.append) == "started"
-    assert echoed == [] and started == ["go"]
-
-
-def test_whitespace_never_queues_nor_echoes():
-    from webbee.tui import _submit_line
-    buf = _RecBuf()
-    pending = deque()
-    started, echoed = [], []
+    started = []
     for junk in ("", "   ", "\t \t"):
-        assert _submit_line(junk, buf, pending, True, started.append, echoed.append) == "ignored"
-        assert _submit_line(junk, buf, pending, False, started.append, echoed.append) == "ignored"
-    assert not pending and started == [] and echoed == []
+        assert _submit_line(junk, buf, pending, True, started.append) == "ignored"
+        assert _submit_line(junk, buf, pending, False, started.append) == "ignored"
+    assert not pending and started == []
     assert buf.history.items == []                   # junk is not recallable either
 
 
@@ -738,7 +721,7 @@ def test_dock_stop_preserves_queue_then_natural_completion_drains():
 
     async def scenario():
         pane = tui.OutputPane(width=80)
-        ran, echoed, markers = [], [], []
+        ran, markers = [], []
         gate = asyncio.Event()
         busy = {"v": False}
 
@@ -763,12 +746,12 @@ def test_dock_stop_preserves_queue_then_natural_completion_drains():
                     on_cycle=lambda: None, status=status,
                     is_busy=lambda: busy["v"],
                     consent_pending=lambda: False, resolve_consent=lambda t: None,
-                    pending=pend, queued_echo=echoed.append, queued_run=markers.append))
+                    pending=pend, queued_run=markers.append))
                 await asyncio.sleep(0.05)
                 pipe.send_text("first\r")
                 await _until(lambda: ran == ["first"])         # turn 1 is running
                 pipe.send_text("queued follow-up\r")           # type-ahead while busy
-                await _until(lambda: echoed == ["queued follow-up"])   # echoed AT ONCE
+                await _until(lambda: list(pend) == ["queued follow-up"])   # queued AT ONCE
                 pipe.send_text("\x03")                         # user STOP (Ctrl-C)
                 await _until(lambda: not busy["v"])
                 await asyncio.sleep(0.1)
@@ -784,6 +767,7 @@ def test_dock_stop_preserves_queue_then_natural_completion_drains():
                 pipe.send_text("\x04")                         # Ctrl-D exit (idle)
                 ok = await asyncio.wait_for(task, 5)
         assert ok is True
+        assert "⋯ queued" not in pane.dump()      # the transcript stays CLEAN
 
     asyncio.run(scenario())
 
@@ -809,7 +793,7 @@ def test_dock_queue_command_runs_immediately_even_while_busy():
 
     async def scenario():
         pane = tui.OutputPane(width=80)
-        ran, echoed = [], []
+        ran = []
         gate = asyncio.Event()
         busy = {"v": False}
         pend = deque()
@@ -836,7 +820,7 @@ def test_dock_queue_command_runs_immediately_even_while_busy():
                     on_cycle=lambda: None, status=status,
                     is_busy=lambda: busy["v"],
                     consent_pending=lambda: False, resolve_consent=lambda t: None,
-                    pending=pend, queued_echo=echoed.append))
+                    pending=pend))
                 await asyncio.sleep(0.05)
                 pipe.send_text("first\r")
                 await _until(lambda: ran == ["first"])
@@ -851,9 +835,269 @@ def test_dock_queue_command_runs_immediately_even_while_busy():
                 await _until(lambda: not busy["v"])
                 await asyncio.sleep(0.1)
                 assert "second" not in ran                     # cleared → nothing drained
-                assert echoed == ["second"]                    # /queue itself never echoed
                 pipe.send_text("\x04")
                 ok = await asyncio.wait_for(task, 5)
         assert ok is True
 
     asyncio.run(scenario())
+
+
+# ── 0.3.13: the LIVE queue panel + pull-to-edit ───────────────────────────────
+# The static `⋯ queued:` scrollback echoes are GONE (they scrolled away,
+# duplicated, and went stale when edited). The queue now lives in a panel
+# pinned ABOVE the input (webbee.queue_panel — pure fragment/height builders
+# mounted in a ConditionalContainer): it updates live on every add/edit/drain,
+# ↑ on an empty input pulls the NEWEST item back into the box for editing
+# (re-submit re-queues it), a click pulls THAT item, and the transcript stays
+# real-turns-only.
+
+from webbee.queue_panel import (  # noqa: E402
+    QP_MAX_ITEMS, one_line, pull_item, queue_fragments, queue_height)
+
+
+def _panel_text(frags):
+    return "".join(f[1] for f in frags)
+
+
+def test_empty_queue_renders_no_panel():
+    assert queue_fragments(deque()) == []
+    assert queue_height(deque()) == 0        # ConditionalContainer hides it anyway
+
+
+def test_panel_header_counts_and_orders_items_drain_first_to_newest():
+    frags = queue_fragments(deque(["first", "second"]))
+    text = _panel_text(frags)
+    assert "⋯ queued (2)" in text
+    assert text.index("first") < text.index("second")   # top row drains next (FIFO)
+    assert text.count("\n") == 2                         # header + exactly one row each
+    assert not NO_CYRILLIC.search(text)
+
+
+def test_panel_newest_item_accented_older_muted():
+    frags = queue_fragments(deque(["older", "newest"]))
+    assert [f[0] for f in frags if "older" in f[1]] == ["class:qp.item"]
+    assert [f[0] for f in frags if "newest" in f[1]] == ["class:qp.last"]
+
+
+def test_panel_caps_at_newest_five_with_a_more_row():
+    items = [f"item{i}" for i in range(8)]
+    frags = queue_fragments(deque(items))
+    text = _panel_text(frags)
+    assert "⋯ queued (8)" in text                        # header keeps the TRUE depth
+    assert "… +3 more" in text                           # the oldest 3 hide behind it
+    assert all(t in text for t in items[3:])             # newest 5 shown
+    assert all(t not in text for t in items[:3])
+
+
+def test_panel_height_is_header_plus_rows_capped():
+    assert queue_height(deque(["a"])) == 2                       # header + 1
+    assert queue_height(deque(["a"] * QP_MAX_ITEMS)) == 6        # header + 5
+    assert queue_height(deque(["a"] * 9)) == 7                   # header + 5 + more-row
+
+
+def test_panel_item_is_one_truncated_row():
+    frags = queue_fragments(deque(["x" * 500]), width=40)
+    rows = _panel_text(frags).split("\n")
+    assert len(rows) == 2                                # a huge item still costs ONE row
+    assert rows[1].endswith("…") and len(rows[1]) <= 40
+
+
+def test_panel_multiline_item_collapses_to_one_row():
+    frags = queue_fragments(deque(["line1\nline2\tline3"]))
+    text = _panel_text(frags)
+    assert text.count("\n") == 1 and "line1 line2 line3" in text
+
+
+def test_one_line_collapses_whitespace_and_truncates():
+    assert one_line("a\n  b\t c", 80) == "a b c"
+    assert one_line("abcdef", 4) == "abc…"
+    assert one_line("abcd", 4) == "abcd"
+    assert one_line("", 10) == ""
+    assert one_line("abcdef", 0) == "abcdef"             # no width → no truncation
+
+
+def test_panel_without_pull_has_no_mouse_handlers():
+    assert all(len(f) == 2 for f in queue_fragments(deque(["a", "b"])))
+
+
+def test_panel_item_mouse_up_pulls_that_item_other_events_fall_through():
+    from prompt_toolkit.data_structures import Point
+    from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
+    pulls = []
+    frags = queue_fragments(deque(["a", "b", "c"]), pull=pulls.append, width=80)
+    handlers = [f[2] for f in frags if len(f) == 3]
+    assert len(handlers) == 3                            # every item row is clickable
+    up = MouseEvent(position=Point(0, 0), event_type=MouseEventType.MOUSE_UP,
+                    button=MouseButton.LEFT, modifiers=frozenset())
+    assert handlers[1](up) is None and pulls == [1]      # the CLICKED item, by index
+    down = MouseEvent(position=Point(0, 0), event_type=MouseEventType.MOUSE_DOWN,
+                      button=MouseButton.LEFT, modifiers=frozenset())
+    assert handlers[0](down) is NotImplemented           # press/drag/wheel fall through
+    assert pulls == [1]
+
+
+def test_control_dispatches_click_row_to_the_matching_item():
+    # prompt_toolkit's OWN per-fragment dispatch (FormattedTextControl.mouse_handler)
+    # routes a click at row y to that row's handler — the exact path a real SGR
+    # ?1000 button report takes after decoding. Row 0 = header (no handler).
+    from prompt_toolkit.data_structures import Point
+    from prompt_toolkit.layout.controls import FormattedTextControl
+    from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
+    pulls = []
+    pend = deque(["alpha", "beta"])
+    ctrl = FormattedTextControl(
+        lambda: queue_fragments(pend, pull=pulls.append, width=80), focusable=False)
+    ctrl.create_content(width=80, height=3)              # populates self._fragments
+    ev = lambda y: MouseEvent(position=Point(4, y), event_type=MouseEventType.MOUSE_UP,
+                              button=MouseButton.LEFT, modifiers=frozenset())
+    assert ctrl.mouse_handler(ev(2)) is None and pulls == [1]    # row 2 = "beta"
+    assert ctrl.mouse_handler(ev(1)) is None and pulls == [1, 0] # row 1 = "alpha"
+    assert ctrl.mouse_handler(ev(0)) is NotImplemented           # header: no pull
+
+
+def test_pull_item_guards_draft_and_stale_index():
+    # The ONE pull implementation behind BOTH ↑ and click: never clobbers a
+    # typed draft; a stale index (queue drained between render and click) is
+    # ignored; a valid pull moves the item out with the cursor at the end.
+    from prompt_toolkit.buffer import Buffer
+    buf = Buffer(multiline=False)
+    buf.text = "half-typed draft"
+    pend = deque(["a", "b"])
+    assert pull_item(pend, buf, 1) is False              # draft protected
+    assert buf.text == "half-typed draft" and list(pend) == ["a", "b"]
+    buf.reset()
+    assert pull_item(pend, buf, 5) is False              # stale index ignored
+    assert pull_item(pend, buf, -1) is False
+    assert pull_item(pend, buf, 0) is True               # arbitrary index (click)
+    assert buf.text == "a" and buf.cursor_position == 1
+    assert list(pend) == ["b"]
+
+
+def test_up_arrow_pulls_newest_queued_into_empty_buffer_busy_or_idle():
+    from prompt_toolkit.buffer import Buffer
+
+    from webbee.tui import _arrow_up_action
+    for busy in (True, False):        # NOT busy-gated: the queue survives Esc into idle
+        buf = Buffer(multiline=False)
+        pend = deque(["older", "newest"])
+        event = _FakeEvent()
+        sel = {"i": None}
+        _arrow_up_action(event, buf, sel, 0, busy, pend)
+        assert buf.text == "newest"                      # the last thing queued
+        assert buf.cursor_position == len("newest")      # cursor ready at the end
+        assert list(pend) == ["older"]                   # it LEFT the queue
+        assert sel["i"] is None and event.app.invalidated is True
+
+
+def test_repeated_pulls_walk_newest_to_oldest():
+    from prompt_toolkit.buffer import Buffer
+
+    from webbee.tui import _arrow_up_action
+    buf = Buffer(multiline=False)
+    pend = deque(["a", "b", "c"])
+    event = _FakeEvent()
+    for expected in ("c", "b", "a"):
+        buf.reset()                                      # emptied (submitted/cleared)…
+        _arrow_up_action(event, buf, {"i": None}, 0, True, pend)
+        assert buf.text == expected                      # …then the next-newest pulls
+    assert not pend
+
+
+def test_up_arrow_with_text_present_never_clobbers_the_draft():
+    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 = "half-typed draft"
+        buf.load_history_if_not_yet_loaded()
+        await buf._load_history_task
+        pend = deque(["queued line"])
+        _arrow_up_action(_FakeEvent(), buf, {"i": None}, 0, True, pend)
+        assert list(pend) == ["queued line"]             # NOT pulled — buffer has text
+        assert buf.text == "submitted earlier"           # history served instead
+    asyncio.run(scenario())
+
+
+def test_pull_queued_takes_precedence_over_step_nav():
+    from prompt_toolkit.buffer import Buffer
+
+    from webbee.tui import _arrow_up_action
+    buf = Buffer(multiline=False)
+    pend = deque(["queued line"])
+    sel = {"i": None}
+    _arrow_up_action(_FakeEvent(), buf, sel, 3, False, pend)   # idle + steps + queue
+    assert buf.text == "queued line" and not pend        # the queued text is fresher intent
+    assert sel["i"] is None                              # steps reachable once queue empties
+
+
+def test_dock_end_to_end_panel_pull_reedit_requeue_and_clean_transcript():
+    # The full loop on the REAL Application: queue while busy → the item is in
+    # the PANEL (queue_fragments over the shared deque), NOT in the scrollback;
+    # ↑ pulls it into the input (it leaves the panel); Enter re-queues it at
+    # the tail; the natural drain announces itself (queued_run) and empties the
+    # panel; the transcript never saw a `⋯ queued` echo.
+    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, markers = [], []
+        gate = asyncio.Event()
+        busy = {"v": False}
+        pend = deque()
+
+        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,
+                    pending=pend, queued_run=markers.append))
+                await asyncio.sleep(0.05)
+                pipe.send_text("first\r")
+                await _until(lambda: ran == ["first"])           # turn 1 is running
+                pipe.send_text("second draft\r")                 # type-ahead → queue
+                await _until(lambda: list(pend) == ["second draft"])
+                assert "second draft" in _panel_text(queue_fragments(pend))  # in the PANEL
+                assert "⋯ queued" not in pane.dump()             # NOT in the scrollback
+                pipe.send_text("\x1b[A")                         # ↑ pulls it to edit
+                await _until(lambda: not pend)                   # it LEFT the panel
+                pipe.send_text(" v2\r")                          # edit + re-submit (busy)
+                await _until(lambda: list(pend) == ["second draft v2"])   # re-queued at tail
+                assert ran == ["first"]                          # still nothing mid-turn
+                gate.set()                                       # natural completion
+                await _until(lambda: ran == ["first", "second draft v2"])
+                assert markers == [0]                            # drain announced itself
+                await _until(lambda: not pend)                   # panel emptied
+                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
+        assert "⋯ queued" not in pane.dump()                     # transcript stayed CLEAN
+
+    asyncio.run(scenario())

webbee-0.3.12/src/webbee/__init__.py

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