webbee 0.3.23__tar.gz → 0.3.24__tar.gz

{webbee-0.3.23 → webbee-0.3.24}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.3.24
+
+The tab bar got a real design: the active tab is a solid highlighted chip,
+tabs are clearly separated, and spacing is uniform — plus a message typed
+on Home no longer shows up twice in the new tab.
+
+- Tabs now render as padded chips with uniform spacing, a clear dim
+  separator between every pair, and the active tab as a solid
+  bee-yellow block — unmistakable at a glance, no more squinting to find
+  which tab you're on.
+- Typing a task on Home and landing in the new session tab no longer
+  double-prints your first message in that tab's transcript.
+- Each tab now keeps its own input draft — switch away and back, your
+  unsent text is right where you left it.
+
 ## 0.3.23
 
 If a task on your session is waiting for your terminal — sent from the panel

{webbee-0.3.23 → webbee-0.3.24}/PKG-INFO

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

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

webbee-0.3.24/src/webbee/__init__.py

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

{webbee-0.3.23 → webbee-0.3.24}/src/webbee/repl.py

@@ -573,11 +573,19 @@ async def _home_input(text: str, *, slots: SlotManager, cfg, token_provider, mod
     ui_hooks.get("switch", slots.switch)(idx)
     if spawn_poller is not None:
         spawn_poller(new_slot)
-    new_slot.sink.user_echo(text)
     start_turn_in = ui_hooks.get("start_turn_in")
     if start_turn_in is not None:
+        # 0.3.24 fix: the dock's start-turn seam threads through on_line ->
+        # `_handle`, which ALREADY echoes the typed line itself for every
+        # non-command line (the SAME canonical echo every other typed line
+        # in the dock gets) -- echoing here too doubled it up in the new
+        # tab's transcript (Valentin, live on 0.3.22/0.3.23).
         start_turn_in(new_slot, text)
     else:
+        # No dock: `run_turn` (repl's `_run_turn`) never echoes on its own
+        # (it only runs the agent turn), so this IS the one echo the typed
+        # line gets.
+        new_slot.sink.user_echo(text)
         await run_turn(new_slot, text)
 
 

{webbee-0.3.23 → webbee-0.3.24}/src/webbee/slots.py

@@ -27,6 +27,10 @@ class SessionSlot:
     pending: deque = field(default_factory=deque)
     turn: dict = field(default_factory=lambda: {"task": None})
     pulled: dict = field(default_factory=lambda: {"text": "", "iid": ""})
+    draft: str = ""                    # 0.3.24: per-tab unsent input -- stashed on switch-away,
+                                        # restored on switch-back (browser-tab model: each tab
+                                        # keeps its own form state); cleared on genuine submit.
+    draft_cursor: int = 0              # cursor position within `draft`, restored alongside it
     qp_ui: dict = field(default_factory=lambda: {"collapsed": False})
     tp_ui: dict = field(default_factory=lambda: {"collapsed": False})
     mode: str = "default"

{webbee-0.3.23 → webbee-0.3.24}/src/webbee/tabs.py

@@ -1,17 +1,29 @@
-"""The tab bar — THE visible piece of the browser-in-terminal (W4a Task 4).
-`tab_fragments` is a PURE builder, queue_panel discipline (unit-tested
-without an Application, no prompt_toolkit import at module top — only
-inside the mouse handlers): it renders ONE row, Home always first (glyph
-fixed ◆, label "Home", NEVER a close ✕), then every session slot numbered
-by its own SlotManager list index (the same index `slots.switch(idx)`/
-`slots.close(idx)` take), glyph from `slot.status_glyph()` (⚠/▶/○). The
-ACTIVE tab (Home or session) is accented (`class:tab.active`); a
-NON-active session tab whose glyph is ⚠ gets `class:tab.alert` — the
-consent badge Valentin sees from whichever tab he's looking at, not just
-the one waiting. Each tab's body is a 3-tuple fragment (MOUSE_UP ->
-on_switch(idx), NotImplemented otherwise — wheel keeps working, same
-event discipline as queue_panel._item_handler); each SESSION tab's
-trailing ` ✕` is its OWN fragment (MOUSE_UP -> on_close(idx)). Unlike the
+"""The tab bar — THE visible piece of the browser-in-terminal (W4a Task 4;
+chip redesign 0.3.24 — Valentin: tabs were hard to notice and hard to
+control, needed clear separators and uniform spacing). `tab_fragments`
+is a PURE builder, queue_panel discipline (unit-tested without an
+Application, no prompt_toolkit import at module top — only inside the
+mouse handlers): it renders ONE row of padded CHIPS, each `" {glyph}
+{label} "` — ONE leading + ONE trailing space baked INSIDE the styled
+fragment itself, so every chip carries identical breathing room regardless
+of style. Home is always first (glyph fixed ◆, label "Home", NEVER a close
+✕); every session slot is numbered by its own SlotManager list index (the
+same index `slots.switch(idx)`/`slots.close(idx)` take) and shaped
+`" {marker} {idx}·{label} {glyph} "` — `marker` (●/○) is THIS tab's own
+active/inactive dot, `glyph` is `slot.status_glyph()` (⚠/▶/○). The ACTIVE
+tab's chip is a SOLID bee-yellow block (`class:tab.active` — background,
+not just text, so it's unmistakable at a glance); a NON-active session
+tab whose glyph is ⚠ gets `class:tab.alert` (yellow text, no bg — only the
+active chip owns a background, so the alert never competes with it). A
+dim `" │ "` (`class:tab.sep`) sits between every pair of tabs — exactly
+one, never at the ends — so the eye always finds the boundary. Each tab's
+body is a 3-tuple fragment (MOUSE_UP -> on_switch(idx), NotImplemented
+otherwise — wheel keeps working, same event discipline as
+queue_panel._item_handler); each SESSION tab's trailing `" ✕ "` is its OWN
+padded fragment (MOUSE_UP -> on_close(idx)), styled `class:tab.close.
+active` instead of the plain dim `class:tab.close` when its tab is the
+active one — same bg as its chip, so the close glyph reads as part of the
+SAME contiguous block rather than a separate dim afterthought. Unlike the
 queue/todo panels this bar is NEVER hidden — even a single slot (Home
 alone) renders it; it IS the new look."""
 
@@ -19,6 +31,8 @@ TAB_STYLE_ACTIVE = "class:tab.active"
 TAB_STYLE_IDLE = "class:tab"
 TAB_STYLE_ALERT = "class:tab.alert"
 TAB_STYLE_CLOSE = "class:tab.close"
+TAB_STYLE_CLOSE_ACTIVE = "class:tab.close.active"
+TAB_STYLE_SEP = "class:tab.sep"
 
 _SEP = " │ "
 _MIN_LABEL = 8
@@ -76,11 +90,11 @@ def tab_fragments(slots, *, on_switch, on_close, width: int = 0, forward=None):
     `SlotManager` (or anything shaped like one — `.slots` + `.active_idx`);
     slot 0 is always treated as Home. `width` (0 = unknown/no truncation —
     headless or pre-first-render) is divided evenly across every SESSION
-    label after subtracting Home's own fixed text, the ` │ ` separators and
-    each session tab's own marker/index/glyph/close overhead, then each
-    label is `_fit` to its share. Returns [] only when `slots` has no slots
-    at all (never happens in practice — Home always occupies index 0).
-    `forward` (FIX6, optional — `None` preserves every existing caller's
+    label after subtracting Home's own fixed chip text, the ` │ ` separators
+    and each session tab's own marker/index/glyph/padding/close overhead,
+    then each label is `_fit` to its share. Returns [] only when `slots` has
+    no slots at all (never happens in practice — Home always occupies index
+    0). `forward` (FIX6, optional — `None` preserves every existing caller's
     behavior verbatim) is threaded into EVERY mouse handler this function
     hands out (Home's own switch handler included) so a drag armed in the
     output pane just below gets first refusal on every tab-bar click."""
@@ -91,14 +105,14 @@ def tab_fragments(slots, *, on_switch, on_close, width: int = 0, forward=None):
     home = slot_list[0]
     sessions = list(enumerate(slot_list[1:], start=1))
 
-    home_text = f"◆ {home.label or 'Home'}"
+    home_text = f" ◆ {home.label or 'Home'} "
     seps = len(sessions)   # one separator before each session tab
 
     pieces = []   # (idx, slot, prefix, suffix, close_text)
     for idx, slot in sessions:
         marker = "●" if idx == active_idx else "○"
         glyph = slot.status_glyph()
-        pieces.append((idx, slot, f"{marker}{idx} ", f" {glyph}", " ✕"))
+        pieces.append((idx, slot, f" {marker} {idx}·", f" {glyph} ", " ✕ "))
 
     budget = 0
     if width > 0 and pieces:
@@ -111,7 +125,7 @@ def tab_fragments(slots, *, on_switch, on_close, width: int = 0, forward=None):
     frags.append((home_style, home_text, _switch_handler(on_switch, 0, forward)))
 
     for idx, slot, prefix, suffix, close_text in pieces:
-        frags.append((TAB_STYLE_IDLE, _SEP))
+        frags.append((TAB_STYLE_SEP, _SEP))
         is_active = idx == active_idx
         glyph = suffix.strip()
         label = slot.label or ""
@@ -120,6 +134,7 @@ def tab_fragments(slots, *, on_switch, on_close, width: int = 0, forward=None):
         style = TAB_STYLE_ACTIVE if is_active else (
             TAB_STYLE_ALERT if glyph == "⚠" else TAB_STYLE_IDLE)
         frags.append((style, f"{prefix}{label}{suffix}", _switch_handler(on_switch, idx, forward)))
-        frags.append((TAB_STYLE_CLOSE, close_text, _close_handler(on_close, idx, forward)))
+        close_style = TAB_STYLE_CLOSE_ACTIVE if is_active else TAB_STYLE_CLOSE
+        frags.append((close_style, close_text, _close_handler(on_close, idx, forward)))
 
     return frags

{webbee-0.3.23 → webbee-0.3.24}/src/webbee/tui.py

@@ -432,6 +432,19 @@ def _swap_history(buf, slot) -> None:
     buf.history = slot.history
 
 
+def _restore_draft(buf, slot) -> None:
+    """0.3.24 (per-tab drafts — the browser-tab model: each tab keeps its own
+    form state): `buf.reset()` must run FIRST (it clears the history-load
+    task state -- unchanged from before this fix), THEN the buffer's live
+    text/cursor are set from `slot`'s OWN stashed draft -- restoring exactly
+    what was mid-type in THIS tab the last time it was left, never another
+    tab's. `min(...)` guards a shrunk/replaced draft never leaving the
+    cursor past the end of the text it's now landing on."""
+    buf.reset()
+    buf.text = slot.draft
+    buf.cursor_position = min(slot.draft_cursor, len(buf.text))
+
+
 async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
                       stop_turn=None, queued_run=None, inject=None,
                       home_input=None, cancel_slot=None, ui_hooks=None,
@@ -656,6 +669,12 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
         slot = _a()
         text = _rewrap_pulled(slot.pulled, scrub_mouse_residue(buf.text))
         buf.reset()
+        # 0.3.24: a genuine Enter retires THIS slot's own stashed draft too
+        # -- otherwise the NEXT switch-away-then-back (nothing typed in
+        # between) would restore text that was already sent, resurrecting a
+        # message the user believes is long gone.
+        slot.draft = ""
+        slot.draft_cursor = 0
         cp = _sink_attr("consent_pending")
         if cp and cp():
             rc = _sink_attr("resolve_consent")
@@ -933,22 +952,28 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
         # it does, neither the history swap nor the redraw happen, so a
         # click on the active tab is a true no-op, never a crash. `prev`
         # captured BEFORE the switch (FIX7b) -- it's the slot we're LEAVING.
+        # 0.3.24: stashed UNCONDITIONALLY, before the switch even resolves --
+        # harmless on a no-op switch (prev IS the still-active slot, so this
+        # is just re-saving its own current text over itself).
         prev = slots.active()
+        prev.draft = buf.text
+        prev.draft_cursor = buf.cursor_position
         if slots.switch(idx):
-            _swap_history(buf, slots.active())
-            # FIX7b: a draft mid-type must NOT survive a switch (it belongs
-            # to the tab you were looking at, not the one you're switching
-            # into -- history load already re-points the buffer's recall
-            # list; the buffer's own live TEXT needs the same reset), and
-            # the LEAVING slot's own pulled-queue-item carry (↑ pull-to-edit,
-            # see _rewrap_pulled) must be dropped -- otherwise a stale
-            # steer_iid can ride along into a totally different slot's
-            # later resubmit (the kernel's dedup ring would then wrongly
-            # dedup a genuinely new message against a landed twin that was
-            # never even the SAME conversation).
-            buf.reset()
-            prev.pulled["text"] = ""
-            prev.pulled["iid"] = ""
+            entering = slots.active()
+            _swap_history(buf, entering)
+            # 0.3.24 (per-tab drafts, product decision -- was FIX7b's "drafts
+            # dropped on switch"): a draft mid-type belongs to the tab you
+            # typed it into, browser-tab style -- switching away no longer
+            # destroys it, it comes right back when you switch back to THIS
+            # tab (`_restore_draft`, which still runs the history-load
+            # `buf.reset()` first). The leaving slot's own pulled-queue-item
+            # carry (↑ pull-to-edit, see _rewrap_pulled) is no longer cleared
+            # here either -- it now travels WITH the draft on its own slot,
+            # so resubmitting it unedited after a round trip still dedups
+            # correctly against a landed twin; `_rewrap_pulled`'s one-shot
+            # consume (on the Enter that actually resubmits, in whichever
+            # slot is active then) is what retires it, not a switch.
+            _restore_draft(buf, entering)
             if on_switch is not None:
                 on_switch(idx)
             get_app().invalidate()
@@ -961,12 +986,14 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
         # FIX7d: the SURVIVOR (post-close active) slot's own history takes
         # over the shared input buffer, exactly like any other switch — a
         # closed tab's history dies with it, so the buffer must never keep
-        # pointing at it; the buffer's own draft is dropped too (same
-        # discipline as `_switch_to`'s FIX7b — a close ALSO changes which
-        # tab you're looking at).
+        # pointing at it. 0.3.24: the buffer now loads the SURVIVOR's own
+        # draft (same `_restore_draft` a plain switch uses) instead of a
+        # bare reset -- the closed tab's own draft is simply gone with it,
+        # nothing to stash (it's not coming back).
         if close_active(slots, cancel_slot):
-            _swap_history(buf, slots.active())
-            buf.reset()
+            survivor = slots.active()
+            _swap_history(buf, survivor)
+            _restore_draft(buf, survivor)
             get_app().invalidate()
             return True
         return False
@@ -981,8 +1008,9 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
         # per-tab idx of their own, so they keep meaning "close what I'm
         # looking at" via `_close_flow`/`close_active` below.
         if close_at(slots, idx, cancel_slot):
-            _swap_history(buf, slots.active())   # FIX7d, same as _close_flow above
-            buf.reset()
+            survivor = slots.active()
+            _swap_history(buf, survivor)         # FIX7d, same as _close_flow above
+            _restore_draft(buf, survivor)        # 0.3.24, same as _close_flow above
             get_app().invalidate()
             return True
         return False
@@ -1036,10 +1064,12 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
     style = Style.from_dict({
         "frame.border": "#5f5f5f",           # muted grey chrome — furniture, not focus
         "prompt": "#00afd7 bold",            # cyan ❯ — the interactive accent
-        "tab": "#8a8a8a",                    # idle tab — dim, same family as tb.dim
-        "tab.active": "#e8a317 bold",        # the VISIBLE tab — bee-yellow, same accent as tb.spin
-        "tab.alert": "#e8a317 bold reverse", # ⚠ consent waiting in a BACKGROUND tab — reversed so it pops next to tab.active
-        "tab.close": "#8a8a8a",              # the ✕ — dim, closing is never the default action
+        "tab": "#8a8a8a",                    # idle chip — dim text, no bg
+        "tab.active": "bg:#e8a317 #1c1c1c bold",  # the ACTIVE chip — solid bee-yellow bg, dark text: unmistakable
+        "tab.alert": "#e8a317 bold",         # ⚠ consent waiting in a BACKGROUND tab — yellow text, no bg (only the active chip owns one)
+        "tab.close": "#8a8a8a",              # the ✕ on a background tab — dim, closing is never the default action
+        "tab.close.active": "bg:#e8a317 #1c1c1c",  # the ✕ on the ACTIVE tab — same bg as its chip, reads as one contiguous block
+        "tab.sep": "#3a3a3a",                # the │ between tabs — dim, consistent, exactly one per pair, none at the ends
         "tb.dim": "#8a8a8a",                 # idle chrome / secondary bits — dim
         "tb.spin": "#e8a317 bold",           # animated spinner — bee-yellow, pops
         "tb.working": "#e8a317",             # 'working' — yellow

{webbee-0.3.23 → webbee-0.3.24}/tests/test_home.py

@@ -357,6 +357,52 @@ def test_home_input_new_slot_sink_records_echo(monkeypatch):
     assert slots.slots[1].sink.echoed == ["hello"]
 
 
+def test_home_input_dock_path_echoes_exactly_once():
+    """Regression pin (0.3.24, Valentin live on 0.3.22/0.3.23): typing on Home
+    opened a new session tab whose transcript showed the first message TWICE.
+    Root cause was `_home_input` echoing the typed line itself AND handing off
+    to `ui_hooks["start_turn_in"]` (tui's `_start_turn_in` -> `_run_turn` ->
+    `on_line` -> repl's `_handle`), which echoes AGAIN for every non-command
+    typed line (`_handle`'s own `slot.sink.user_echo(line)` -- the canonical
+    echo every OTHER typed line in the dock already goes through). This fake
+    `start_turn_in` mirrors that real seam (it echoes, exactly like `_handle`
+    does) so the count below actually exercises the double-echo path, not
+    just the echo-free fallback branch `test_home_input_new_slot_sink_records_
+    echo` above already covers."""
+    slots = SlotManager()
+    slots.add(_home_slot(workspace="/cwd"))
+
+    async def fake_make_session_slot(cfg, tp, ws, mode, *, resources, shared_client,
+                                      agent_factory, intel_factory, shadow_factory, first):
+        s = _session_slot(workspace=ws)
+        s.sink = _EchoSink()
+        return s
+
+    import webbee.repl as repl_mod
+    orig = repl_mod._make_session_slot
+    repl_mod._make_session_slot = fake_make_session_slot
+
+    def fake_start_turn_in(slot, text):
+        # Stands in for tui._start_turn_in's REAL chain (on_line -> _handle),
+        # which echoes the line itself for every non-command typed line.
+        slot.sink.user_echo(text)
+
+    async def never_called(slot, text):
+        raise AssertionError("fallback run_turn must not fire when start_turn_in is wired")
+
+    try:
+        asyncio.run(_home_input(
+            "hello", slots=slots, cfg=None, token_provider=None, mode="default",
+            resources=WorkspaceResources(), shared_client=None, agent_factory=None,
+            intel_factory=None, shadow_factory=None, workspace="/cwd",
+            ui_hooks={"start_turn_in": fake_start_turn_in}, run_turn=never_called))
+    finally:
+        repl_mod._make_session_slot = orig
+
+    new_slot = slots.slots[1]
+    assert new_slot.sink.echoed == ["hello"]   # exactly ONE echo -- not two
+
+
 # ---- _schedule_home_refill --------------------------------------------------
 
 def test_schedule_home_refill_ignores_non_home_idx():

{webbee-0.3.23 → webbee-0.3.24}/tests/test_tabs.py

@@ -1,13 +1,21 @@
-"""tab_fragments (W4a Task 4) — the browser tab bar as a PURE fragment
-builder, queue_panel discipline: unit-tested without a prompt_toolkit
-Application. Home always first, glyph fixed ◆, never closable; session
-tabs carry their own switch/close mouse handlers and middle-truncate their
-labels to fit a live width."""
+"""tab_fragments (W4a Task 4; chip redesign 0.3.24) — the browser tab bar as
+a PURE fragment builder, queue_panel discipline: unit-tested without a
+prompt_toolkit Application. Home always first, glyph fixed ◆, never
+closable; session tabs carry their own switch/close mouse handlers and
+middle-truncate their labels to fit a live width. Every tab renders as a
+padded CHIP (`" {glyph} {label} "` — one leading + one trailing space baked
+into the styled fragment itself), separated by exactly one dim `" │ "`
+between each pair (none at the ends); the ACTIVE tab's chip carries
+`class:tab.active` (resolved to a solid bg in tui.py's Style dict) and its
+`✕` carries `class:tab.close.active` so the whole row reads as one
+contiguous block."""
 from prompt_toolkit.data_structures import Point
 from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
 
 from webbee.slots import SessionSlot, SlotManager
-from webbee.tabs import _fit, tab_fragments
+from webbee.tabs import (TAB_STYLE_ACTIVE, TAB_STYLE_ALERT, TAB_STYLE_CLOSE,
+                         TAB_STYLE_CLOSE_ACTIVE, TAB_STYLE_IDLE, TAB_STYLE_SEP,
+                         _fit, tab_fragments)
 
 
 class _FakeSink:
@@ -64,33 +72,64 @@ def test_active_tab_gets_accent_and_active_marker():
     frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
     text = _text(frags)
     styles = {f[1]: f[0] for f in frags}
-    assert "●1 alpha ○" in text                      # active session marked ●N
-    assert "○2 beta ○" in text                        # inactive session marked ○N
-    assert styles["●1 alpha ○"] == "class:tab.active"
-    assert styles["○2 beta ○"] == "class:tab"
+    assert " ● 1·alpha ○ " in text                      # active session marked ●N, padded chip
+    assert " ○ 2·beta ○ " in text                        # inactive session marked ○N, padded chip
+    assert styles[" ● 1·alpha ○ "] == TAB_STYLE_ACTIVE
+    assert styles[" ○ 2·beta ○ "] == TAB_STYLE_IDLE
 
 
 def test_home_active_gets_accent_style_but_glyph_and_label_stay_fixed():
     slots = _mk_slots(("alpha", _FakeSink()), active_idx=0)
     frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
     home_frag = frags[0]
-    assert home_frag[1] == "◆ Home"
-    assert home_frag[0] == "class:tab.active"
+    assert home_frag[1] == " ◆ Home "
+    assert home_frag[0] == TAB_STYLE_ACTIVE
 
 
 def test_home_inactive_is_idle_style():
     slots = _mk_slots(("alpha", _FakeSink()), active_idx=1)
     frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
     home_frag = frags[0]
-    assert home_frag[1] == "◆ Home"
-    assert home_frag[0] == "class:tab"
+    assert home_frag[1] == " ◆ Home "
+    assert home_frag[0] == TAB_STYLE_IDLE
 
 
 def test_glyphs_come_from_status_glyph_busy_and_idle():
     slots = _mk_slots(("alpha", _FakeSink(busy=True)), ("beta", _FakeSink()), active_idx=1)
     text = _text(tab_fragments(slots, on_switch=_noop, on_close=_noop))
-    assert "alpha ▶" in text
-    assert "beta ○" in text
+    assert " ● 1·alpha ▶ " in text
+    assert " ○ 2·beta ○ " in text
+
+
+# ── chip padding + separators (0.3.24 redesign) ─────────────────────────────
+
+def test_every_chip_body_has_uniform_single_space_padding():
+    # Home + every session body fragment (never the sep/close pieces) starts
+    # and ends with EXACTLY one space, not zero and not two.
+    slots = _mk_slots(("alpha", _FakeSink()), ("beta", _FakeSink()), active_idx=1)
+    frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
+    bodies = [f[1] for f in frags if f[0] not in (TAB_STYLE_SEP, TAB_STYLE_CLOSE, TAB_STYLE_CLOSE_ACTIVE)]
+    assert bodies == [" ◆ Home ", " ● 1·alpha ○ ", " ○ 2·beta ○ "]
+    for body in bodies:
+        assert body.startswith(" ") and not body.startswith("  ")
+        assert body.endswith(" ") and not body.endswith("  ")
+
+
+def test_exactly_one_separator_between_each_pair_of_tabs_none_at_ends():
+    slots = _mk_slots(("alpha", _FakeSink()), ("beta", _FakeSink()), ("gamma", _FakeSink()), active_idx=1)
+    frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
+    seps = [f for f in frags if f[0] == TAB_STYLE_SEP]
+    assert len(seps) == 3                          # one before EACH session tab
+    assert all(f[1] == " │ " for f in seps)
+    assert frags[0][0] != TAB_STYLE_SEP             # never at the very start (Home's own chip)
+    assert frags[-1][0] != TAB_STYLE_SEP            # never at the very end (last tab's close)
+
+
+def test_close_fragment_is_uniformly_padded():
+    slots = _mk_slots(("alpha", _FakeSink()), active_idx=1)
+    frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
+    close = [f[1] for f in frags if f[0] in (TAB_STYLE_CLOSE, TAB_STYLE_CLOSE_ACTIVE)]
+    assert close == [" ✕ "]
 
 
 # ── ⚠ background consent badge ──────────────────────────────────────────────
@@ -101,8 +140,20 @@ def test_alert_badge_on_background_consent_tab():
     slots = _mk_slots(("alpha", _FakeSink()), ("beta", _FakeSink(consent=True)), active_idx=1)
     frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
     styles = {f[1]: f[0] for f in frags}
-    assert "○2 beta ⚠" in styles
-    assert styles["○2 beta ⚠"] == "class:tab.alert"
+    assert " ○ 2·beta ⚠ " in styles
+    assert styles[" ○ 2·beta ⚠ "] == TAB_STYLE_ALERT
+
+
+def test_alert_style_never_applied_to_the_active_tab_itself():
+    # tab.alert exists ONLY to flag a BACKGROUND tab -- an ACTIVE tab that
+    # happens to have a ⚠ (own pending consent) must never get tab.alert,
+    # since only the active chip owns a background and alert has none (it
+    # would silently lose its highlight).
+    slots = _mk_slots(("alpha", _FakeSink(consent=True)), ("beta", _FakeSink()), active_idx=1)
+    frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
+    styles = {f[1]: f[0] for f in frags}
+    assert styles[" ● 1·alpha ⚠ "] == TAB_STYLE_ACTIVE
+    assert TAB_STYLE_ALERT not in styles.values()
 
 
 def test_active_tab_with_consent_pending_stays_active_styled_not_alert():
@@ -112,8 +163,8 @@ def test_active_tab_with_consent_pending_stays_active_styled_not_alert():
     slots = _mk_slots(("alpha", _FakeSink(consent=True)), active_idx=1)
     frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
     styles = {f[1]: f[0] for f in frags}
-    assert "●1 alpha ⚠" in styles
-    assert styles["●1 alpha ⚠"] == "class:tab.active"
+    assert " ● 1·alpha ⚠ " in styles
+    assert styles[" ● 1·alpha ⚠ "] == TAB_STYLE_ACTIVE
 
 
 # ── Home has no close ───────────────────────────────────────────────────────
@@ -121,10 +172,10 @@ def test_active_tab_with_consent_pending_stays_active_styled_not_alert():
 def test_home_never_gets_a_close_fragment():
     slots = _mk_slots(("alpha", _FakeSink()), active_idx=1)
     frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
-    assert not any(f[1].strip() == "✕" and f[0] == "class:tab.close" for f in frags[:1])
+    assert not any(f[1].strip() == "✕" for f in frags[:1])
     # Only ONE fragment renders before the first separator (Home's body) —
     # no trailing close piece tacked onto it.
-    assert frags[0][1] == "◆ Home"
+    assert frags[0][1] == " ◆ Home "
     assert frags[1][1] == " │ "   # separator, not a close glyph
 
 
@@ -165,7 +216,10 @@ def test_session_close_fragment_fires_on_close_with_its_index():
     frags = tab_fragments(slots, on_switch=_noop, on_close=hits.append)
     close_alpha = frags[3]     # [home, sep, alpha, CLOSE-alpha, sep, beta, close-beta]
     close_beta = frags[6]
-    assert close_alpha[1] == " ✕" and close_alpha[0] == "class:tab.close"
+    # alpha (idx 1) IS the active tab -- its ✕ gets the bg-contiguous style;
+    # beta (idx 2, background) keeps the plain dim one.
+    assert close_alpha[1] == " ✕ " and close_alpha[0] == TAB_STYLE_CLOSE_ACTIVE
+    assert close_beta[1] == " ✕ " and close_beta[0] == TAB_STYLE_CLOSE
     assert _up(close_alpha[2]) is None and hits == [1]
     assert _up(close_beta[2]) is None and hits == [1, 2]
 
@@ -196,12 +250,14 @@ def test_fit_middle_truncates_and_never_shrinks_below_floor():
 
 
 def test_narrow_width_truncates_labels_to_the_floor_and_row_fits():
-    # width=42 is chosen so the computed per-label budget lands exactly on
-    # the 8-char floor: both long labels truncate to precisely 8 chars and
-    # the whole row still fits inside `width` (no floor-forced overflow).
+    # width=52 is chosen so the computed per-label budget lands exactly on
+    # the 8-char floor (chip padding raises the fixed per-tab overhead from
+    # the pre-0.3.24 shape, so the exact width that lands on the floor
+    # shifted too): both long labels truncate to precisely 8 chars and the
+    # whole row still fits inside `width` (no floor-forced overflow).
     label1, label2 = "workspace-one-long-name", "workspace-two-long-name"
     slots = _mk_slots((label1, _FakeSink()), (label2, _FakeSink()), active_idx=1)
-    width = 42
+    width = 52
     frags = tab_fragments(slots, on_switch=_noop, on_close=_noop, width=width)
     text = _text(frags)
     assert len(text) <= width
@@ -225,7 +281,7 @@ def test_single_slot_home_alone_still_renders_the_bar():
     slots = _mk_slots(active_idx=0)
     frags = tab_fragments(slots, on_switch=_noop, on_close=_noop)
     assert frags
-    assert _text(frags) == "◆ Home"
+    assert _text(frags) == " ◆ Home "
 
 
 def test_empty_slot_manager_renders_nothing():

{webbee-0.3.23 → webbee-0.3.24}/tests/test_tui.py

@@ -3319,12 +3319,13 @@ def test_dock_mounts_sticky_todo_panel_above_queue_panel():
 # a mid-turn tab switch. No tab-bar UI yet (Task 4) -- these tests switch
 # tabs directly via `slots.active_idx`, exactly as a future keybinding will.
 
-def test_switching_tabs_drops_the_leaving_tabs_unsent_draft():
-    # FIX7b: a draft mid-type belongs to the tab you were looking at when
-    # you typed it, never the one you switch into -- _switch_to's
-    # buf.reset() must drop it (plan-mandated: drafts dropped, history
-    # load-task reset), not just repoint the recall history.
-    from prompt_toolkit.application import create_app_session
+def test_switching_tabs_preserves_the_draft_and_restores_it_on_return():
+    # 0.3.24 (per-tab drafts, product decision -- supersedes FIX7b's "drafts
+    # dropped on switch"): a draft mid-type belongs to the tab you typed it
+    # into, browser-tab style -- it must survive a switch AWAY and come back
+    # verbatim (text + cursor) on a switch BACK, while the tab you switched
+    # INTO in between never sees it.
+    from prompt_toolkit.application import create_app_session, get_app
     from prompt_toolkit.input import create_pipe_input
     from prompt_toolkit.output import DummyOutput
 
@@ -3349,14 +3350,27 @@ def test_switching_tabs_drops_the_leaving_tabs_unsent_draft():
                 await asyncio.sleep(0.05)
                 pipe.send_text("partial draft")          # no Enter -- just a draft in progress
                 await asyncio.sleep(0.05)
+                get_app().current_buffer.cursor_position = 7   # mid-text, not just "at the end"
 
                 pipe.send_text("\x1b1")                    # Alt+1 -- switch to B
                 await _until(lambda: slots.active_idx == 1)
+                assert get_app().current_buffer.text == ""      # B never sees A's draft
 
-                pipe.send_text("\r")                        # Enter on an (expected) EMPTY buffer
+                pipe.send_text("\r")                        # Enter on B's (genuinely empty) buffer
                 await asyncio.sleep(0.1)
-                assert ran == []                             # the draft never resubmitted as a line
+                assert ran == []                             # nothing resubmitted on B
 
+                pipe.send_text("\x1b0")                      # Alt+0 -- switch back to A
+                await _until(lambda: slots.active_idx == 0)
+                assert get_app().current_buffer.text == "partial draft"   # restored verbatim
+                assert get_app().current_buffer.cursor_position == 7      # cursor restored too
+
+                # Exit via B -- idx 0 is structurally unclosable in this
+                # 2-slot fixture (SlotManager.close's own Home-guard treats
+                # index 0 as never closable, session or not), same escape
+                # route the pre-0.3.24 version of this test used.
+                pipe.send_text("\x1b1")
+                await _until(lambda: slots.active_idx == 1)
                 pipe.send_text("\x04")
                 await _until(lambda: len(slots.slots) == 1)
                 pipe.send_text("\x04")
@@ -3366,16 +3380,123 @@ def test_switching_tabs_drops_the_leaving_tabs_unsent_draft():
     asyncio.run(scenario())
 
 
-def test_switch_clears_the_leaving_slots_pulled_carry_so_a_stale_iid_cannot_leak():
-    # FIX7b: a pulled-but-never-resubmitted queue item's steer_iid must not
-    # outlive a switch AWAY from its own slot -- otherwise a LATER, wholly
-    # unrelated line that happens to match the pulled text verbatim (typed
-    # after switching away and back) would wrongly inherit a STALE dedup
-    # iid, misleading the kernel's ring into treating a genuinely NEW
-    # message as a duplicate of a pull that's long gone.
+def test_home_draft_is_isolated_from_a_session_tabs_draft():
+    # Companion to the round-trip test above, specifically for Home: typing
+    # on Home (never submitted -- home_input owns plain text there, no
+    # Enter needed for this test) must not leak into a session tab's buffer,
+    # and Home's own draft must survive a round trip exactly like a session
+    # tab's does.
+    from prompt_toolkit.application import create_app_session, get_app
+    from prompt_toolkit.input import create_pipe_input
+    from prompt_toolkit.output import DummyOutput
+
+    from webbee import tui
+    from webbee.slots import SessionSlot, SlotManager
+
+    async def scenario():
+        home = SessionSlot(kind="home", workspace=".", label="Home",
+                           pane=tui.OutputPane(width=80), sink=None, agent=None)
+        session = SessionSlot(kind="session", workspace=".", label="a",
+                              pane=tui.OutputPane(width=80), sink=_idle_sink(), agent=None)
+        slots = SlotManager()
+        slots.add(home)
+        slots.add(session)
+        slots.active_idx = 0
+
+        async def on_line(text, slot=None): ...
+
+        with create_pipe_input() as pipe:
+            with create_app_session(input=pipe, output=DummyOutput()):
+                task = asyncio.create_task(tui.run_session(
+                    slots=slots, on_line=on_line, on_cycle=lambda: None,
+                    home_input=lambda text: None))
+                await asyncio.sleep(0.05)
+                pipe.send_text("home draft")
+                await asyncio.sleep(0.05)
+
+                pipe.send_text("\x1b1")                    # Alt+1 -- switch to the session tab
+                await _until(lambda: slots.active_idx == 1)
+                assert get_app().current_buffer.text == ""      # session tab never sees Home's draft
+
+                pipe.send_text("session draft")
+                await asyncio.sleep(0.05)
+
+                pipe.send_text("\x1b0")                      # Alt+0 -- back to Home
+                await _until(lambda: slots.active_idx == 0)
+                assert get_app().current_buffer.text == "home draft"   # Home's OWN draft restored
+
+                pipe.send_text("\x1b1")                      # back to the session tab
+                await _until(lambda: slots.active_idx == 1)
+                assert get_app().current_buffer.text == "session draft"   # its own draft, untouched
+
+                pipe.send_text("\x1b0")
+                await _until(lambda: slots.active_idx == 0)
+                pipe.send_text("\x04")
+                ok = await asyncio.wait_for(task, 5)
+        assert ok is True
+
+    asyncio.run(scenario())
+
+
+def test_submitting_a_line_clears_that_slots_draft_so_it_never_resurrects():
+    # 0.3.24: a genuine submit must retire the stashed draft too -- otherwise
+    # switching away and back after sending a message would restore text
+    # that was already sent, silently resurrecting it in the input box.
+    from prompt_toolkit.application import create_app_session, get_app
+    from prompt_toolkit.input import create_pipe_input
+    from prompt_toolkit.output import DummyOutput
+
+    from webbee import tui
+    from webbee.slots import SessionSlot
+
+    async def scenario():
+        pane_a, pane_b = tui.OutputPane(width=80), tui.OutputPane(width=80)
+        ran = []
+
+        async def on_line(text, slot=None):
+            ran.append(text)
+
+        slots = mk_slots(pane=pane_a, sink=_idle_sink())
+        slots.add(SessionSlot(kind="session", workspace=".", label="b",
+                              pane=pane_b, sink=_idle_sink(), agent=None))
+
+        with create_pipe_input() as pipe:
+            with create_app_session(input=pipe, output=DummyOutput()):
+                task = asyncio.create_task(tui.run_session(
+                    slots=slots, on_line=on_line, on_cycle=lambda: None))
+                await asyncio.sleep(0.05)
+                pipe.send_text("go\r")                       # type + submit, idle slot -> starts a turn
+                await _until(lambda: ran == ["go"])
+
+                pipe.send_text("\x1b1")                        # switch away
+                await _until(lambda: slots.active_idx == 1)
+                pipe.send_text("\x1b0")                        # ...and back
+                await _until(lambda: slots.active_idx == 0)
+                assert get_app().current_buffer.text == ""      # NOT resurrected
+
+                pipe.send_text("\x1b1")
+                await _until(lambda: slots.active_idx == 1)
+                pipe.send_text("\x04")
+                await _until(lambda: len(slots.slots) == 1)
+                pipe.send_text("\x04")
+                ok = await asyncio.wait_for(task, 5)
+        assert ok is True
+
+    asyncio.run(scenario())
+
+
+def test_switch_preserves_the_leaving_slots_pulled_carry_so_resubmit_unchanged_still_dedups():
+    # 0.3.24 (product decision, supersedes FIX7b's "pulled cleared on the
+    # way out"): pulled now travels WITH the draft, on its own slot -- a
+    # pulled-but-not-yet-resubmitted queue item survives a switch away and
+    # back, and resubmitting it UNCHANGED after the round trip still reuses
+    # its ORIGINAL steer_iid, so the kernel's dedup ring can still catch a
+    # landed twin exactly as if the user had never glanced at another tab.
+    # `_rewrap_pulled`'s one-shot consume still retires it -- on the Enter
+    # that actually resubmits, not on the switch.
     from collections import deque
 
-    from prompt_toolkit.application import create_app_session
+    from prompt_toolkit.application import create_app_session, get_app
     from prompt_toolkit.input import create_pipe_input
     from prompt_toolkit.output import DummyOutput
 
@@ -3407,14 +3528,17 @@ def test_switch_clears_the_leaving_slots_pulled_carry_so_a_stale_iid_cannot_leak
 
                 pipe.send_text("\x1b1")                        # Alt+1 -- switch away WITHOUT resubmitting
                 await _until(lambda: slots.active_idx == 1)
-                assert slot_a.pulled == {"text": "", "iid": ""}   # FIX7b: cleared on the way out
+                assert slot_a.pulled == {"text": "queued text", "iid": "iid-1"}   # SURVIVES the switch
+                assert slot_a.draft == "queued text"                              # draft travels with it
 
                 pipe.send_text("\x1b0")                        # Alt+0 -- switch back to A
                 await _until(lambda: slots.active_idx == 0)
+                assert get_app().current_buffer.text == "queued text"   # restored, unedited
 
-                pipe.send_text("queued text\r")                # coincidentally the SAME text, typed fresh
+                pipe.send_text("\r")                            # resubmit UNCHANGED -- no retyping
                 await _until(lambda: ran == ["queued text"])
-                assert getattr(ran[0], "iid", "") == ""         # NOT the stale iid-1 -- a genuinely new line
+                assert getattr(ran[0], "iid", "") == "iid-1"    # ORIGINAL iid preserved -- dedup intact
+                assert slot_a.pulled == {"text": "", "iid": ""}  # one-shot: consumed by THIS Enter, not the switch
 
                 pipe.send_text("\x1b1")                          # switch to B -- A (idx 0) is unclosable here
                 await _until(lambda: slots.active_idx == 1)
@@ -4016,7 +4140,7 @@ def test_tab_bar_window_is_root_hsplit_first_child():
                 assert not isinstance(bar, ConditionalContainer)   # ALWAYS visible
                 text = "".join(f[1] for f in bar.content.text())
                 assert "◆ Home" in text                            # Home always first
-                assert "●1 proj" in text                           # active session, marked ●N
+                assert "● 1·proj" in text                          # active session, marked ●N
                 pipe.send_text("\x04")
                 ok = await asyncio.wait_for(task, 5)
         assert ok is True
@@ -4495,7 +4619,7 @@ def test_tab_bar_close_click_closes_the_clicked_background_tab_not_the_active_on
                 frags = bar.content.text()
                 # frags: [home, sep, a-body, a-CLOSE, sep, b-body, b-close]
                 close_a = frags[3]
-                assert close_a[1] == " ✕"
+                assert close_a[1] == " ✕ "
                 ev = MouseEvent(position=Point(0, 0), event_type=MouseEventType.MOUSE_UP,
                                 button=MouseButton.LEFT, modifiers=frozenset())
                 close_a[2](ev)                                 # click ✕ on the BACKGROUND tab a
@@ -4546,7 +4670,7 @@ def test_tab_bar_close_click_closes_the_active_tab_when_that_is_the_one_clicked(
                 bar = get_app().layout.container.children[0]
                 frags = bar.content.text()
                 close_b = frags[6]
-                assert close_b[1] == " ✕"
+                assert close_b[1] == " ✕ "
                 ev = MouseEvent(position=Point(0, 0), event_type=MouseEventType.MOUSE_UP,
                                 button=MouseButton.LEFT, modifiers=frozenset())
                 close_b[2](ev)                                 # click ✕ on the ACTIVE tab b

webbee-0.3.23/src/webbee/__init__.py

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