webbee 0.3.35__tar.gz → 0.3.36__tar.gz

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

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.3.36
+
+Write on more than one line, and see what a session actually costs.
+
+- **New line inside your prompt.** Press **Alt+Enter** — or **Shift+Enter** on
+  a modern terminal, or **Ctrl+J** anywhere at all — to add a line without
+  sending. Enter still sends, exactly as before. Three chords because no single
+  one is available in every terminal: whichever your setup supports, one of
+  them works. Continuation lines are marked with a dim ┊ gutter, so a
+  half-written message never looks like something already sent. Pasting
+  multi-line text now keeps its line breaks instead of firing off each line.
+- **Spend is visible from every tab.** The status line at the bottom shows the
+  tokens and credits used in this session, in every tab. Home — which has no
+  session of its own — shows the running TOTAL across all your open tabs, both
+  in its status line and in the Wallet tile ("spent this session").
+- **Version and freshness, bottom right of Home.** Your Webbee version sits in
+  the bottom-right corner. It says "up to date" only when we actually managed
+  to check; when we could not reach the release server it shows the plain
+  version rather than a reassurance we cannot back up. A newer release is
+  called out in bee-yellow with the version to upgrade to.
+- **`/login` now works on Home.** Previously `/login`, `/logout`, `/sessions`,
+  `/logout-others` and `/cost` only worked in a session tab, which made no
+  sense — they act on your account, not on a session. They all work on Home
+  now, and Home shows a "Sign in to Imperal" button when you are signed out
+  instead of a blank space. `/cost` on Home reports the whole session's total.
+- `/help` lists the keyboard shortcuts, including the new-line chords.
+
 ## 0.3.35
 
 Reliability and speed of the terminal itself.

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

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

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

webbee-0.3.36/src/webbee/__init__.py

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

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

