webbee 0.3.11__tar.gz → 0.3.13__tar.gz

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

@@ -1,5 +1,27 @@
 # 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,
+  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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.11"
+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.11 → webbee-0.3.13}/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.11 → webbee-0.3.13}/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.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.11 → 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()
 
@@ -215,6 +225,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 +266,17 @@ class RichSink:
         self.console.print(_pad(Text(" ❯ " + _clean(text) + " ", style="bold white on grey30")))
         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.11 → webbee-0.3.13}/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,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_run=_sink.queued_run,
                     )
                 finally:
                     _cancel_background()

{webbee-0.3.11 → webbee-0.3.13}/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