webbee 0.3.15__tar.gz → 0.3.16__tar.gz

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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.15"
+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.15 → webbee-0.3.16}/src/webbee/render.py

@@ -139,6 +139,13 @@ 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
@@ -325,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:

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

@@ -344,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)

{webbee-0.3.15 → webbee-0.3.16}/tests/test_render.py

@@ -603,6 +603,55 @@ def test_end_turn_and_abort_clear_remote_rows_in_place():
     assert rows == [] and s.remote_pending is rows
 
 
+# ── 0.3.16: queue-panel single-source dedup (steer_iid reconciliation) ────────
+# The steer_iid minted at enqueue time is the ONE key both legs carry; the
+# display layer now consumes it too: a duplicated task_queued frame
+# (at-least-once delivery) never doubles a row, and the kernel echo of a
+# terminal-injected line REPLACES its local fallback twin — one message,
+# one owner (the kernel), one panel row.
+
+def test_remote_queued_ignores_duplicate_frame_same_iid():
+    s = _sink()
+    s.remote_queued("terminal", "ship it", "i1")
+    s.remote_queued("terminal", "ship it", "i1")   # publish retry / SSE resume
+    assert [r["iid"] for r in s.remote_pending] == ["i1"]
+
+
+def test_remote_queued_empty_iid_never_dedups():
+    # Legacy kernels emit steer_iid="" — identical re-typed lines must keep
+    # appending (text is NOT a dedup key).
+    s = _sink()
+    s.remote_queued("telegram", "same text", "")
+    s.remote_queued("telegram", "same text", "")
+    assert len(s.remote_pending) == 2
+
+
+def test_remote_queued_promotes_local_twin_to_kernel_owned():
+    # A failed-LOOKING inject that actually landed leaves a local QueuedLine
+    # twin; the kernel echo (same iid) is positive proof it landed — the
+    # local row goes, the message shows exactly once (kernel-owned).
+    from collections import deque
+
+    from webbee.tui import QueuedLine
+    s = _sink()
+    lp = deque([QueuedLine("ship it", "i1"), QueuedLine("other", "i9")])
+    s.local_pending = lp
+    s.remote_queued("terminal", "ship it", "i1")
+    assert [str(x) for x in lp] == ["other"]
+    assert [r["iid"] for r in s.remote_pending] == ["i1"]
+
+
+def test_remote_dequeued_nonempty_iid_unmatched_is_noop():
+    # task_dequeued twins (the kernel emits one per pop, dedup-dropped twins
+    # included) must never eat a DIFFERENT same-origin row: the origin-FIFO
+    # fallback is legacy-only (empty iid).
+    s = _sink()
+    s.remote_queued("terminal", "a", "i1")
+    s.remote_queued("terminal", "b", "i2")
+    s.remote_dequeued("terminal", "i-unknown")
+    assert [r["iid"] for r in s.remote_pending] == ["i1", "i2"]
+
+
 # ── 0.3.14: the terminal-local yes/no confirm (autopilot safe-asymmetry) ──────
 
 def test_ask_yes_no_sync_fallback_strict_yes_only():

{webbee-0.3.15 → webbee-0.3.16}/tests/test_repl.py

@@ -395,6 +395,15 @@ def test_boot_survives_intel_import_failure_base_install(monkeypatch):
     assert sink.turns == []  # boot completed cleanly, no crash mid-boot
 
 
+def test_boot_shares_local_queue_with_sink():
+    # The repl hands the sink the SAME type-ahead deque tui mutates, so the
+    # kernel's task_queued echo can promote a local twin into the single
+    # kernel-owned row (queue-panel single-source dedup, 0.3.16).
+    from collections import deque
+    sink, agent = _run(read_line=_lines("/exit"))
+    assert isinstance(getattr(sink, "local_pending", None), deque)
+
+
 def test_boot_skips_intel_when_disabled_in_config(monkeypatch):
     monkeypatch.setattr("webbee.repl.AgentSession", _SpyAgent)
     called = []

webbee-0.3.15/src/webbee/__init__.py

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