@@ -23,7 +23,12 @@ _HELP = """Commands:
   /sessions revoke <#>   revoke a session by its number
   /logout-others     sign out every session except this one
   /notify [tg|panel|both|off]   mirror this session to Telegram/panel & steer it back
-  /exit  (=/quit)    quit"""
+  /exit  (=/quit)    quit
+
+Keys:
+  Alt+↵ (or Shift+↵, or Ctrl+J)   new line in the prompt — Enter still sends
+  Shift+TAB          switch mode        Ctrl+T   new tab
+  Alt+№              switch to tab №    Ctrl+W   close tab"""
 
 
 @dataclass(frozen=True)

{webbee-0.3.35 → webbee-0.3.36}/src/webbee/home.py

@@ -181,13 +181,17 @@ async def fill_home(slot, *, cfg, token_provider, slots, account_fetcher,
         try:
             from pathlib import Path
 
-            from webbee.update import check_for_update, default_fetch
+            from webbee.update import check_update_status, default_fetch
             cache = Path(os.path.expanduser("~/.cache/webbee/update.json"))
-            data.update_notice = await asyncio.to_thread(
-                check_for_update, version, cache_path=cache, now=time.time(),
-                fetch=default_fetch) or ""
+            # 0.3.36: the (notice, checked) variant -- Home's version badge
+            # only claims "up to date" when the check actually resolved a
+            # latest version; offline shows the bare version, no false claim.
+            data.update_notice, data.update_checked = await asyncio.to_thread(
+                check_update_status, version, cache_path=cache, now=time.time(),
+                fetch=default_fetch)
         except Exception:
             data.update_notice = ""
+            data.update_checked = False
         _repaint()
     finally:
         slot._last_fill = time.monotonic()

{webbee-0.3.35 → webbee-0.3.36}/src/webbee/home_view.py

@@ -64,6 +64,9 @@ class HomeData:
     endpoint: str = ""
     version: str = ""
     update_notice: str = ""
+    # 0.3.36: did the freshness check actually COMPLETE? False = we could not
+    # reach PyPI (offline/timeout), so the footer must not claim "up to date".
+    update_checked: bool = False
     notice: str = ""             # transient one-line note (top-up/security URL)
 
 
@@ -90,6 +93,11 @@ class HomeActions:
     set_new_tab_mode: "Callable[[str], None]"
     top_up: "Callable[[], None]"
     open_security_docs: "Callable[[], None]"
+    # 0.3.36 -- signing in is now possible FROM Home (/login was un-gated), so
+    # the dashboard offers it as a real action instead of leaving a bare "…"
+    # where the account should be. Optional: None -> the item is not offered
+    # (every pre-0.3.36 caller/test keeps working unchanged).
+    sign_in: "Callable[[], None] | None" = None
 
 
 class HomeModel:
@@ -159,11 +167,64 @@ def _cycle(options, current: str, delta: int) -> str:
     return options[(i + delta) % len(options)]
 
 
+def version_badge(version: str, update_notice: str = "", checked: bool = True) -> "tuple[str, str]":
+    """(text, style_class) for Home's bottom-right version badge (0.3.36).
+
+    THREE honest states, never a fake reassurance:
+      * a newer release is known   -> "v0.3.35 → 0.3.36 available" (accent)
+      * checked, nothing newer     -> "v0.3.36 · up to date"       (dim)
+      * not checked (offline/first run, `checked=False`) -> "v0.3.36"
+        with NO freshness claim at all -- we do not say "up to date" when we
+        could not reach PyPI.
+
+    `update_notice` is `update.check_for_update`'s own sentence; the newer
+    version is parsed out of it for the compact badge and the full upgrade
+    command stays in the Settings tile, so the footer never wraps.
+    """
+    v = (version or "").strip()
+    vtxt = f"v{v}" if v else "v?"
+    notice = (update_notice or "").strip()
+    if notice:
+        latest = ""
+        for tok in notice.replace("—", " ").split():
+            if tok.startswith("v") and tok[1:2].isdigit():
+                latest = tok[1:]
+        return ((f"{vtxt} → {latest} available" if latest else f"{vtxt} · update available"),
+                "class:home.update")
+    if checked:
+        return (f"{vtxt} · up to date", "class:home.fresh")
+    return (vtxt, "class:home.dim")
+
+
 def two_column(width: int, threshold: int = 100) -> bool:
     """Wide terminal -> You + Wallet render side-by-side; narrow -> stacked."""
     return width >= threshold
 
 
+def session_totals(slots) -> "tuple[int, int]":
+    """(tokens, credits) summed across EVERY open session tab (0.3.36).
+
+    Home has no sink of its own, so "what has this session cost me?" can only
+    be answered by adding up the live per-tab counters. Pure + total: any slot
+    whose sink is missing or whose status() misbehaves contributes 0 rather
+    than breaking the toolbar, and Home's own sink-less slot is skipped
+    naturally (no sink -> no numbers). Reuses tab_rows so the numbers on Home
+    and in the toolbar can never disagree.
+    """
+    tokens = credits = 0
+    try:
+        rows = tab_rows(slots)
+    except Exception:
+        return (0, 0)
+    for r in rows:
+        try:
+            tokens += int(r.tokens or 0)
+            credits += int(r.credits or 0)
+        except (TypeError, ValueError):
+            pass
+    return (tokens, credits)
+
+
 def tab_rows(slots) -> "list[TabRow]":
     """PURE transform of the live SlotManager into Home's per-tab rows
     (session tabs only -- Home never lists itself). Per-tab spend comes from
