webbee 0.3.14__tar.gz → 0.3.16__tar.gz

{webbee-0.3.14 → webbee-0.3.16}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.3.16
+
+- A message typed while Webbee is working now shows in the queue panel
+  exactly once: the queue reconciles every entry by its id, so a retried
+  delivery or a send that only looked failed no longer produces a duplicate
+  row.
+
+## 0.3.15
+
+- Type a follow-up while Webbee is working and it now flies into the current
+  run within seconds (not after it finishes), shown in the queue tagged by
+  where it came from. The task list is now a pinned panel that stays visible
+  and updates live.
+
 ## 0.3.14
 
 - See queued messages from Telegram/panel right in the terminal queue

{webbee-0.3.14 → webbee-0.3.16}/PKG-INFO

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

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

webbee-0.3.16/src/webbee/__init__.py

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

{webbee-0.3.14 → webbee-0.3.16}/src/webbee/render.py

@@ -139,6 +139,21 @@ class RichSink:
         # queue panel reads THIS list object every redraw — mutate in place
         # only (append/del/clear), never rebind.
         self.remote_pending: list = []
+        # The repl's OWN type-ahead deque (the SAME object tui mutates),
+        # shared by reference at boot. remote_queued reconciles against it:
+        # a kernel task_queued echo carrying a local QueuedLine's steer_iid
+        # is positive proof the inject landed — the local twin is removed so
+        # one message is one row with ONE owner (the kernel). None until the
+        # repl wires it (minimal sinks / unit tests without a queue).
+        self.local_pending = None
+        # The current coding checklist (sticky todo panel, 0.3.15) — the twin
+        # of remote_pending: todos() replaces its contents in place on every
+        # todo frame; the dock's todo panel reads THIS list object every
+        # redraw. Sticky: it persists across turn ends (the panel stays up)
+        # and clears only on /clear.
+        self.current_todos: list = []
+        self._todo_counts = (0, 0)      # kernel-reported (done, total)
+        self._todos_dirty = False       # a turn touched the list -> end_turn records it
 
     def _nudge(self) -> None:
         """After output/state changes: let the pane follow the tail + redraw."""
@@ -213,6 +228,14 @@ class RichSink:
         # would linger as phantoms. Clear them (in place — the panel holds
         # this list object).
         self.remote_pending.clear()
+        # Sticky-todo scrollback record (0.3.15): in the dock the live panel
+        # replaced the inline re-renders, so print the FINAL checklist state
+        # ONCE per turn that touched it — the transcript keeps the history
+        # while the panel itself persists (sticky) into idle.
+        if self._on_output is not None and self._todos_dirty and self.current_todos:
+            done, total = self._todo_counts
+            self._todos_inline(self.current_todos, total, done)
+        self._todos_dirty = False
         final_text = _clean(final_text)
         if final_text:
             self.console.print()   # separation before the focus block
@@ -237,15 +260,41 @@ class RichSink:
         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."""
+        """Checklist state for the coding TODO scratchpad. The kernel
+        republishes the FULL list on every todo_write; each update replaces
+        `current_todos` IN PLACE (the dock's sticky todo panel holds this
+        list object and re-reads it every redraw — 0.3.15, no more inline
+        scroll-away in the dock; end_turn prints the final checklist ONCE as
+        the scrollback record). Headless / non-dock sinks (no on_output pane)
+        keep today's full inline render. Defensive both ways: malformed items
+        are skipped, bad counts degrade, never raises."""
+        rows = []
+        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
+            rows.append({"content": content,
+                         "status": str(item.get("status", "") or "")})
+        self.current_todos[:] = rows           # in place — the panel holds this list
+        try:
+            self._todo_counts = (int(done), int(total))
+        except (TypeError, ValueError):
+            self._todo_counts = (sum(1 for r in rows if r["status"] == "completed"),
+                                 len(rows))
+        self._todos_dirty = True
+        if self._on_output is not None:        # dock: the sticky panel renders it live
+            self._nudge()
+            return
+        self._todos_inline(items, total, done)
+
+    def _todos_inline(self, items, total, done) -> None:
+        """The Claude-Code-style INLINE checklist render (the pre-0.3.15
+        behavior, verbatim): one line per item — ✓ completed (dim, struck) ·
+        ▶ in progress (bold, so "what's happening now" pops) · ○ pending
+        (muted), order preserved. Used by the headless/non-dock path on every
+        todo frame and by end_turn's one-shot scrollback record in the dock."""
         try:
             head = f"📋 Todos ({int(done)}/{int(total)})"
         except (TypeError, ValueError):
