webbee 0.3.36__tar.gz → 0.3.37__tar.gz

{webbee-0.3.36 → webbee-0.3.37}/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 0.3.37
+
+Your tabs come back, the queue does what you tell it, and the version sits
+where you asked for it.
+
+- **Closing the terminal no longer throws your work away.** Three tabs of live
+  work used to become one empty tab on the next start. Your layout is
+  remembered per repo and restored on boot — and it is reconciled against what
+  is *actually* still running, so a tab that really ended comes back as a
+  labelled tab rather than a dead one pretending to be alive. An accidental
+  exit, Ctrl-D and a crash all remember equally. Autopilot is deliberately
+  never remembered: a mode that acts on its own has to be turned on each time.
+- **A queue you can actually manage.** Every queued line now has its own **✕**,
+  so you can remove *any* item — previously the only way out was ↑, which
+  hijacked your input and could only ever reach the newest row, leaving item 1
+  of 3 stuck. `/queue drop N` and `/queue edit N` do the same from the keyboard
+  when your terminal reports no mouse. Editing an item *removes* it from the
+  queue as it moves into your input, so a line can never both sit in the queue
+  and still fire.
+- **Version badge, bottom-right of the window.** Pinned to the corner of the
+  whole window rather than floating inside the toolbar's content. On a narrow
+  terminal the badge is dropped instead of truncating real information.
+- **A live-session indicator that keeps telling you the truth.** The old boot
+  note fired once and scrolled away. The toolbar now shows "● live",
+  "● live · needs approval" or "○ N elsewhere", refreshed every 30 seconds from
+  what the server actually reports — and it stays empty when nothing is
+  running, so an idle dock gains no permanent noise.
+- **✕, Ctrl+W and `/close` all really do close a tab** — they always shared one
+  teardown path; what was missing was saying so, and the busy-close note now
+  names all three ways out.
+- Fixed two latent crashes that would only have fired on a click (a queue panel
+  and a row renderer were each used without being imported).
+
 ## 0.3.36
 
 Write on more than one line, and see what a session actually costs.

{webbee-0.3.36 → webbee-0.3.37}/PKG-INFO

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

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

webbee-0.3.37/src/webbee/__init__.py

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

{webbee-0.3.36 → webbee-0.3.37}/src/webbee/active_sessions.py