@@ -197,6 +258,16 @@ def build_home_model(data: "HomeData", tabs: "list[TabRow]",
     enabled (they need no live session)."""
     items: "list[ActionItem]" = []
 
+    # Signed out? Then signing in is THE next step -- offer it first, before
+    # anything that would just fail without an account (0.3.36).
+    acct = getattr(data, "account", None)
+    signed_in = bool(getattr(acct, "signed_in", False)) if acct is not None else False
+    if not signed_in and actions.sign_in is not None:
+        items.append(ActionItem(
+            id="sign-in", label="→ Sign in to Imperal",
+            hint="sign in with your browser (same as typing /login)",
+            activate=actions.sign_in))
+
     items.append(ActionItem(
         id="new-session", label="+ New session",
         hint="open a new session tab (Ctrl+T)",
@@ -489,6 +560,13 @@ class HomeView:
             a = self.data.account
             L = [hdr("You")]
             if a is None or not getattr(a, "signed_in", False):
+                # Not signed in (or not fetched yet): say so plainly and offer
+                # the fix right here (0.3.36) instead of an opaque "…".
+                if "sign-in" in by_id:
+                    it = by_id["sign-in"]
+                    return L + [[("class:home.dim", "  not signed in")],
+                                [("class:home.dim", "  "), act(it, "→ Sign in to Imperal")],
+                                [("class:home.dim", "  or type /login")]]
                 return L + [[("class:home.dim", "  …")]]
             nick = getattr(a, "nickname", "") or ""
             L.append([("class:home.value", f"  @{nick}" if nick else "  (no nickname)")])
@@ -516,7 +594,16 @@ class HomeView:
                 L.append([("class:home.dim", "  credits —")])
             else:
                 cap = f" / {_fmt_tokens(w.cap)}" if w.cap else ""
-                L.append([("class:home.value", f"  {_fmt_tokens(w.balance)}{cap} credits")])
+                L.append([("class:home.value", f"  {_fmt_tokens(w.balance)}{cap} credits"),
+                          ("class:home.dim", "  left")])
+            # This session's TOTAL spend across every open tab (0.3.36) --
+            # Home is the summary page, so the figure belongs here and not
+            # only in each tab's own toolbar. Same `session_totals` the
+            # toolbar uses, so the two can never disagree.
+            stk, scr = session_totals(self.slots)
+            L.append([("class:home.dim", "  spent this session  "),
+                      ("class:home.spend", f"{_fmt_tokens(scr)} credits"),
+                      ("class:home.dim", f"  ({_fmt_tokens(stk)} tokens)")])
             it = by_id["top-up"]
             L.append([("class:home.dim", "  "), act(it, "Top up credits")])
             return L
@@ -594,9 +681,22 @@ class HomeView:
             L = [[("", "")], [("class:home.hint", f"  {hint}")]]
             if self.data.notice:
                 L.append([("class:home.dim", f"  {self.data.notice}")])
-            L.append([("class:home.dim",
-                       "  ↑↓ move · ↵ open · ←→ change "
-                       "· Ctrl+T new tab · Alt+N switch")])
+            # Key legend on the LEFT, version badge hard-right on the SAME row
+            # (0.3.36) -- the bottom-right corner of Home, as asked. When the
+            # window is too narrow to hold both, the badge drops to its own
+            # right-aligned row instead of being truncated.
+            keys = ("  ↑↓ move · ↵ open · ←→ change "
+                    "· Alt+↵ newline · Ctrl+T new tab · Alt+N switch")
+            btxt, bstyle = version_badge(self.data.version, self.data.update_notice,
+                                         checked=self.data.update_checked)
+            pad = width - len(keys) - len(btxt) - 2
+            if pad >= 1:
+                L.append([("class:home.dim", keys), ("", " " * pad),
+                          (bstyle, btxt), ("", "  ")])
+            else:
+                L.append([("class:home.dim", keys)])
+                rpad = max(0, width - len(btxt) - 2)
+                L.append([("", " " * rpad), (bstyle, btxt), ("", "  ")])
             return L
 
         # No center title — the tab bar's ◆ Home chip already names the tab,

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

@@ -126,38 +126,100 @@ def _gate_busy(sink, turn_ref: dict) -> bool:
     return bool(cp and cp())
 
 
-def _slot_ctx(slot: SessionSlot, *, logged_in: bool) -> CommandContext:
+def _slot_ctx(slot: SessionSlot, *, logged_in: bool, slots=None) -> CommandContext:
     """Pure extraction of the ACTIVE slot's fields into a CommandContext
     (W4a boot split, map §6): `state["mode"]`/`state["git_branch"]` are gone
     -- mode/git_branch/the type-ahead queue now live on the slot. Module-level
     so a test can drive slot-switching directly (build a SlotManager, flip
-    active_idx, assert the fields follow) without running the whole REPL."""
+    active_idx, assert the fields follow) without running the whole REPL.
+
+    0.3.36: `slots=` is optional and only matters for a SINK-LESS slot (Home).
+    Home has no counters of its own, so `/cost` and `/status` used to report a
+    flat 0 there; given the SlotManager they instead report the SESSION TOTAL
+    across every open tab -- the same pair the Home toolbar/dashboard show, so
+    the three can never disagree. Omitted (every existing caller/test) -> the
+    previous per-slot behaviour, byte for byte."""
     sink = slot.sink
+    tokens = getattr(sink, "session_tokens", 0)
+    credits = getattr(sink, "session_credits", 0)
+    if sink is None and slots is not None:
+        try:
+            from webbee.home_view import session_totals
+            tokens, credits = session_totals(slots)
+        except Exception:
+            tokens, credits = 0, 0
     return CommandContext(mode=slot.mode, workspace=slot.workspace, version=__version__,
                           surface="terminal", logged_in=logged_in,
-                          session_tokens=getattr(sink, "session_tokens", 0),
-                          session_credits=getattr(sink, "session_credits", 0),
+                          session_tokens=tokens,
+                          session_credits=credits,
                           git_branch=slot.git_branch, queued=tuple(slot.pending))
 
 
 # FIX4 (W4a final review — Home None-sink command crashes): actions that are
 # genuinely SESSION-scoped (an agent's steps, a workspace's checkpoints, this
-# session's spend/queue, account operations kept off the dashboard for
-# consistency) — dispatched while Home is active, they reply with ONE
+# session's queue/mode) — dispatched while Home is active, they reply with ONE
 # consistent "open a tab" note instead of either crashing on `_sink.note`
 # (sink is None) or quietly doing session-shaped work against Home's own
 # placeholder fields. `/clear`/`/tabs`/`/tab N`/`/new`/`/close`/`/help`/
 # `/exit` are deliberately NOT in this set — those are tab-bar/global actions
 # and must keep working on Home (map §FIX4).
+#
+# 0.3.36 — ACCOUNT-scoped commands were un-gated: `/login`, `/logout`,
+# `/sessions`, `/sessions revoke`, `/logout-others` and `/cost` act on the
+# ACCOUNT or DEVICE, not on any one session, so requiring a session tab first
+# was an artificial block (reported live: "/login only works in a new tab").
+# They are safe on Home because `_say` already tolerates a None sink and the
+# two handlers that used `_sink` directly now go through `_say`/`_sink_or_say`.
+# `/cost` on Home reports the SESSION TOTAL across every open tab (the same
+# number the Home toolbar and dashboard show) instead of Home's own zeros.
 _HOME_GATED_ACTIONS = frozenset({
     "steps", "step_detail", "checkpoints", "rollback", "notify", "mode",
-    "cost", "queue", "queue_clear", "login", "logout", "sessions",
-    "sessions_revoke", "logout_others", "rename",
+    "queue", "queue_clear", "rename",
 })
 
 _HOME_GATE_NOTE = "open a session tab first — Ctrl+T or type a task"
 
 
+class _SaySink:
+    """Minimal sink-shaped adapter over `_say` for the Home slot (0.3.36).
+
+    A few account-scoped handlers hand "the sink" to shared code that only
+    ever calls `.note(...)` on it -- `login_device_flow`'s fallback prompt is
+    the live example. On Home `slot.sink is None`, so passing it straight
+    through raised AttributeError (which is exactly why /login used to be
+    gated to session tabs). This shim routes those notes into Home's own
+    pane via `_say`, so the device code and URL are actually readable.
+    """
+
+    __slots__ = ("_slot",)
+
+    def __init__(self, slot: SessionSlot) -> None:
+        self._slot = slot
+
+    def note(self, msg: str) -> None:
+        _say(self._slot, str(msg))
+
+    def login_prompt(self, user_code: str, uri: str) -> None:
+        _say(self._slot, f"Open {uri} and enter code: {user_code}")
+
+
+def _format_sessions_plain(rows) -> str:
+    """Active sessions as plain text -- Home's stand-in for the sink's rich
+    table (0.3.36). Same fields, same order, no Rich table dependency; PII
+    stays as the server sent it (the sink's table shows the same columns)."""
+    rows = list(rows or [])
+    if not rows:
+        return "Active sessions: (none)"
+    out = ["Active sessions:"]
+    for i, s in enumerate(rows, 1):
+        label = str(s.get("label") or s.get("surface") or "?")
+        seen = str(s.get("last_seen_at") or "")[:16].replace("T", " ")
+        here = "  ← this device" if s.get("current") else ""
+        out.append(f"  {i}. {label}" + (f" · {seen}" if seen else "") + here)
+    out.append("Revoke one with /sessions revoke <#>")
+    return "\n".join(out)
+
+
 def _say(slot: SessionSlot, msg: str) -> None:
     """Reply into `slot`'s own surface regardless of whether it has a live
     sink -- a REAL session slot's `sink.note(msg)`, unchanged; a sink-less
@@ -833,7 +895,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         'continue'."""
         if not line.strip():
             return "continue"
-        res = dispatch(line, _slot_ctx(slot, logged_in=state["logged_in"]))
+        res = dispatch(line, _slot_ctx(slot, logged_in=state["logged_in"], slots=slots))
         if res.handled:
             _sink = slot.sink
             if res.exit:
@@ -850,7 +912,11 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                 return "continue"
             if res.action == "login":
                 # Device-code flow (RFC 8628) — rendering + polling in webbee.account.
-                email = await login_device_flow(cfg, auth, _sink)
+                # 0.3.36: on Home `_sink` is None and login_device_flow's
+                # prompt path calls `.note(...)` -- `_SaySink` puts the device
+                # code + URL into Home's own pane instead of crashing.
+                email = await login_device_flow(
+                    cfg, auth, _sink if _sink is not None else _SaySink(slot))
                 state["logged_in"] = True
                 _say(slot, f"Signed in as {email}.")
                 return "continue"
@@ -862,7 +928,10 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
             if res.action == "sessions":
                 rows = await sessions_client.list_sessions(cfg, token_provider)
                 state["sessions"] = rows
-                _sink.sessions_table(rows)
+                if _sink is not None:
+                    _sink.sessions_table(rows)
+                else:
+                    _say(slot, _format_sessions_plain(rows))   # Home: no rich table
                 return "continue"
             if res.action == "sessions_revoke":
                 rows = state.get("sessions") or []
@@ -1347,6 +1416,14 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                     home_view.data.notice = f"security & privacy: {url}"
                     home_view.notify()
 
+                def _home_sign_in() -> None:
+                    # 0.3.36: /login is no longer gated on Home, so the
+                    # dashboard's "Sign in" item just runs the SAME command
+                    # path (device-code flow, output via `_SaySink` into
+                    # Home's own pane) as typing /login here would.
+                    get_app().create_background_task(
+                        _handle("/login", slots.slots[0] if slots.slots else slots.active()))
+
                 # Home's command/output region — built FIRST via tui.OutputPane
                 # so it is the dock's first OutputPane (the spy's created[0] =
                 # Home) and `_say`/slash output on Home stays visible.
@@ -1361,6 +1438,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                     set_new_tab_mode=_set_new_tab_mode,
                     top_up=_home_top_up,
                     open_security_docs=_home_security_docs,
+                    sign_in=_home_sign_in,
                 ))
                 home_view.data.new_tab_mode = state["new_tab_mode"]
                 # Home slot at index 0; the first session slot (cwd