@@ -283,25 +332,46 @@ class RichSink:
         queue panel the instant it queues — tagged `[origin]`, "as if typed".
         DISPLAY-ONLY: it renders above the local rows but is never pullable
         (↑/click) — the kernel owns it; only a `task_dequeued` (or turn end)
-        removes it."""
+        removes it. This is the ONE reconciliation chokepoint (0.3.16): the
+        steer_iid minted at enqueue time dedups the display too — a frame
+        delivered twice (publish retry / SSE resume) never doubles a row, and
+        the echo of a terminal-injected line whose POST merely LOOKED failed
+        removes its local fallback twin (the echo is positive proof it
+        landed; kernel-owned = one row). Empty iid (legacy kernels) always
+        appends — text is never a dedup key."""
+        iid = str(iid or "")
+        if iid:
+            if any(r.get("iid") == iid for r in self.remote_pending):
+                self._nudge()
+                return
+            lp = self.local_pending
+            if lp is not None:
+                twin = next((q for q in lp if getattr(q, "iid", "") == iid), None)
+                if twin is not None:
+                    try:
+                        lp.remove(twin)
+                    except ValueError:
+                        pass
         self.remote_pending.append({"origin": _clean(str(origin or "")),
                                     "text": _clean(str(text or "")),
-                                    "iid": str(iid or "")})
+                                    "iid": iid})
         self._nudge()
 
     def remote_dequeued(self, origin: str, iid: str) -> None:
         """The kernel drained (or dedup-dropped) one queued item
-        (`task_dequeued` frame): remove its panel row — by `iid` when it
-        matches, else the OLDEST row of that origin (the kernel queue is
-        FIFO, so when an iid is missing/lost the oldest same-origin row is
-        the one that just started). Nothing matched → no-op (the row was
-        already cleared or its announce was never seen)."""
+        (`task_dequeued` frame): remove its panel row by `iid`. The
+        oldest-same-origin fallback is LEGACY-ONLY (empty iid — the kernel
+        queue is FIFO, so the oldest row of that origin is the one that just
+        started): a NON-empty unmatched iid is a no-op, because the kernel
+        emits one dequeue per pop INCLUDING dedup-dropped twins, and a twin's
+        second dequeue must never eat a different same-origin row. Nothing
+        matched → no-op (the row was already cleared or never announced)."""
         iid = str(iid or "")
         origin = _clean(str(origin or ""))
         rows = self.remote_pending
         idx = next((i for i, r in enumerate(rows) if iid and r.get("iid") == iid),
                    None)
-        if idx is None:
+        if idx is None and not iid:
             idx = next((i for i, r in enumerate(rows) if r.get("origin") == origin),
                        None)
         if idx is None:
@@ -346,7 +416,10 @@ class RichSink:
         self._nudge()
 
     def clear(self) -> None:
-        """/clear: wipe the pane/screen + reset the session counters."""
+        """/clear: wipe the pane/screen + reset the session counters. The
+        sticky todo panel resets with it (in place — the panel holds the
+        list object); a mid-run abort deliberately does NOT (the last known
+        plan state is still true and the panel is always-on)."""
         self.console.clear()
         self.tokens = 0
         self.credits = 0
@@ -354,6 +427,8 @@ class RichSink:
         self.session_credits = 0
         self._tools = 0
         self._current = ""
+        self.current_todos.clear()
+        self._todos_dirty = False
         self._nudge()
 
     def abort(self) -> None:

{webbee-0.3.14 → webbee-0.3.16}/src/webbee/repl.py

@@ -54,6 +54,30 @@ async def run_marathon(cfg, mode: str, goal: str, *, sink=None, auth=None,
     return text
 
 
+async def _inject_via_gateway(cfg, token_provider, agent, sink,
+                              text: str, steer_iid: str) -> bool:
+    """The gateway leg of the dock's Enter-while-busy fly-in (mid-turn inject,
+    0.3.15): POST the line straight into the agent's LIVE running session so
+    the marathon absorbs it at the next brain step (seconds), instead of
+    holding it client-side until the turn ends. On ok the line is kernel-owned
+    — the ❯ echo records it as sent and the kernel's task_queued[terminal]
+    echo drives the panel row. False on ANY failure (no live session yet,
+    network, auth, gateway refusal) — the dock then falls back to today's
+    local type-ahead queue (tui._inject_or_queue), carrying the same iid so
+    the kernel ring dedups a twin. Module-level so tests drive it directly."""
+    sid = getattr(agent, "session_id", "")
+    if not sid:
+        return False
+    try:
+        from webbee.thread import inject_to_session
+        ok = await inject_to_session(cfg, token_provider, sid, text, steer_iid)
+    except Exception:
+        return False
+    if ok:
+        sink.user_echo(text)   # the transcript records the message as sent
+    return ok
+
+
 async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None, read_line=input,
                    agent_factory=None, auth=None, account_fetcher=None,
                    sessions_client=None, intel_factory=None, shadow_factory=None) -> None:
@@ -220,9 +244,12 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                 _sink.note(res.message)
             return "continue"
 
-        # A task for the agent.
+        # A task for the agent. A drained type-ahead line minted for a
+        # failed mid-turn inject still carries its steer_iid (tui.QueuedLine)
+        # -- thread it so the kernel's dedup ring drops the twin if the
+        # inject actually landed server-side (a plain typed line has none).
         _sink.user_echo(line)
-        await _run_turn(line)
+        await _run_turn(line, steer_iid=getattr(line, "iid", ""))
         return "continue"
 
     async def _run_turn(line: str, surface: str = "", steer_iid: str = "") -> None:
@@ -317,6 +344,11 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
     async def _boot(s) -> None:
         nonlocal _sink, agent, intel, watcher_task, shadow, steer_task
         _sink = s
+        # Queue-panel single-source dedup (0.3.16): hand the sink the SAME
+        # type-ahead deque tui mutates, so a kernel task_queued echo can
+        # promote a landed local twin (matched by steer_iid) into the one
+        # kernel-owned row. Reference share — never a copy.
+        s.local_pending = pending_queue
         # Cache git branch OFF the event loop (subprocess.run blocks it). Only
         # /status reads it; recomputing it per input line froze the dock.
         state["git_branch"] = await asyncio.to_thread(_git_branch, workspace)
@@ -382,6 +414,9 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                         stop_turn=lambda: agent.stop(),
                         pending=pending_queue, queued_run=_sink.queued_run,
                         remote_pending=getattr(_sink, "remote_pending", None),
+                        todos=getattr(_sink, "current_todos", None),
+                        inject=lambda text, iid: _inject_via_gateway(
+                            cfg, token_provider, agent, _sink, text, iid),
                     )
                 finally:
                     _cancel_background()

{webbee-0.3.14 → webbee-0.3.16}/src/webbee/session.py

@@ -226,19 +226,20 @@ class AgentSession:
 
                     elif ftype in ("task_queued", "task_dequeued"):
                         # Full-queue-layer K1: a follow-up queued into the RUNNING
-                        # kernel session from another surface shows in the live
-                        # queue panel the instant it queues (tagged by origin) and
-                        # leaves the panel when the kernel drains it. These frames
-                        # carry NO task_id (they belong to the session, not a
-                        # turn), so the C7 filter never eats them; getattr-guarded
-                        # like todos/queued_run — a minimal sink drops them, a
-                        # render error never breaks the loop. The terminal's own
-                        # follow-ups already sit in the LOCAL panel — skip
-                        # terminal-origin twins.
+                        # kernel session shows in the live queue panel the instant
+                        # it queues (tagged by origin) and leaves the panel when
+                        # the kernel drains it. These frames carry NO task_id
+                        # (they belong to the session, not a turn), so the C7
+                        # filter never eats them; getattr-guarded like todos/
+                        # queued_run — a minimal sink drops them, a render error
+                        # never breaks the loop. Terminal-origin rows render TOO
+                        # (mid-turn inject, 0.3.15): an injected line never sits
+                        # in the LOCAL panel — the kernel's echo is its only row,
+                        # and task_dequeued clears it when the turn absorbs it.
                         _origin = str(frame.get("origin", "") or "")
                         _hook = getattr(sink, "remote_queued" if ftype == "task_queued"
                                         else "remote_dequeued", None)
-                        if _hook is not None and _origin != "terminal":
+                        if _hook is not None:
                             _iid = str(frame.get("steer_iid", "") or "")
                             try:
                                 if ftype == "task_queued":

{webbee-0.3.14 → webbee-0.3.16}/src/webbee/thread.py

@@ -8,7 +8,8 @@ itself -- `_boot` wraps the whole replay in one try/except so a network
 failure never blocks/delays boot beyond the timeout, it just skips the
 replay (same division of labor as remote.py + the /notify call site).
 Also home to the /thread endpoint's pending-steer sibling read (liveness v2
-§B) -- the drain webbee.steer polls while the REPL is idle."""
+§B) -- the drain webbee.steer polls while the REPL is idle -- and the
+mid-turn inject POST (0.3.15) the dock fires on Enter-while-busy."""
 from __future__ import annotations
 
 _DISPLAY_LIMIT = 400
@@ -67,6 +68,27 @@ async def fetch_pending_steer(cfg, token_provider, session_id: str) -> dict:
         return r.json() or {}
 
 
+async def inject_to_session(cfg, token_provider, session_id: str, text: str,
+                            steer_iid: str) -> bool:
+    """Mid-turn inject (0.3.15): POST an Enter-while-busy line straight into
+    the user's OWN running session — `/v1/agent/sessions/{id}/inject`, body
+    `{text, steer_iid}`. The gateway signals a task_id-LESS new_task, so the
+    kernel's mid-turn fly-in absorbs it at the next brain step under the
+    running turn's own task_id (frames stay visible in this terminal), and
+    the given steer_iid rides the kernel's dedup ring. Returns True only when
+    the gateway accepted it ({ok: true}). Non-swallowing like its siblings
+    above — the repl wiring wraps it and falls back to the local type-ahead
+    queue on any failure."""
+    import httpx
+    token = await token_provider()
+    async with httpx.AsyncClient(base_url=cfg.api_url, timeout=10) as c:
+        r = await c.post(f"/v1/agent/sessions/{session_id}/inject",
+                         json={"text": text, "steer_iid": steer_iid},
+                         headers={"Authorization": f"Bearer {token}"})
+        r.raise_for_status()
+        return bool((r.json() or {}).get("ok"))
+
+
 def truncate_for_display(text, limit: int = _DISPLAY_LIMIT) -> str:
     """Cap one replayed message's text so a single huge assistant reply can't
     flood the boot screen -- foreign_turn renders one line per message."""

webbee-0.3.16/src/webbee/todo_panel.py

@@ -0,0 +1,91 @@
+"""The STICKY todo panel pinned above the queue panel (0.3.15 — replaces the
+inline scroll-away checklist in the dock: the plan now stays visible and
+updates in place on every `todo` frame, mirroring the proven queue-panel
+pattern). The builders here are PURE (unit-tested without an Application);
+tui.run_session mounts them in a ConditionalContainer that occupies ZERO rows
+while the list is empty, so the todo-less dock is pixel-identical to before.
+The panel reads the sink-owned `RichSink.current_todos` list object every
+redraw (in-place mutation, the twin of `remote_pending`); the scrollback
+record is the ONE inline checklist RichSink.end_turn prints per turn. Split
+into its own file like queue_panel.py to stay far under the size ceiling."""
+
+from webbee.queue_panel import one_line
+
+TP_MAX_ITEMS = 6   # item rows shown; completed collapse first, then `… +K more`
+
+
+def _rows(todos) -> list:
+    """PURE. Normalize to (status, content) pairs: dict items with a
+    non-empty content only — malformed entries are skipped, never raised on
+    (same defensive contract as the inline checklist render)."""
+    out = []
+    for t in (todos if isinstance(todos, (list, tuple)) else ()):
+        if not isinstance(t, dict):
+            continue
+        content = str(t.get("content", "") or "").strip()
+        if not content:
+            continue
+        out.append((str(t.get("status", "") or ""), content))
+    return out
+
+
+def todo_fragments(todos, width: int = 0):
+    """PURE builder: the panel as prompt_toolkit formatted text, re-invoked
+    every redraw (same live mechanics as the queue panel) so every todo_write
+    republish shows at once. Layout, top→bottom = plan order:
+
+        📋 Todos (done/total)
+        … ✓K done            ← completed collapse FIRST when over the cap
+        ✓ finished item      ← green glyph, dim struck text
+        ▶ current item       ← bold bee-yellow — NEVER hidden by the cap
+        ○ pending item       ← muted
+        … +K more            ← pending overflow beyond TP_MAX_ITEMS
+
+    Counts derive from the items themselves (the kernel republishes the FULL
+    list on every todo_write). Empty/malformed-only list → [] (panel hidden)."""
+    rows = _rows(todos)
+    if not rows:
+        return []
+    done = sum(1 for s, _ in rows if s == "completed")
+    frags = [("class:tp.header", f" 📋 Todos ({done}/{len(rows)})")]
+    show = rows
+    hidden_done = 0
+    if len(show) > TP_MAX_ITEMS:
+        # History compresses first: collapse the completed items into one
+        # summary row so the live part of the plan keeps its rows.
+        active = [r for r in show if r[0] != "completed"]
+        hidden_done = len(show) - len(active)
+        show = active
+    extra = 0
+    if len(show) > TP_MAX_ITEMS:
+        cut = show[TP_MAX_ITEMS:]
+        extra = len(cut)
+        show = show[:TP_MAX_ITEMS]
+        cur = next((r for r in cut if r[0] == "in_progress"), None)
+        if cur is not None:
+            show[-1] = cur   # what's happening NOW is never hidden by the cap
+    if hidden_done:
+        frags.append(("class:tp.done", f"\n   … ✓{hidden_done} done"))
+    for status, content in show:
+        text = one_line(content, width - 5 if width > 0 else 0)
+        if status == "completed":
+            frags.append(("class:tp.done", "\n   ✓ "))
+            frags.append(("class:tp.done.text", text))
+        elif status == "in_progress":
+            frags.append(("class:tp.now", "\n   ▶ " + text))
+        else:                              # pending / unknown -> not started yet
+            frags.append(("class:tp.item", "\n   ○ " + text))
+    if extra:
+        frags.append(("class:tp.item", f"\n   … +{extra} more"))
+    return frags
+
+
+def todo_height(todos) -> int:
+    """PURE. Rows the panel needs — derived from the SAME fragments the panel
+    renders (header line + one per newline), so height can never desync from
+    the visible rows. 0 when the list is empty (the ConditionalContainer
+    hides the panel then anyway)."""
+    frags = todo_fragments(todos)
+    if not frags:
+        return 0
+    return 1 + sum(f[1].count("\n") for f in frags)