@@ -39,6 +39,85 @@ async def fetch_active_sessions(cfg, token_provider, *, client=None) -> list[dic
         return []
 
 
+def live_session_ids(sessions: list[dict]) -> set:
+    """PURE. The set of session ids the gateway currently reports as RUNNING.
+    One helper so the tab-restore reconciliation and the status indicator read
+    liveness from the SAME shape (0.3.37)."""
+    return {str(s.get("session_id") or "") for s in (sessions or [])
+            if str(s.get("session_id") or "")}
+
+
+def session_indicator(sessions: list[dict], repo_key: str) -> str:
+    """PURE. The PERSISTENT live-session indicator for the toolbar (0.3.37).
+
+    Before this, a running Temporal workflow was mentioned exactly once, in a
+    boot note that scrolled away -- so after an accidental exit and reopen the
+    terminal silently re-attached with nothing on screen ever confirming that
+    it had seen a running session, or that one existed at all.
+
+    Returns a SHORT string for the status line, or "" when there is nothing
+    to say (no running sessions at all -- silence is correct then, the dock
+    must not grow permanent noise):
+      * this repo has a live session      -> "● live"
+      * ...and it is parked on an approval -> "● live · needs approval"
+      * only OTHER repos have live ones    -> "○ 2 elsewhere"
+    Honest by construction: it reports what the gateway's Temporal listing
+    actually says, never a guess.
+    """
+    suffix = f"-r{repo_key}"
+    own, own_parked, others = False, False, 0
+    for s in (sessions or []):
+        sid = str(s.get("session_id") or "")
+        if not sid:
+            continue
+        if sid.endswith(suffix):
+            own = True
+            if s.get("pending_consent"):
+                own_parked = True
+        else:
+            others += 1
+    if own:
+        return "● live · needs approval" if own_parked else "● live"
+    if others:
+        return f"○ {others} elsewhere"
+    return ""
+
+
+def plan_tab_restore(saved: list, sessions: list[dict]) -> list:
+    """PURE. Reconcile the REMEMBERED tab layout (tab_store.load_tabs) against
+    the sessions Temporal reports as Running, and decide per tab what reopening
+    it means (0.3.37).
+
+    Each returned dict is the saved record plus:
+      * `attach`: True  -> its workflow is STILL RUNNING; the tab must re-attach
+                           and pick the live run up where it left off.
+        `attach`: False -> nothing is running under that id any more; restore
+                           the tab's state (label/mode/draft) only.
+      * `pending_consent`: carried through from the live listing so a restored
+        tab can immediately show it is parked on an approval.
+
+    A saved tab with no session_id is legal (a tab you never sent anything in)
+    and simply restores as state-only. Never raises; unknown/extra keys on the
+    saved record are ignored rather than trusted.
+    """
+    live = {}
+    for s in (sessions or []):
+        sid = str(s.get("session_id") or "")
+        if sid:
+            live[sid] = s
+    out = []
+    for rec in (saved or []):
+        if not isinstance(rec, dict):
+            continue
+        sid = str(rec.get("session_id") or "")
+        s = live.get(sid)
+        item = dict(rec)
+        item["attach"] = bool(sid and s is not None)
+        item["pending_consent"] = bool((s or {}).get("pending_consent"))
+        out.append(item)
+    return out
+
+
 def boot_reattach_notice(sessions: list[dict], repo_key: str) -> list[str]:
     """Decide what, if anything, to tell the user about their OTHER running
     sessions once THIS terminal's own boot replay has finished. `sessions`

{webbee-0.3.36 → webbee-0.3.37}/src/webbee/commands.py

@@ -111,6 +111,23 @@ def dispatch(line: str, ctx: CommandContext) -> SlashResult:
         # 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.
+        # 0.3.37: drop/edit ONE queued item by its 1-based /queue number --
+        # the KEYBOARD twin of the panel's per-row ✕ and click-to-edit, so
+        # managing a 3-deep queue works on terminals with no mouse reporting
+        # (tmux without mouse on, restrictive SSH clients) too. The repl owns
+        # the actual deque mutation; this layer only validates + routes.
+        if args and args[0].lower() in ("drop", "remove", "rm", "edit"):
+            verb = "queue_drop" if args[0].lower() != "edit" else "queue_edit"
+            if len(args) < 2:
+                return SlashResult(handled=True, action="queue",
+                                   message=f"Usage: /queue {args[0].lower()} <number> "
+                                           f"(see /queue for the numbers).")
+            raw = args[1]
+            if not raw.isdigit() or int(raw) < 1 or int(raw) > len(ctx.queued):
+                return SlashResult(handled=True, action="queue",
+                                   message=(f"No queued item #{raw}. "
+                                            f"Queue holds {len(ctx.queued)}."))
+            return SlashResult(handled=True, action=verb, arg=str(int(raw)))
         if args and args[0].lower() == "clear":
             n = len(ctx.queued)
             return SlashResult(handled=True, action="queue_clear",
@@ -122,7 +139,8 @@ def dispatch(line: str, ctx: CommandContext) -> SlashResult:
         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}"))
+                                    f"one per finished turn:\n{lines}\n"
+                                    f"  /queue drop <n> · /queue edit <n> · /queue clear"))
     if cmd == "/steps":
         if args:
             return SlashResult(handled=True, action="step_detail", arg=args[0])

{webbee-0.3.36 → webbee-0.3.37}/src/webbee/queue_panel.py

@@ -68,6 +68,43 @@ def pull_item(pending, buf, index: int):
     return item
 
 
+def drop_item(pending, index: int):
+    """The ONE queue-REMOVE implementation (0.3.37) — serves the per-row ✕ in
+    the panel. Deletes pending[index] WITHOUT touching the input buffer, so
+    removing item #1 of 3 no longer forces you to pull it into the input just
+    to get rid of it (before this, the only exit from the queue was
+    `pull_item`, which is edit-the-line, hijacks the buffer and — bound to ↑ —
+    only ever reached the NEWEST row).
+
+    Guards mirror `pull_item`: a stale index (the queue drained between render
+    and click) is ignored rather than raising or eating the wrong row. Returns
+    the removed item, or None when nothing was removed.
+    """
+    if not (0 <= index < len(pending)):
+        return None
+    item = pending[index]
+    del pending[index]
+    return item
+
+
+def _drop_handler(drop, index: int, forward=None):
+    """One row's ✕ mouse handler: MOUSE_UP removes THAT queued item via
+    `drop(index)`. Same event discipline as `_item_handler` (MOUSE_UP only,
+    `forward` gets first refusal so a drag released here is not mistaken for
+    a click) — the difference is purely WHICH action fires, so a ✕ click can
+    never be confused with the row-body click that pulls for editing.
+    """
+    def _h(mouse_event):
+        from prompt_toolkit.mouse_events import MouseEventType
+        if forward is not None and forward(mouse_event):
+            return None
+        if mouse_event.event_type == MouseEventType.MOUSE_UP:
+            drop(index)
+            return None
+        return NotImplemented
+    return _h
+
+
 def _item_handler(pull, index: int, forward=None):
     """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
@@ -109,7 +146,7 @@ def _toggle_handler(toggle, forward=None):
 
 def queue_fragments(pending, pull=None, width: int = 0, remote=None,
                      collapsed=False, toggle=None, max_items=QP_MAX_ITEMS,
-                     forward=None):
+                     forward=None, drop=None):
     """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 —
@@ -159,7 +196,9 @@ def queue_fragments(pending, pull=None, width: int = 0, remote=None,
     if collapsed:
         return frags
     if n:
-        frags.append(("class:qp.item", " · ↑ edit last · click to edit"))
+        hint = (" · ↑ edit last · click to edit · ✕ remove" if drop is not None
+                else " · ↑ edit last · click to edit")
+        frags.append(("class:qp.item", hint))
     rstart = max(0, len(rem) - max_items)
     if rstart:
         frags.append(("class:qp.remote", f"\n   … +{rstart} more"))
@@ -177,9 +216,17 @@ def queue_fragments(pending, pull=None, width: int = 0, remote=None,
         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)
+        # 0.3.37: reserve the ✕ column so the row text truncates BEFORE the
+        # button rather than shoving it off-screen on a narrow terminal.
+        avail = (width - 4 - (2 if drop is not None else 0)) if width > 0 else 0
+        row = "\n   " + one_line(items[i], avail)
         if pull is None:
             frags.append((style, row))
         else:
             frags.append((style, row, _item_handler(pull, i, forward)))
+        if drop is not None:
+            # Its OWN fragment + OWN handler: clicking ✕ removes the item,
+            # clicking the row body still pulls it for editing. Two adjacent
+            # targets, zero ambiguity.
+            frags.append(("class:qp.drop", " ✕", _drop_handler(drop, i, forward)))
     return frags

{webbee-0.3.36 → webbee-0.3.37}/src/webbee/repl.py

@@ -174,7 +174,7 @@ def _slot_ctx(slot: SessionSlot, *, logged_in: bool, slots=None) -> CommandConte
 # number the Home toolbar and dashboard show) instead of Home's own zeros.
 _HOME_GATED_ACTIONS = frozenset({
     "steps", "step_detail", "checkpoints", "rollback", "notify", "mode",
-    "queue", "queue_clear", "rename",
+    "queue", "queue_clear", "queue_drop", "queue_edit", "rename",
 })
 
 _HOME_GATE_NOTE = "open a session tab first — Ctrl+T or type a task"
@@ -437,6 +437,116 @@ def _resolve_agent_factory(agent_factory, bundle: dict):
     return lambda c, tp, ws, m: AgentSession(c, tp, ws, m, intel=bundle["intel"], shadow=bundle["shadow"])
 
 
+async def restore_tabs(workspace: str, slots, make_slot, *, sessions_fn=None,
+                       note=None, spawn_poller=None, limit: int = 0) -> int:
+    """Reopen the tabs remembered from the last run (0.3.37).
+
+    Closing the terminal used to be silently destructive: three tabs of live
+    work became one empty tab, and the still-Running Temporal workflows behind
+    them were reachable only by remembering what you had been doing. Now the
+    layout is remembered (`tab_store`), reconciled against what Temporal
+    actually still has Running (`active_sessions.plan_tab_restore`) and rebuilt
+    through the SAME `_make_session_slot` factory `/new` uses -- so a restored
+    tab is a completely ordinary tab, not a special second kind.
+
+    The FIRST session tab already exists when this runs (the boot builds it),
+    so the first remembered record is skipped: it is that tab. Each further
+    record becomes a real tab, labelled as it was, and told honestly whether it
+    re-attached to a live run or restored state only.
+
+    Best-effort by construction: a missing layout file, a gateway that cannot
+    list sessions, or a single tab that fails to build all degrade to "fewer
+    tabs restored", never to a failed boot. Returns how many tabs it opened.
+    """
+    from webbee.active_sessions import plan_tab_restore
+    from webbee.tab_store import load_tabs
+    opened = 0
+    try:
+        saved = load_tabs(workspace)
+    except Exception:
+        return 0
+    if len(saved) <= 1:
+        return 0            # nothing beyond the tab the boot already made
+    try:
+        sessions = await sessions_fn() if sessions_fn is not None else []
+    except Exception:
+        sessions = []       # no listing -> every tab restores state-only
+    plan = plan_tab_restore(saved, sessions)
+    live_n = 0
+    for rec in plan[1:]:
+        if limit and opened >= limit:
+            break
+        try:
+            slot = await make_slot(rec)
+        except Exception:
+            continue        # one bad tab must not cost the whole layout
+        if slot is None:
+            continue
+        label = str(rec.get("label") or "")
+        if label:
+            slot.label = label
+            slot.label_pinned = True
+        draft = str(rec.get("draft") or "")
+        if draft:
+            slot.draft = draft
+            slot.draft_cursor = len(draft)
+        slots.add(slot)
+        if spawn_poller is not None:
+            try:
+                spawn_poller(slot)
+            except Exception:
+                pass
+        opened += 1
+        if rec.get("attach"):
+            live_n += 1
+    if note is not None and opened:
+        try:
+            if live_n:
+                note(f"restored {opened} tab(s) — {live_n} still running server-side")
+            else:
+                note(f"restored {opened} tab(s) — their earlier runs have finished")
+        except Exception:
+            pass
+    return opened
+
+
+def snapshot_tabs(slots) -> list:
+    """Build the persistable tab layout from the LIVE slots (0.3.37).
+
+    SESSION tabs only -- Home is a fixture the dock always builds itself, so
+    persisting it would duplicate it on restore. The re-attach handle is the
+    agent's own `session_id` (the gateway id it streamed under); a tab that
+    never ran anything has none and restores as state-only. Reads defensively
+    (getattr with defaults) so a half-built slot during shutdown can never
+    turn saving the layout into a crash on exit.
+    """
+    from webbee.tab_store import tab_record
+    out = []
+    for slot in list(getattr(slots, "slots", []) or []):
+        if getattr(slot, "kind", "") == "home":
+            continue
+        agent = getattr(slot, "agent", None)
+        out.append(tab_record(
+            session_id=str(getattr(agent, "session_id", "") or ""),
+            label=str(getattr(slot, "label", "") or ""),
+            mode=str(getattr(slot, "mode", "default") or "default"),
+            workspace=str(getattr(slot, "workspace", "") or ""),
+            draft=str(getattr(slot, "draft", "") or ""),
+        ))
+    return out
+
+
+def _save_tab_layout(workspace: str, slots) -> None:
+    """Persist the tab layout, best-effort (0.3.37). Called on the way out of
+    the dock: losing the memory is a far smaller problem than failing to exit
+    cleanly, so EVERY error is swallowed -- same posture as mode_store."""
+    try:
+        from webbee.tab_store import save_tabs
+        save_tabs(workspace, snapshot_tabs(slots))
+    except Exception:
+        pass
+
+
 async def _note_reattach(cfg, token_provider, workspace, sink) -> None:
     """Boot reattach notice (T6.3, coding-remote flow perfection): best-
     effort, entirely swallowed on any failure -- same division of labor as