{webbee-0.3.35 → webbee-0.3.36}/src/webbee/tui.py

@@ -24,6 +24,7 @@ from webbee import sizing
 from webbee.output_pane import OutputPane  # noqa: F401 — re-exported (webbee.tui.OutputPane)
 from webbee.queue_panel import pull_item, queue_fragments, queue_height
 from webbee.render import _fmt_tokens
+from webbee.home_view import session_totals
 from webbee.slots import close_active, close_at, disarm_all, is_turn_alive
 from webbee.tabs import tab_fragments
 from webbee.todo_panel import todo_fragments, todo_height
@@ -90,6 +91,10 @@ _STYLE_DICT = {
     "home.disabled": "#5f5f5f",
     "home.focus": "bg:#e8a317 #1c1c1c bold",
     "home.hint": "#00afd7",
+    "home.update": "#e8a317 bold",       # a newer release exists — bee-yellow, pops
+    "home.fresh": "#5faf5f",             # verified up to date — calm green
+    "home.spend": "#ffffff bold",        # session spend total — reads as a figure
+    "input.cont": "#5f5f5f",             # multi-line prompt continuation gutter
 }
 
 
@@ -132,6 +137,48 @@ def configure_mouse_modes(output) -> None:
     output.disable_mouse_support = _disable
 
 