@@ -461,6 +571,44 @@ async def _note_reattach(cfg, token_provider, workspace, sink) -> None:
         pass
 
 
+async def _live_session_watch(cfg, token_provider, workspace, live: dict,
+                              invalidate=None, interval: float = 30.0,
+                              sessions_fn=None, sleep=None) -> None:
+    """Keep the toolbar's PERSISTENT live-session indicator honest (0.3.37).
+
+    The boot note fires once and scrolls away; this refreshes the indicator on
+    a slow cadence (default 30s -- it answers "is a workflow running", which
+    does not need per-second polling) so an accidental exit + reopen, or a
+    session that ends while you watch, is always reflected.
+
+    Writes ONLY into `live["text"]`, which `tui`'s toolbar reads every redraw:
+    no new UI ownership, no second source of truth. Fail-soft like every other
+    background poller here -- ANY error just leaves the previous value and
+    tries again next tick, and a gateway without the route means the indicator
+    stays empty (today's behaviour). `sessions_fn`/`sleep` are test seams.
+    """
+    from webbee.active_sessions import fetch_active_sessions, session_indicator
+    from webbee.repo import compute_repo_key, find_repo_root
+    _sleep = sleep or asyncio.sleep
+    fetch = sessions_fn or (lambda: fetch_active_sessions(cfg, token_provider))
+    try:
+        repo_key = await asyncio.to_thread(
+            lambda: compute_repo_key(find_repo_root(workspace)))
+    except Exception:
+        repo_key = ""
+    while True:
+        try:
+            sessions = await fetch()
+            text = session_indicator(sessions, repo_key)
+            if text != live.get("text"):
+                live["text"] = text
+                if invalidate is not None:
+                    invalidate()
+        except Exception:
+            pass
+        await _sleep(interval)
+
+
 async def _finish_slot(cfg, token_provider, workspace, mode, *, resources: WorkspaceResources,
                        agent_factory, intel_factory, shadow_factory, pane, sink, first: bool,
                        account, slot_id: str = "", label: "str | None" = None) -> "tuple[SessionSlot, int]":
@@ -1080,6 +1228,33 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                 # count follows on the sink's redraw below. (Home never
                 # reaches here -- "queue_clear" is in _HOME_GATED_ACTIONS.)
                 slot.pending.clear()
+            if res.action in ("queue_drop", "queue_edit"):
+                # 0.3.37 keyboard queue management. dispatch already validated
+                # the number against the SAME snapshot, but re-check here: the
+                # running turn can drain an item between the command and this
+                # line, and a stale index must never delete the wrong message.
+                idx = int(res.arg) - 1
+                if not (0 <= idx < len(slot.pending)):
+                    _say(slot, "that queued item just ran — nothing removed.")
+                    return "continue"
+                if res.action == "queue_drop":
+                    from webbee.queue_panel import drop_item as _drop_item
+                    item = _drop_item(slot.pending, idx)
+                    _say(slot, f"removed from queue: {item}")
+                else:
+                    # edit = move it OUT of the queue and INTO the input, so it
+                    # can never both sit in the queue AND still fire (the exact
+                    # bug ↑ had). Reuses the dock's own `_pull_at` -- the SAME
+                    # code the panel's click-to-edit runs -- so the live buffer
+                    # is filled correctly and `pulled` carries the steer_iid
+                    # for dedup. No dock (headless/tests) = honest no-op note.
+                    pull_fn = ui_hooks.get("pull_queued")
+                    if pull_fn is None:
+                        _say(slot, "editing a queued item needs the interactive dock.")
+                        return "continue"
+                    pull_fn(idx)
+                    _say(slot, "queued item moved into the input — edit it and press Enter.")
+                return "continue"
             if res.action == "clear":
                 # FIX4: works fully on Home too -- clears Home's OWN pane
                 # (there are no session counters to reset there, so only the