+def enable_csi_u_newline() -> bool:
+    """Teach prompt_toolkit's vt100 parser the CSI-u encodings of Shift+Enter.
+
+    prompt_toolkit 3.0.52 has NO ShiftEnter key: in a legacy terminal
+    Shift+Enter is byte-identical to Enter (CR), so it CANNOT be bound.
+    Modern terminals (kitty/foot/WezTerm/Ghostty, xterm with modifyOtherKeys,
+    iTerm2 with CSI-u) instead emit `ESC [13;<mod>u`. Registering those
+    sequences as (Escape, ControlM) makes them arrive as the SAME two-key
+    sequence Alt+Enter already produces, so ONE key binding -- ("escape",
+    "enter") -- serves both chords and nothing else in the app changes.
+
+    Registration is additive and idempotent: existing sequences are never
+    overwritten, so no other key can regress. Returns True when the table
+    now contains the codes (best effort -- never raises, an old/patched
+    prompt_toolkit just means Alt+Enter and Ctrl+J remain the way in).
+    """
+    try:
+        from prompt_toolkit.input.ansi_escape_sequences import ANSI_SEQUENCES
+        from prompt_toolkit.keys import Keys
+    except Exception:
+        return False
+    combo = (Keys.Escape, Keys.ControlM)
+    # 13 = Enter's unicode codepoint (CR) in the CSI-u scheme; modifier code
+    # 2 = Shift, 4 = Alt(Meta), 6 = Ctrl+Shift, 8 = Ctrl+Alt+Shift.
+    for mod in (2, 4, 6, 8):
+        seq = f"\x1b[13;{mod}u"
+        try:
+            ANSI_SEQUENCES.setdefault(seq, combo)
+        except Exception:
+            return False
+    try:
+        # The parser memoises prefix lookups built from ANSI_SEQUENCES; drop
+        # the cache so sequences registered after import are actually seen.
+        from prompt_toolkit.input import vt100_parser as _vp
+        for _obj in vars(_vp).values():
+            if hasattr(_obj, "cache_clear"):
+                _obj.cache_clear()
+    except Exception:
+        pass
+    return True
+
+
 def input_rows(text: str, cols: int, cap: int) -> int:
     """PURE row-wrap estimator behind `_input_height` (module-level so tests
     drive it directly with an injected size, mirroring repl._gate_busy).
@@ -158,7 +205,7 @@ def next_mode(mode: str) -> str:
 def build_toolbar(mode: str, tokens: int, credits: int, *, busy: bool = False,
                   current: str = "", elapsed: float = 0.0, tools: int = 0,
                   consent: bool = False, queued: int = 0,
-                  reconnecting: int = 0) -> list:
+                  reconnecting: int = 0, width: int = 0) -> list:
     """The status line under the pinned input box, as prompt_toolkit formatted
     text (per-segment styled). Four states: consent (awaiting a reply),
     reconnecting (the stream transport is down mid-turn — honest, not a fake
@@ -189,11 +236,23 @@ def build_toolbar(mode: str, tokens: int, credits: int, *, busy: bool = False,
         frags += q
         frags.append(("class:tb.dim", "   ·   Esc/Ctrl-C to stop"))
         return frags
-    return [("class:tb.dim", "  mode: "),
-            (f"class:tb.mode.{mode}", mode),
-            ("class:tb.dim", f"   ·   {_fmt_tokens(tokens)} tok · {_fmt_tokens(credits)} credits"),
-            *q,
-            ("class:tb.dim", "   ·   Shift + TAB: switch mode")]
+    frags = [("class:tb.dim", "  mode: "),
+             (f"class:tb.mode.{mode}", mode),
+             ("class:tb.dim", f"   ·   {_fmt_tokens(tokens)} tok · {_fmt_tokens(credits)} credits this session"),
+             *q]
+    # 0.3.36: the hints are DISCOVERABILITY, the spend figures are DATA -- so
+    # the hints are what gets dropped when the terminal is too narrow to hold
+    # everything, never the numbers (an 80-column window used to cut the line
+    # mid-word). `width=0` (unknown/headless) keeps the full line, which is
+    # also what every pre-0.3.36 caller and test sees.
+    used = sum(len(t) for _, t in frags)
+    full = "   ·   Alt+↵ newline · Shift + TAB: switch mode"
+    short = "   ·   Alt+↵ newline"
+    if not width or used + len(full) <= width:
+        frags.append(("class:tb.dim", full))
+    elif used + len(short) <= width:
+        frags.append(("class:tb.dim", short))
+    return frags
 
 
 def _width_watch(pane, app) -> None:
@@ -764,6 +823,11 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
         finally:
             _finish_natural_turn(slot, done)
 
+    # Shift+Enter (CSI-u) must be known to the parser BEFORE any key is read,
+    # so the ("escape","enter") binding below can match it. Best effort: a
+    # False return just means Alt+Enter / Ctrl+J remain the newline chords.
+    enable_csi_u_newline()
+
     kb = KeyBindings()
 
     def _busy_live() -> bool:
@@ -855,6 +919,27 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
                         ) in ("queued", "injected"):
             event.app.invalidate()             # panel + toolbar show the new depth
 
+    # ---- newline INSIDE the prompt (0.3.36) -------------------------------
+    # Enter still SENDS (muscle memory is sacred); these insert a literal
+    # newline so one prompt can be many lines. THREE chords, because no
+    # single one is portable across every terminal/OS/SSH client:
+    #   * Alt+Enter   -> ("escape", "enter"). Universal: every terminal sends
+    #     ESC as the Alt prefix. Same two-key shape as the Alt+N tab
+    #     switches already bound above.
+    #   * Shift+Enter -> ALSO ("escape", "enter"), because enable_csi_u_newline()
+    #     registers the CSI-u codes modern terminals emit for it. This is the
+    #     chord most people try first, so it works wherever the terminal can
+    #     express it -- and degrades to Alt+Enter/Ctrl+J where it cannot.
+    #   * Ctrl+J      -> a raw LF (0x0a) that EVERY terminal, tmux/screen and
+    #     ssh client can send, on every OS: the guaranteed fallback.
+    # Buffer(multiline=False) stores embedded "\n" fine and input_rows()
+    # already counts them, so the input box grows by itself.
+    def _insert_newline(event):
+        event.current_buffer.insert_text("\n")
+
+    kb.add("escape", "enter")(_insert_newline)   # Alt+Enter (+ Shift+Enter via CSI-u)
+    kb.add("c-j")(_insert_newline)               # raw LF -- universal fallback
+
     @kb.add("s-tab")
     def _cycle(event):
         slot = _a()
@@ -1039,11 +1124,20 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
                                       current=st["current"], elapsed=st["elapsed"],
                                       tools=st["tools"], consent=st["consent"],
                                       queued=len(slot.pending) + len(_sink_attr("remote_pending", [])),
-                                      reconnecting=st.get("reconnecting", 0))
+                                      reconnecting=st.get("reconnecting", 0),
+                                      width=sizing.get_size(get_app_or_none())[0])
             else:
-                # Home has no sink -- an idle toolbar of its own, no tokens/
-                # credits/mode to show (there's no session yet).
-                frags = [("class:tb.dim", "  ◆ home · type to start a session · Alt+№ switch")]
+                # Home has no sink of its OWN, but it is the dock's summary
+                # page: show the SESSION TOTAL across every open tab (0.3.36)
+                # so spend is visible from every tab, Home included -- the
+                # per-tab numbers live in each sink, Home adds them up.
+                tk, cr = session_totals(slots)
+                frags = [("class:tb.dim", "  ◆ home"),
+                         ("class:tb.dim", f"   ·   {_fmt_tokens(tk)} tok · {_fmt_tokens(cr)} credits this session")]
+                _w = sizing.get_size(get_app_or_none())[0]
+                _hint = "   ·   type a task to start · Alt+№ switch"
+                if not _w or sum(len(t) for _, t in frags) + len(_hint) <= _w:
+                    frags.append(("class:tb.dim", _hint))
         # W2 Task 8: the toolbar has no mouse handling of its own, so
         # `_forwarding(None, pane)` is wrapped onto every fragment purely for
         # drag-forwarding — a release that lands on the toolbar row while a
@@ -1158,9 +1252,19 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
                        always_hide_cursor=True, wrap_lines=False),
         filter=Condition(lambda: bool(_sink_attr("current_todos", []))))
 
+    def _line_prefix(line_no, wrap_count):
+        # 0.3.36: with multi-line prompts, line 2+ gets a dim continuation
+        # gutter so it reads as ONE message still being composed, never as
+        # something already sent. Line 1 keeps the coloured `❯ ` that
+        # BeforeInput draws (returning "" leaves it untouched). Aligned to
+        # the same 2 columns as `❯ `, so text never shifts as it wraps.
+        if line_no == 0 and not wrap_count:
+            return ""
+        return [("class:input.cont", "\u250a ")]
+
     input_win = Window(
         BufferControl(buffer=buf, input_processors=[BeforeInput(_prompt_fragments)]),
-        height=_input_height, wrap_lines=True)
+        height=_input_height, wrap_lines=True, get_line_prefix=_line_prefix)
     toolbar = Window(FormattedTextControl(_toolbar), height=1, always_hide_cursor=True)
 
     _hover_on = {"v": None}