@@ -1261,6 +1436,19 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         if agent is not None:
             await agent.stop()
 
+    def _invalidate_dock() -> None:
+        """Ask the dock to redraw (0.3.37 live-session indicator). Fail-soft:
+        before the Application exists -- or in the headless fallback loop that
+        has no dock at all -- there is simply nothing to invalidate, and a
+        background poller must never die over a missing UI."""
+        try:
+            from prompt_toolkit.application.current import get_app_or_none
+            app = get_app_or_none()
+            if app is not None:
+                app.invalidate()
+        except Exception:
+            pass
+
     def _cancel_background() -> None:
         # Task 7: the actual walk moved to the module-level, directly-tested
         # `_cancel_all_background` (every slot's bg_tasks, .done()-guarded --
@@ -1464,6 +1652,36 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                 # is very likely already done (or well under way) by the
                 # time anyone actually switches to it.
                 home_slot.bg_tasks.append(asyncio.ensure_future(home.fill_home(home_slot, **home_fill_kwargs)))
+                # 0.3.37: keep the toolbar's live-session indicator fresh. Parked
+                # in Home's bg_tasks so the EXISTING teardown
+                # (_cancel_all_background) cancels it -- no new lifecycle to get
+                # wrong, and Home outlives every session tab.
+                # 0.3.37: reopen the tabs remembered from the last run, through
+                # the SAME factory /new uses. Awaited (not fire-and-forget) so
+                # the tab bar is already complete on the first frame instead of
+                # visibly popping in; every failure mode degrades to fewer tabs.
+                try:
+                    await restore_tabs(
+                        workspace, slots,
+                        lambda rec: _make_session_slot(
+                            cfg, token_provider,
+                            str(rec.get("workspace") or workspace),
+                            str(rec.get("mode") or mode), resources=resources,
+                            shared_client=shared_client, agent_factory=agent_factory,
+                            intel_factory=intel_factory, shadow_factory=shadow_factory,
+                            first=False, account=account),
+                        sessions_fn=lambda: __import__(
+                            "webbee.active_sessions", fromlist=["x"]
+                        ).fetch_active_sessions(cfg, token_provider),
+                        note=session_slot.sink.note if session_slot.sink else None,
+                        spawn_poller=_spawn_slot_poller)
+                except Exception:
+                    pass
+
+                _live_state: dict = {"text": ""}
+                home_slot.bg_tasks.append(asyncio.ensure_future(
+                    _live_session_watch(cfg, token_provider, workspace, _live_state,
+                                        invalidate=_invalidate_dock)))
 
                 async def _on_line(text: str, slot: SessionSlot) -> None:
                     if await _handle(text, slot) == "exit":
@@ -1519,8 +1737,15 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                         on_switch=lambda idx: _schedule_home_refill(slots, idx, home_fill_kwargs),
                         on_new=lambda: _open_new_tab(),
                         on_paste=_on_paste,
+                        live=_live_state,
                     )
                 finally:
+                    # 0.3.37: remember the tab layout BEFORE teardown, while the
+                    # slots (and their agents' session ids) are still intact.
+                    # In `finally` so an accidental exit, Ctrl-D and a crash all
+                    # remember equally -- the whole point is that closing the
+                    # terminal stops being destructive.
+                    _save_tab_layout(workspace, slots)
                     _cancel_background()
                     # Part C: release the per-repo instance lock (if this
                     # process actually acquired one -- None on a secondary
@@ -1593,6 +1818,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
             if await _handle(line, slots.active()) == "exit":
                 return
     finally:
+        _save_tab_layout(workspace, slots)   # 0.3.37, see the dock path above
         _cancel_background()
         if shared_client is not None:
             try:

webbee-0.3.37/src/webbee/tab_store.py

@@ -0,0 +1,123 @@
+"""Tab persistence per-repo (0.3.37): remembers WHICH tabs were open so
+closing the terminal is no longer destructive -- reopen it and your 3 tabs
+come back, each one re-attaching to its own still-Running Temporal workflow
+when there is one, or restoring just its label/mode/draft when there is not.
+
+Deliberately modelled on `mode_store` (same house pattern, same failure
+posture) with one difference: a tab is a RECORD, not a single string, so the
+file is JSONL -- one JSON object per line, newest write replaces the file.
+JSONL (not one big JSON doc) so a single corrupt line costs ONE tab instead
+of the whole layout.
+
+Fail-soft in BOTH directions, by design:
+  * `load_tabs` -- missing file, unreadable dir, corrupt/garbage lines all
+    degrade to [] (or skip just the bad line). A bad cache is exactly as safe
+    as no cache: you get today's behaviour, a single fresh tab.
+  * `save_tabs` -- a write failure (read-only home, disk full) is silently
+    dropped. Losing the memory is far smaller than crashing the terminal over
+    a nice-to-have.
+
+WHAT IS PERSISTED, and what deliberately is NOT:
+  * persisted: `session_id` (the re-attach handle -- the whole point),
+    `label`, `mode`, `workspace`, `draft`.
+  * NEVER persisted: the transcript (it lives server-side and replays on
+    re-attach -- duplicating it here would risk showing a stale copy), and
+    `autopilot` as a mode. Autopilot auto-approves every tool call, so it is
+    downgraded to 'default' on write for EXACTLY the reason mode_store
+    downgrades it: resuming it silently from a stale file is unsafe.
+"""
+from __future__ import annotations
+
+import json
+import os
+
+from webbee.repo import compute_repo_key, find_repo_root
+
+_CACHE_DIR = os.path.expanduser("~/.cache/webbee")   # test seam: monkeypatch this name
+
+MAX_TABS = 12   # a sane ceiling: a corrupt/huge file can never spawn tabs forever
+
+_KEY_CACHE: dict[str, str] = {}
+
+
+def _repo_key_for(workspace: str) -> str:
+    """Memoised exactly like mode_store's twin: `compute_repo_key` shells out
+    to git, and this is reached from UI paths where a stall would be felt."""
+    key = _KEY_CACHE.get(workspace)
+    if key is None:
+        key = compute_repo_key(find_repo_root(workspace))
+        _KEY_CACHE[workspace] = key
+    return key
+
+
+def _path_for(workspace: str) -> str:
+    return os.path.join(_CACHE_DIR, f"tabs-{_repo_key_for(workspace)}.jsonl")
+
+
+def tab_record(session_id: str = "", label: str = "", mode: str = "default",
+               workspace: str = "", draft: str = "") -> dict:
+    """PURE. Build ONE normalised tab record. Central so the writer and the
+    tests agree on the shape, and so the autopilot downgrade can never be
+    forgotten at a call site."""
+    return {
+        "session_id": str(session_id or ""),
+        "label": str(label or ""),
+        "mode": "default" if str(mode or "") == "autopilot" else (str(mode or "") or "default"),
+        "workspace": str(workspace or ""),
+        "draft": str(draft or ""),
+    }
+
+
+def load_tabs(workspace: str) -> list:
+    """The remembered tabs for `workspace`'s repo, oldest-first, or [] on no
+    file / ANY error. Individual corrupt lines are SKIPPED, not fatal: one bad
+    line must never cost you the other two tabs. Capped at MAX_TABS."""
+    out: list = []
+    try:
+        with open(_path_for(workspace), "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    rec = json.loads(line)
+                except Exception:
+                    continue          # one unreadable tab, not a broken layout
+                if isinstance(rec, dict):
+                    out.append(tab_record(**{k: rec.get(k, "") for k in
+                                             ("session_id", "label", "mode",
+                                              "workspace", "draft")}))
+                if len(out) >= MAX_TABS:
+                    break
+    except Exception:
+        return []
+    return out
+
+
+def save_tabs(workspace: str, tabs: list) -> None:
+    """Remember `tabs` (a list of dicts/records, oldest-first) for this repo.
+    Written whole (replace, not append) so the file always mirrors the CURRENT
+    layout -- a closed tab genuinely disappears. Never raises."""
+    try:
+        os.makedirs(_CACHE_DIR, exist_ok=True)
+        lines = []
+        for t in list(tabs)[:MAX_TABS]:
+            if not isinstance(t, dict):
+                continue
+            lines.append(json.dumps(tab_record(**{k: t.get(k, "") for k in
+                                                  ("session_id", "label", "mode",
+                                                   "workspace", "draft")}),
+                                    ensure_ascii=False))
+        with open(_path_for(workspace), "w", encoding="utf-8") as f:
+            f.write("\n".join(lines) + ("\n" if lines else ""))
+    except Exception:
+        pass
+
+
+def clear_tabs(workspace: str) -> None:
+    """Forget this repo's remembered layout (a clean `/exit` of the LAST tab,
+    or a user who wants a fresh dock). Never raises."""
+    try:
+        os.remove(_path_for(workspace))
+    except Exception:
+        pass