@vibelord/lanes 1.3.0 → 1.5.0

package/payload/lanes/libexec/sidebar.py

@@ -7,7 +7,7 @@ Fully usable from the keyboard (touch/mouse is a bonus):
   ↑/↓ j/k move · Enter/→/Space open · J/K open next/previous lane · / filter · Esc clear · g/G · r reload
   2 / 3 open the lane under the cursor in the 2nd / 3rd viewport (wide view sessions) · x / × close (y, then Enter)
   u unregister a session added with a (z within 10 s undoes it; a declared lane says which file to edit)
-  d shows the cursor lane's docs link in the footer (plan W10 W7)
+  d shows the cursor lane's docs link in the footer (plan W10 W7) · i folds / unfolds the fleet block (W11)
   ? shows every key in the body until the next key · Tab / Shift-Tab open the next / previous lane that needs you
 The keyboard goes back to the lane after every action (cockpit v3 S3): the sidebar and the lane share one keyboard, so
 an action that ends — a close, a rename, a register, a cancel, Esc, r, closing the key sheet, a click that opened
@@ -52,6 +52,13 @@ one tail cell by priority: stale `?` > starving ⚠ > downgraded ↓ > mostly pa
 Docs (plan W10 W7): while the workspace's lanes have published documents the idle strip says ` ↑ uploads · ▤ docs N
 (U)`, one OSC 8 link to the docs page; the cursor row's name links to its lane's documents, and `d` shows that link in
 the footer. The counts and the origin come in status.json (statusd): no stat or fork of the sidebar's own.
+Fleet block (W11, spec 2026-10-11 §3): pinned above the upload strip, from status.json's `fleet` and `throttle` objects
+only — Throttle in one row, an availability bar per provider (Anthropic, OpenAI and, since W12, Moonshot's Kimi),
+the host and its top containers; a pane of 25 rows or more draws a rule and six rows, 18–24 three, fewer none, and the
+lane list scrolls in the rest. `i` folds it to one line in the owner's profile (`look.fleet_collapsed`); with
+LANES_FLEET_DASHBOARD_URL in site.conf the host row is one OSC 8 link to the dashboard. While its unfolded Throttle
+row draws the money and every part after it (the same facts), the strip row's economy line yields to it; a row that
+dropped `spill` or `429` to fit keeps the strip.
 Truthful under load: a lane statusd could not observe keeps its last glyph, dimmed, with a `?`; the footer line warns
 when the host is under pressure or statusd has fallen behind (age of $STATE/health, measured with our own clock).
 Never frozen by an action (cockpit v3 S9): a close, `P`'s write and a new shell run on one worker thread (Worker); the
@@ -301,6 +308,154 @@ def load_economy(doc):
                 lanes={k: v for k, v in lanes.items() if isinstance(v, dict)} if isinstance(lanes, dict) else {})
 
 
+# ----------------------------------------------------------------- the fleet block (W11, spec 2026-10-11 §3)
+# Pinned above the upload strip: Throttle in one line, an availability bar per provider, the host and its top
+# containers — from status.json's `fleet` and `throttle` objects ONLY (statusd publishes both, spec §2.1/§2.2), so the
+# block costs no stat, read or fork of the sidebar's own on a tick. A pane of FLEET_FULL rows or more draws a rule and
+# six rows (W12 added the Kimi row: FLEET_FULL 24 -> 25, so the body a full block leaves keeps its W11 floor), one of
+# FLEET_SHORT..FLEET_FULL − 1 rows three (Throttle, the worse provider, the host), a shorter one none; `i` folds it to
+# one line (`look.fleet_collapsed` in the owner's profile). The lane list scrolls in the rest.
+FLEET_SCHEMA = 1                # the `v` of both objects this reader understands (absent = 1; another is ignored)
+FLEET_FULL, FLEET_SHORT = 25, 18
+# Own-clock floors beneath the publishers' `stale` flags (DEF-1528's rule, as ECONOMY_STALE): statusd writes `fleet`
+# every 10 s (a 12 s cycle at its slowest) and the pulse `throttle.at` at least every 60 s, which statusd flags past
+# 60 s; a status.json that stopped changing (statusd frozen) still turns the block stale here.
+FLEET_STALE_S, PULSE_STALE_S = 60, 90
+BAR_CELLS = 10
+# The pulse's pools, in row order, and the row's word: the vendor (W12, spec 2026-10-15 §6: Kimi Code's pool is
+# `kimi`, its vendor Moonshot AI). No grok row until Throttle has an xAI pool (the 2026-10-14 xAI pool review's gates).
+PROVIDERS = (('claude', 'anthropic'), ('codex', 'openai'), ('kimi', 'moonshot'))
+# The pools whose overflow is money (fleet_money): Kimi has no paid overflow lane, so a kimi figure is never shown —
+# the pulse records it as nulls (throttle-pulse MONEY_POOLS), and this reader would not show one if it did not.
+MONEY_POOLS = ('claude', 'codex')
+LABEL_CELLS = 9                 # the label field of the Throttle and provider rows (`anthropic`), then one blank
+# `429 +N`: how much the pools' upstream_429_total grew over the last SURGE_S seconds of pulse samples this sidebar
+# saw — from the newest sample at or before that window's start; a counter that went down (a daemon restart) starts
+# again. At most SURGE_SAMPLES are kept (the pulse writes at most every 10 s: 31 in five minutes).
+SURGE_S, SURGE_SAMPLES = 300, 64
+CPU_ATTENTION, MEM_ATTENTION = 0.95, 0.90
+GIB = 1 << 30
+SEVERITY = {'tone-urgent': 2, 'tone-attention': 1}   # a row's worst part tones its lead mark; the fold's verdict
+BAR_MARKS = ('bar-usable', 'bar-cooling', 'bar-benched', 'bar-dead')
+# LANES_FLEET_DASHBOARD_URL, the operator's site.conf value (unset until an authenticated dashboard exists): the host
+# row is then ONE OSC 8 link to it. Read at start and with the 30 s version recheck (recheck_version), never on a tick:
+# the line as bin/lanes reads site.conf (SITE_LINE's characters, the last line wins), and only an https URL passes —
+# it rides inside an OSC string, and a terminal needs an absolute URL.
+SITE_CONF = os.path.join(os.path.expanduser('~'), '.config', 'lanes', 'site.conf')
+SITE_CONF_MAX = 64 * 1024
+DASHBOARD_LINE = re.compile(r'LANES_FLEET_DASHBOARD_URL=([A-Za-z0-9_.:@/-]*)')
+DASHBOARD_URL = re.compile(r'https://[A-Za-z0-9](?:[A-Za-z0-9.-]{0,251}[A-Za-z0-9])?(?::[0-9]{1,5})?(?:/[A-Za-z0-9_.:@/-]*)?\Z',
+                           re.ASCII)
+
+
+def fleet_doc(value):
+    """status.json's `fleet` / `throttle` object as the block reads it: a dict whose `v` is 1 (or absent), else {} —
+    an object of another version is ignored rather than half-read (load_economy's rule)."""
+    return value if isinstance(value, dict) and value.get('v', FLEET_SCHEMA) == FLEET_SCHEMA else {}
+
+
+def tally(value):
+    """A pool count: a non-negative int (a finite float is truncated), else 0."""
+    value = finite(value)
+    return max(0, int(value)) if value is not None else 0
+
+
+def half_up(numerator, denominator):
+    """numerator / denominator (both ≥ 0, denominator > 0) rounded half up, in integers — never Python's half-to-even
+    (2.5 cells down, 3.5 up) and never a float that lands a hair under .5 (7 × 10 / 14 must give 5, not 4)."""
+    return (2 * numerator + denominator) // (2 * denominator)
+
+
+def bar_segments(pool):
+    """(usable, cooling, benched, dead) accounts of a pulse pool, exclusive and summing to its `configured`; None
+    without a configured count. The pulse's buckets overlap (spec §2.1: `cooling` is its remainder, `benched` the
+    model-benched accounts, usable or not), so the bar takes them in order, each capped by what is left: usable;
+    cooling; benched WITHIN cooling — a benched account the pool still counts usable reads usable, one it does not
+    reads benched instead of cooling; dead the rest (exhausted, auth failed, disabled, billing- or organization-blocked
+    or unhealthy: configured − usable − cooling)."""
+    configured = finite(pool.get('configured')) if isinstance(pool, dict) else None
+    if configured is None:
+        return None
+    configured = max(0, int(configured))
+    usable = min(tally(pool.get('usable')), configured)
+    cooling = min(tally(pool.get('cooling')), configured - usable)
+    benched = min(tally(pool.get('benched')), cooling)
+    return usable, cooling - benched, benched, configured - usable - cooling
+
+
+def bar_cells(segments):
+    """Cells per segment (usable, cooling, benched, dead) of the BAR_CELLS-cell bar; they always sum to BAR_CELLS.
+    Usable is `usable × 10 / configured` rounded half up and held to 1..9 while some but not all accounts are usable:
+    the bar never shows none of a pool that serves, nor all of one that does not. The other three share what is left
+    by cumulative half-up rounding over the accounts that are not usable. Nothing configured is ten dead cells."""
+    usable, *rest = segments
+    configured = usable + sum(rest)
+    if not configured:
+        return (0, 0, 0, BAR_CELLS)
+    cells = half_up(usable * BAR_CELLS, configured)
+    if 0 < usable < configured:
+        cells = min(BAR_CELLS - 1, max(1, cells))
+    left, others = BAR_CELLS - cells, configured - usable
+    out, edge_before, seen = [cells], 0, 0
+    for value in rest:
+        seen += value
+        edge = half_up(seen * left, others) if others else 0
+        out.append(edge - edge_before)
+        edge_before = edge
+    return tuple(out)
+
+
+def compact_gib(value):
+    """Bytes as GiB in at most four cells: 0.4G, 8.4G, 14G, 123G (no trailing `.0`)."""
+    gib = max(0.0, float(value)) / GIB
+    return (f'{gib:.1f}' if gib < 9.95 else f'{gib:.0f}').removesuffix('.0') + 'G'
+
+
+def aged(doc, now, floor):
+    """Whether a `fleet` / `throttle` object is a frozen picture: its publisher says so (`stale: true`), or its own `at`
+    is more than `floor` seconds behind `now` (OUR clock, DEF-1528). False for {} (nothing known, nothing claimed) and
+    without a numeric `at`."""
+    if not doc:
+        return False
+    at = number(doc.get('at'))
+    return doc.get('stale') is True or (at is not None and now - at > floor)
+
+
+def finite(value):
+    """number(value) when it is also finite (a NaN or an infinity in published JSON is no fact), else None."""
+    value = number(value)
+    return value if value is not None and -INF < value < INF else None
+
+
+def whole(value):
+    """A finite value ≥ 0 rounded half up to an int (tenths first, so 37.25 is 37 and 2.5 is 3); held to 0..10⁹, so
+    no published figure can overflow a frame or a float."""
+    return half_up(round(min(max(value, 0.0), 1e9) * 10), 10)
+
+
+def percent(fraction):
+    """A finite 0–1 fraction as a whole percent (`53`), half up, never below 0."""
+    return whole(fraction * 100) if fraction < 1e7 else whole(1e9)
+
+
+def short_name(value, cells):
+    """A name from status.json as a row prints it: printable (control and format characters dropped — it is
+    published data, never an escape), at most `cells` cells; '' when it is no string."""
+    return clip(OSC_UNSAFE.sub('', value), cells)[0] if isinstance(value, str) else ''
+
+
+def site_dashboard(path=None):
+    """LANES_FLEET_DASHBOARD_URL from the server's site.conf (read, never executed; at most SITE_CONF_MAX bytes): ''
+    when the file or the line is absent, unreadable, or the value is not an https URL of DNS-name characters."""
+    try:
+        with open(path or SITE_CONF, 'rb') as handle:
+            text = handle.read(SITE_CONF_MAX).decode('utf-8', 'replace')
+    except OSError:
+        return ''
+    found = [match.group(1) for match in map(DASHBOARD_LINE.fullmatch, text.splitlines()) if match]
+    return found[-1] if found and DASHBOARD_URL.match(found[-1]) else ''
+
+
 # The six words statusd publishes (alignment contract A3) and the helper word for an `exec` lane. There is no
 # seventh: statusd's zmx observer used to publish `idle`, which no other surface knew (DEF-823). Values are
 # (unicode, ascii, tone) from the one token source — the tone is a role name from tokens.ROLES, never an SGR code:
@@ -424,6 +579,18 @@ def mtime(path):
         return 0
 
 
+def file_stamp(path):
+    """(st_ino, st_mtime_ns, st_size) of `path`, or 0 when it cannot be stat()ed. For a file replaced by rename
+    (users.update -> atomic_write: a new temp file, created while the old one still exists, then renamed over it) every
+    write has a new inode, so two writes inside one timestamp tick of the file system still differ — an mtime alone
+    reads them as one (DEF-1972)."""
+    try:
+        info = os.stat(path)
+    except OSError:
+        return 0
+    return info.st_ino, info.st_mtime_ns, info.st_size
+
+
 def cell_width(text):
     if text.isascii():    # every ASCII character is one cell here (none combines, none is wide): the common case
         return len(text)
@@ -489,7 +656,8 @@ BOX_ROWS = 1    # the upload strip (spec §4.6(d)); it was a four-row box
 # config.kdl's shared block; lane chords such as Ctrl-Alt-m are no sidebar keys and stay off). 18 lines below the
 # dynamic version row (cockpit v3 V2, LNS-84: `  lanes <current> · view <tree>`, key_sheet) — exactly the 19-row body
 # of a 24-row pane with the strip row; R5's `p h` / `H o` (LNS-78) took the two rows S10 left, and V2's row the line
-# `u z` now share. Plan W10 W7's `d` (the cursor lane's docs link) joins the strip's own keys, `+ U d`, for the same reason.
+# `u z` now share. Plan W10 W7's `d` (the cursor lane's docs link) joins the strip's own keys, `+ U d`, for the same reason,
+# and W11's `i` (fold the fleet block) the reload and the sheet, `r i ?`.
 # test_sidebar.DocumentedKeys holds the sheet, the table and handle() to the same keys.
 KEY_SHEET = (('↑ ↓ j k', 'Up Dn j k', 'move'), ('⏎ → Space', 'Enter Spc', 'open the cursor lane'),
              ('J K', 'J K', 'open next / prev lane'), ('Tab S-Tab', 'Tab S-Tab', 'next / prev needing you'),
@@ -498,7 +666,7 @@ KEY_SHEET = (('↑ ↓ j k', 'Up Dn j k', 'move'), ('⏎ → Space', 'Enter Spc'
              ('+ U d', '+ U d', 'shell / upload / docs'), ('a', 'a', 'add to a workspace'),
              ('x', 'x', 'close (y, then Enter)'), ('u z', 'u z', 'unregister / undo 10 s'),
              ('R', 'R', 'rename'), ('P', 'P', 'register a session'), ('p h', 'p h', 'pin / hide lane'),
-             ('H o', 'H o', 'hide tab / hidden lanes'), ('r ?', 'r ?', 'reload / this sheet'),
+             ('H o', 'H o', 'hide tab / hidden lanes'), ('r i ?', 'r i ?', 'reload / fleet / keys'),
              ('Ctrl-Alt-l', 'Ctrl-Alt-l', 'focus the sidebar'))
 PASTE_START, PASTE_END = '\033[200~', '\033[201~'
 # A paste typed into a footer field (Sidebar.pasted): a run of line breaks / tabs is one space, never an Enter.
@@ -687,6 +855,14 @@ class Sidebar:
     # document count (reload), the link of the footer message `d` set ('' = the message is no link; the message
     # setter clears it) and the link the footer row draws this frame (footer_text sets it).
     web_origin, docs_total, _message_link, footer_link = '', 0, '', ''
+    # The fleet block (W11; read-only defaults, every write assigns fresh values): status.json's `fleet` and `throttle`
+    # (take_fleet), `i`'s fold (the owner's profile look.fleet_collapsed; this process's own on a device nobody owns),
+    # the dashboard link (site.conf, fleet_url), the (pulse at, 429 total) samples `429 +N` is measured over, the
+    # block's place in the last frame (`block_top` its first 1-based row, 0 = not drawn; `block_rows` how many) and the
+    # stale verdicts poll_fleet last saw (fleet, throttle).
+    fleet_facts, throttle_facts, fleet_collapsed, fleet_url = {}, {}, False, ''
+    surge_samples, block_top, block_rows, fleet_frozen = (), 0, 0, (False, False)
+    block_says_money = False    # fleet_block: the unfolded Throttle row drew the money and every part after it
 
     def __init__(self, device, workspace, slot='main', viewports='1'):
         self.device, self.workspace, self.slot = device, workspace, slot
@@ -764,6 +940,7 @@ class Sidebar:
         self.current_version = (self.tree_version if self.current_path == str(L.REPO)
                                 else shown_version(self.current_path))
         self.version_at = time.monotonic()
+        self.fleet_url = site_dashboard()          # W11: LANES_FLEET_DASHBOARD_URL, again with every version recheck
         # A predecessor that swapped itself out left its cursor, scroll, seen marks and filter (cockpit v3 U5).
         self.swappable, self.restore_id = False, None
         self.restored = self.take_state()
@@ -815,6 +992,7 @@ class Sidebar:
             self.zmx = (status.get('zmx') or {}).get(self.workspace, [])
             origin = status.get('web_origin')
             self.web_origin = origin if isinstance(origin, str) and WEB_ORIGIN.match(origin) else ''
+            self.take_fleet(status if isinstance(status, dict) else {})   # W11: the fleet block's facts
             self.keep_moved_row()
         if stamp[0] != self.stamp[0] or stamp[1] != self.stamp[1] or force:
             self.fleet = self.fleet_counts()
@@ -880,6 +1058,9 @@ class Sidebar:
         if now - self.version_at < VERSION_RECHECK_S:
             return False
         self.version_at = now
+        url = site_dashboard()                     # W11: the dashboard link follows site.conf within 30 s
+        if url != self.fleet_url:
+            self.fleet_url, self.dirty = url, True
         if self.current_path == str(L.REPO):
             return False
         version = shown_version(self.current_path)
@@ -999,8 +1180,9 @@ class Sidebar:
             return None, None
 
     def profile_stamp(self):
-        """reload()'s seventh stamp field: the profile's mtime — 0, with no stat at all, on a device nobody owns."""
-        return mtime(self.profile_path) if self.profile_path else 0
+        """reload()'s seventh stamp field: the profile's (inode, mtime, size) (`file_stamp`: two writes in one mtime
+        tick are both seen, DEF-1972) — 0, with no stat at all, on a device nobody owns."""
+        return file_stamp(self.profile_path) if self.profile_path else 0
 
     def read_profile(self):
         """The person's profile as users.read normalizes it (None: no owner, no file yet, or a file this release does
@@ -1008,6 +1190,8 @@ class Sidebar:
         profile = users.read(self.login, os.path.dirname(self.profile_path)) if self.profile_path else None
         self.profile_look = dict(profile['look']) if profile else {}
         self.take_arrangement(profile)
+        if self.profile_path:   # W11 `i`: the owner's fold; a device nobody owns keeps its own
+            self.fleet_collapsed = users.look_flag(profile, 'fleet_collapsed')
         return profile
 
     def take_arrangement(self, profile):
@@ -1459,6 +1643,312 @@ class Sidebar:
         lead_painted = f'{tone["ink-dim"]}{lead}{tone["reset"]}' if stale else lead
         return lead_painted + sep_painted.join(painted), lead + sep_plain.join(plain)
 
+    # ---------------------------------------------------------- the fleet block (W11, spec 2026-10-11 §3)
+    def take_fleet(self, status):
+        """reload()'s status.json read: its `fleet` and `throttle` objects (fleet_doc) and, once per new pulse sample
+        (`throttle.at` moved), the pools' summed `upstream_429_total` for `429 +N` (surge). Fresh values only."""
+        self.fleet_facts = fleet_doc(status.get('fleet'))
+        self.throttle_facts = fleet_doc(status.get('throttle'))
+        at = finite(self.throttle_facts.get('at'))
+        pools = self.throttle_facts.get('pools')
+        totals = [finite(pool.get('upstream_429_total')) for pool in pools.values() if isinstance(pool, dict)] \
+            if isinstance(pools, dict) else []
+        totals = [total for total in totals if total is not None]
+        if at is None or not totals:
+            return
+        total, samples = sum(totals), self.surge_samples
+        if samples and at <= samples[-1][0]:
+            return                                   # the same pulse sample (statusd republished), or an older one
+        if samples and total < samples[-1][1]:
+            samples = ()                             # the counter went down: a restarted daemon counts again
+        samples += ((at, total),)
+        start = at - SURGE_S
+        keep = max((i for i, (when, _total) in enumerate(samples) if when <= start), default=0)
+        self.surge_samples = samples[keep:][-SURGE_SAMPLES:]
+
+    def surge(self):
+        """`429 +N`'s N: the summed upstream_429_total's growth from the newest sample at or before SURGE_S seconds
+        before the latest one (the oldest this sidebar has, while it has seen less than that) to the latest."""
+        samples = self.surge_samples
+        return samples[-1][1] - samples[0][1] if len(samples) > 1 else 0
+
+    def fleet_aged(self, now):
+        """(fleet stale, throttle stale): the publisher's flag, or the object's own `at` past FLEET_STALE_S /
+        PULSE_STALE_S by our clock (aged)."""
+        return aged(self.fleet_facts, now, FLEET_STALE_S), aged(self.throttle_facts, now, PULSE_STALE_S)
+
+    def poll_fleet(self):
+        """Repaint when either object crosses into (or out of) stale. Polled every tick like poll_economy(): a statusd
+        that stopped never changes status.json's mtime again, reload()'s only trigger. In-memory only: no I/O."""
+        frozen = self.fleet_aged(time.time())
+        if frozen != self.fleet_frozen:
+            self.fleet_frozen, self.dirty = frozen, True
+
+    def fleet_money(self):
+        """(text, role) of ONE pool's overflow money — `$8.5k/16k 53%` — or None (no token: every overflow figure is
+        null). The pools' daily budgets are separate, non-fungible money, so the figure is never a sum: it is the pool
+        nearest its cap — one at or over its alert level first, then the highest fraction spent, Anthropic on a tie (a
+        pool with spend but no budget ranks last and shows `$120` alone). The attention tone when that pool's fraction
+        reached its alert level (the ranking puts any such pool first)."""
+        overflow = self.throttle_facts.get('overflow')
+        overflow = overflow if isinstance(overflow, dict) else {}
+        known = []                                    # (alarm, fraction or -1, spend, budget) in MONEY_POOLS order
+        for key in MONEY_POOLS:
+            pool = overflow.get(key) if isinstance(overflow.get(key), dict) else {}
+            spent, cap = finite(pool.get('spend_today_usd')), finite(pool.get('budget_usd'))
+            if spent is None:
+                continue
+            fraction, alert = finite(pool.get('fraction')), finite(pool.get('alert_level_pct'))
+            if fraction is None and cap:
+                fraction = spent / cap
+            alarm = fraction is not None and alert is not None and fraction * 100 >= alert
+            known.append((alarm, fraction if fraction is not None and cap else -1.0, spent, cap))
+        if not known:
+            return None
+        alarm, fraction, spend, budget = max(known, key=lambda pool: pool[:2])   # max keeps the first on a tie
+        text = '$' + compact_usd(spend)
+        if budget and fraction >= 0:
+            text += f'/{compact_usd(budget)} {percent(fraction)}%'
+        return text, 'tone-attention' if alarm else 'ink-dim'
+
+    def throttle_shows_money(self):
+        """True when the block's Throttle row carries the overflow money (throttle_spec's tokened head): a pulse that
+        is not `up: false` and whose token gave fleet_money() a figure. An untokened or down pulse shows `up …` /
+        `down`, never the money — the strip row's economy line must not yield to it (spec 2026-10-11 §3)."""
+        return bool(self.throttle_facts) and self.throttle_facts.get('up') is not False \
+            and self.fleet_money() is not None
+
+    def throttle_spec(self, now):
+        """The Throttle row: (head after the lead mark, parts, worst role). Tokened: `$8.5k/16k 53% · 429 +4 · spill
+        76%`; else `up · spill 76% · 429 +4`; `down · <error>` in the urgent tone when the daemon did not answer; `no
+        pulse` before statusd has published one. Spill is the most-spilling pool's, shown above 0 %."""
+        facts = self.throttle_facts
+        if not facts:
+            return 'throttle', [[('no pulse', 'ink-dim')]], 'ink-dim'
+        if facts.get('up') is False:
+            parts = [[('down', 'tone-urgent')]]
+            error = short_name(facts.get('error'), 24)
+            if error:
+                parts.append([(error, 'ink-dim')])
+            return 'throttle', parts, 'tone-urgent'
+        pools = facts.get('pools') if isinstance(facts.get('pools'), dict) else {}
+        spills = [finite(pool.get('spill_fraction')) for pool in pools.values() if isinstance(pool, dict)]
+        spill = max((value for value in spills if value is not None), default=None)
+        spill = [[(f'spill {percent(spill)}%', 'ink-dim')]] if spill is not None and percent(spill) > 0 else []
+        surge = self.surge()
+        surge = [[(f'429 +{int(surge)}', 'ink-dim')]] if surge > 0 else []
+        money = self.fleet_money()
+        if money:
+            return 'throttle', [[money]] + surge + spill, money[1]
+        return 'throttle', [[('up' if facts.get('up') is True else '?', 'ink-dim')]] + spill + surge, 'ink-dim'
+
+    def provider_spec(self, key, word, now):
+        """A provider's row: (head, parts, worst). The availability bar — usable/configured over BAR_CELLS cells, usable
+        ▰ cooling ▱ benched ▪ dead · each in its tone (bar_segments, bar_cells) — and, after one blank, `12/19` (the
+        attention tone while none of a configured pool is usable; a pool with nothing configured is no alarm), then the
+        tokened pulse's worst `wk N%` / `5h N%` utilization and the soonest reset. `no data` without the pool."""
+        pools = self.throttle_facts.get('pools')
+        pool = pools.get(key) if isinstance(pools, dict) else None
+        segments = bar_segments(pool)
+        if segments is None:
+            return word, [[('no data', 'ink-dim')]], 'ink-dim'
+        marks = self.glyphs['marks']
+        bar = [(marks[name] * cells, MARKS[name][2]) for name, cells in zip(BAR_MARKS, bar_cells(segments)) if cells]
+        usable, configured = segments[0], sum(segments)
+        worst = 'tone-attention' if configured and not usable else 'ink-dim'
+        parts = [bar + [(' ', None), (f'{usable}/{configured}', worst)]]   # `▰▰▰▱▱ 12/19`: one part, one blank
+        for field, prefix in (('worst_7d', 'wk'), ('worst_5h', '5h')):
+            value = finite(pool.get(field))
+            if value is not None:
+                parts.append([(f'{prefix} {percent(value)}%', 'ink-dim')])
+        reset = finite(pool.get('soonest_reset'))
+        if reset is not None and reset > now:
+            parts.append([(f'reset {age3(reset - now).strip()}', 'ink-dim')])
+        return word, parts, worst
+
+    def worse_provider(self):
+        """(pool key, word) of the provider the three-row block shows, over every PROVIDERS pool: the one with no usable
+        account, else the lower usable share; Anthropic, then OpenAI, on a tie. A pool with nothing configured ranks
+        after every configured pool — it is no alarm (provider_spec), and a daemon without Kimi accounts reports its
+        kimi pool so (DEF-2002) — and a pool the pulse does not report ranks last."""
+        pools = self.throttle_facts.get('pools')
+        pools = pools if isinstance(pools, dict) else {}
+
+        def share(provider):
+            segments = bar_segments(pools.get(provider[0]))
+            if segments is None:
+                return 3.0
+            configured = sum(segments)
+            return segments[0] / configured if configured else 2.0
+        return min(PROVIDERS, key=share)
+
+    def host_spec(self):
+        """The host row: (head, parts, worst) — `productbox cpu 42% · mem 61% · load 37 · psi 3%`; cpu at
+        CPU_ATTENTION (one sample), memory at MEM_ATTENTION and any `memory.full` stall in the attention tone. psi is
+        the highest avg10 statusd publishes."""
+        facts = self.fleet_facts
+        name = short_name(facts.get('host.name'), 12) or 'host'
+        if not facts:
+            return name, [[('no data', 'ink-dim')]], 'ink-dim'
+        parts, worst = [], 'ink-dim'
+        pressure = facts.get('system.pressure') if isinstance(facts.get('system.pressure'), dict) else {}
+        stalls = [value for value in map(finite, pressure.values()) if value is not None]
+        full = finite(pressure.get('memory.full.avg10'))
+        load = finite(facts.get('system.cpu.load_average.1m'))
+        for text, value, alarm in (
+                ('cpu', finite(facts.get('system.cpu.utilization')), lambda v: v >= CPU_ATTENTION),
+                ('mem', finite(facts.get('system.memory.utilization')), lambda v: v >= MEM_ATTENTION)):
+            if value is not None:
+                role = 'tone-attention' if alarm(value) else 'ink-dim'
+                parts.append([(f'{text} {percent(value)}%', role)])
+                worst = max(worst, role, key=lambda r: SEVERITY.get(r, 0))
+        if load is not None:
+            parts.append([(f'load {whole(load)}', 'ink-dim')])
+        if stalls:
+            role = 'tone-attention' if full is not None and full > 0 else 'ink-dim'
+            parts.append([(f'psi {whole(max(stalls))}%', role)])
+            worst = max(worst, role, key=lambda r: SEVERITY.get(r, 0))
+        return name, parts, worst
+
+    def containers_spec(self):
+        """The containers row: (head, parts, worst) — `bw-tools 14G · worlds 8.4G · sakio 3.7G`, statusd's top three
+        by memory in its order."""
+        found = self.fleet_facts.get('containers')
+        parts = []
+        for container in found[:3] if isinstance(found, list) else ():
+            if not isinstance(container, dict):
+                continue
+            name = short_name(container.get('container.name'), 14)
+            used = finite(container.get('container.memory.usage.total'))
+            if name and used is not None:
+                parts.append([(f'{name} {compact_gib(used)}', 'ink-dim')])
+        return '', parts or [[('no containers', 'ink-dim')]], 'ink-dim'
+
+    def paint(self, segments):
+        """[(text, role or None)] painted: one SGR and one reset per run of equal roles (a 16-colour ink-dim may be SGR 2,
+        which only a reset ends), a None role written bare."""
+        tone, out, run, role_of_run = self.tone, [], [], None
+        for text, role in segments + [('', '\0')]:
+            if role != role_of_run and run:
+                joined = ''.join(run)
+                out.append(joined if role_of_run is None else f'{tone[role_of_run]}{joined}{tone["reset"]}')
+                run = []
+            role_of_run = role
+            run.append(text)
+        return ''.join(out)
+
+    def fleet_row(self, mark, spec, width, stale, link=''):
+        """One block row from a spec (head, parts, worst): ` <mark> <head> ` then the parts joined by the `sep` mark,
+        whole parts dropped from the end to fit `width` cells (economy_strip's rule). The lead mark takes the row's worst
+        tone — of every part, a dropped one included, so a 36-column row still says something needs a look. A Throttle
+        or provider head is a LABEL_CELLS field; the host's name is its own width. Stale: everything ink-dim. `link`:
+        the whole row but its first blank one OSC 8 hyperlink (bytes, no cell)."""
+        return self.fleet_layout(mark, spec, width, stale, link)[0]
+
+    def fleet_layout(self, mark, spec, width, stale, link=''):
+        """fleet_row's (painted row, whole): `whole` is True when every part of the spec fit — nothing was dropped
+        from the end. render() keeps the strip row's economy line unless the Throttle row is whole (spec 2026-10-11
+        §3: the strip yields only when the block shows the same facts)."""
+        head, parts, worst = spec
+        marks = self.glyphs['marks']
+        label = head.ljust(LABEL_CELLS) if mark in ('fleet-throttle', 'fleet-provider') else head
+        segments = [(marks[mark], 'ink-dim' if stale else worst if worst in SEVERITY else MARKS[mark][2]),
+                    (f' {label} ' if label else ' ', 'ink-dim')]
+        if stale and mark == 'fleet-throttle':
+            segments.append((f'{marks["stale"]} ', 'ink-dim'))
+        used, sep, first = 1 + sum(cell_width(text) for text, _role in segments), f' {marks["sep"]} ', True
+        drawn = 0
+        for part in parts:
+            cost = sum(cell_width(text) for text, _role in part) + (0 if first else cell_width(sep))
+            if used + cost > width:
+                break
+            segments += ([] if first else [(sep, 'ink-dim')]) + part
+            used, first, drawn = used + cost, False, drawn + 1
+        if stale:
+            segments = [(text, 'ink-dim') for text, _role in segments]
+        return ' ' + osc8(link, self.paint(segments)), drawn == len(parts)
+
+    def fleet_rule(self, cols):
+        """` ── fleet ───…` to cols − 1: the rule ink-faint, the word ink-dim (divider_line's look)."""
+        rule = self.glyphs['marks']['rule']
+        return ' ' + self.paint([(rule * 2 + ' ', 'ink-faint'), ('fleet', 'ink-dim'),
+                                 (' ' + rule * max(0, cols - 1 - 10), 'ink-faint')])
+
+    def fleet_folded(self, specs, width, stale):
+        """`i`'s one line: ` fleet ✓ · throttle 53% · cpu 42% · mem 61%` — the verdict is the worst tone of every row
+        (✗ urgent, ⚠ attention, ✓ done), the stale mark while either object is stale; parts dropped from the end."""
+        marks = self.glyphs['marks']
+        worst = max((spec[2] for spec in specs), key=lambda role: SEVERITY.get(role, 0))
+        verdicts = {'tone-urgent': ('fail', 'tone-urgent'), 'tone-attention': ('warning', 'tone-attention')}
+        verdict = ('stale', 'ink-dim') if stale else verdicts.get(worst, ('ok', 'tone-done'))
+        parts = []
+        if self.throttle_facts:                  # the Throttle row's first part: the money's percent, up, down, ?
+            text, role = specs[0][1][0][0]
+            if text.startswith('$') and text.endswith('%'):
+                text = text.rsplit(' ', 1)[1]
+            parts.append([(f'throttle {text}', role)])
+        parts += [part for part in specs[-1][1] if part[0][0][:4] in ('cpu ', 'mem ')]   # the host's cpu and mem
+        segments = [(' fleet ', 'ink-dim'), (marks[verdict[0]], verdict[1])]
+        used, sep = cell_width(' fleet ' + marks[verdict[0]]), f' {marks["sep"]} '
+        for part in parts:
+            cost = cell_width(sep) + sum(cell_width(text) for text, _role in part)
+            if used + cost > width:
+                break
+            segments += [(sep, 'ink-dim')] + part
+            used += cost
+        if stale:
+            segments = [(text, 'ink-dim') for text, _role in segments]
+        return self.paint(segments)
+
+    def fleet_block(self, cols, rows, now):
+        """The block's painted rows (render, render_mobile), [] when there is none: neither object published (a statusd
+        before W11), a pane under FLEET_SHORT rows, or the key sheet up (it takes the rows back until the next key, so
+        the whole sheet still fits a 24-row pane). Folded (`i`): one line. FLEET_FULL rows or more: the rule, Throttle,
+        Anthropic, OpenAI, Moonshot (Kimi), the host, its containers; fewer: Throttle, the worse provider, the host.
+        Each row at most cols − 1 cells (column 36 never written)."""
+        self.block_says_money = False
+        if self.showing_keys or rows < FLEET_SHORT or not (self.fleet_facts or self.throttle_facts):
+            return []
+        stale, width = any(self.fleet_aged(now)), max(1, cols - 1)
+        throttle, host = self.throttle_spec(now), self.host_spec()
+        link = self.fleet_url
+        if self.fleet_collapsed:
+            return [self.fleet_folded([throttle] + [self.provider_spec(k, w, now) for k, w in PROVIDERS] + [host],
+                                      width, stale)]
+        # the strip row's economy line yields only to a Throttle row that drew the money AND every part after it (429,
+        # spill): a 36-column row that dropped `spill 76%` does not show the strip's facts, so the strip keeps them
+        throttle_row, whole = self.fleet_layout('fleet-throttle', throttle, width, stale)
+        self.block_says_money = whole and self.throttle_shows_money()
+        if rows < FLEET_FULL:
+            key, word = self.worse_provider()
+            return [throttle_row,
+                    self.fleet_row('fleet-provider', self.provider_spec(key, word, now), width, stale),
+                    self.fleet_row('fleet-host', host, width, stale, link)]
+        return [self.fleet_rule(cols), throttle_row] + [
+            self.fleet_row('fleet-provider', self.provider_spec(key, word, now), width, stale) for key, word in PROVIDERS
+        ] + [self.fleet_row('fleet-host', host, width, stale, link),
+             self.fleet_row('fleet-host', self.containers_spec(), width, stale)]
+
+    def toggle_fleet(self):
+        """`i`: fold the fleet block to its one line, or unfold it. On a device with an owner the fold is theirs
+        (users.set_look_flag: `look.fleet_collapsed`, through the profile's lock for at most PROFILE_LOCK_S) and every
+        device of theirs follows on its next tick; a write the lock refused changes nothing and says so, keeping the
+        keyboard. On a device nobody owns it is this sidebar's own. Then the keyboard goes back to the lane, as `o`."""
+        self.begin_action()
+        self.dirty = True
+        folded, g = not self.fleet_collapsed, self.glyphs['marks']
+        if self.profile_path and not users.set_look_flag(self.login, self.device, 'fleet_collapsed', folded,
+                                                         directory=os.path.dirname(self.profile_path),
+                                                         timeout=PROFILE_LOCK_S):
+            self.message = f'profile busy or unreadable {g["sep"]} try again'
+            return
+        self.fleet_collapsed = folded
+        if not (self.fleet_facts or self.throttle_facts):
+            self.message = f'fleet {"folded" if folded else "unfolded"} {g["sep"]} no fleet facts yet'
+        else:
+            self.message = f'fleet {"folded" if folded else "unfolded"} {g["sep"]} i {"unfolds" if folded else "folds"}'
+        self.release_focus()
+
     def attention(self, entry):
         """The attention section key of a registry entry, or None (the remainder)."""
         return self.agent_rows([entry])[0][3]
@@ -1859,7 +2349,7 @@ class Sidebar:
     def begin_action(self):
         """An action begins (cockpit v3 S6): the last action's message goes, so the footer never shows what an EARLIER
         action said beside what this one does. Called first by every verb — open (⏎ Space → J K 2 3, Tab, a click on a
-        row), `x`/`×`, `R`, `P`, `a`/`+`, `/`, `U` (and a click on the strip), `+`, `r`, `?`, `u`, `z`, a sidebar-key
+        row), `x`/`×`, `R`, `P`, `a`/`+`, `/`, `U` (and a click on the strip), `+`, `r`, `?`, `u`, `z`, `i`, a sidebar-key
         chord. A cursor move, a typed letter, Esc, the wheel, a report begin nothing: a message outlives them for
         MESSAGE_S. An undo offer (`u`, cockpit v3 S7) is not a message: only `z`, the next `u` or UNDO_S end it."""
         self.message = ''
@@ -3163,14 +3653,21 @@ class Sidebar:
         entries = self.follow()      # the cursor re-resolved onto its lane, clamped (spec §4.5)
         self.expire_theme()          # no OSC 11 answer within the grace: dark it is (spec §2.4)
         now = time.time()
-        # Frame order (spec §4.6): header, body, upload strip (rows ≥ 14), strip row (rows ≥ 18, economy or fleet
-        # attention to show), rule, footer. `box_top` is the upload strip's 1-based row; a click at or below it arms.
-        # The strip row is the fleet economy line when economy.json knows a fleet fact (Task 12), else fleet attention.
+        # Frame order (spec §4.6, W11 §4.7): header, body, the fleet block (rows ≥ 18, fleet_block), upload strip
+        # (rows ≥ 14), strip row (rows ≥ 18, economy or fleet attention to show), rule, footer. `box_top` is the upload
+        # strip's 1-based row; a click at or below it arms, a click on the block (`block_top`, `block_rows`) opens
+        # nothing. The strip row is the fleet economy line when economy.json knows a fleet fact (Task 12) and the block
+        # does not show the same facts (block_says_money: the unfolded Throttle row drew the money and every part after
+        # it; an untokened `up …`, a `down`, a row that dropped `spill` or `429` to fit, or the fold's bare percent do
+        # not, and the strip keeps its place), else fleet attention.
         self.box = rows >= 14 and not self.registration and not self.attach_only
-        economy_line = self.economy_strip(cols - 2, now)[0] if self.economy and rows >= 18 else ''
+        block = self.fleet_block(cols, rows, now)
+        economy_line = (self.economy_strip(cols - 2, now)[0] if self.economy and rows >= 18
+                        and not (block and self.block_says_money) else '')
         self.strip_row = rows >= 18 and (bool(economy_line) or bool(self.fleet))
-        body = max(1, rows - 3 - (BOX_ROWS if self.box else 0) - (1 if self.strip_row else 0))
-        self.box_top = 2 + body
+        body = max(1, rows - 3 - (BOX_ROWS if self.box else 0) - (1 if self.strip_row else 0) - len(block))
+        self.block_top, self.block_rows = (2 + body if block else 0), len(block)
+        self.box_top = 2 + body + len(block)
         rows, hidden_below = self.place_body(entries, body)
         self.body_map = rows + ([next(i for i in range(self.top, len(entries)) if i not in rows)] if hidden_below else [])
         self.more_row = 1 + body if hidden_below else 0   # 1-based screen row of `⋮ N more`, 0 = none
@@ -3250,6 +3747,7 @@ class Sidebar:
         # legend rung itself says so, in the accent (keys_here, cockpit v3 S4): ` ▌ keys go to sidebar · Esc → lane` —
         # no extra row, every rung above it unchanged.
         self.legend_shown = self.keys_here()
+        out.extend(f'{line}\033[K\r\n' for line in block)   # W11: pinned above the upload strip
         if self.box:
             out.append(self.strip_line(cols) + '\033[K\r\n')
         if self.strip_row:   # spec §4.6(c): the fleet economy line first; without one, fleet attention
@@ -3268,7 +3766,9 @@ class Sidebar:
         self.body_map = None   # the phone's rows are `top + row` (three terminal rows each); place_body is the desktop's
         self.box = False  # the Mac file-drop helper is not available in a phone browser
         self.entry_top, self.entry_height = 3, 3 if rows >= 8 else 1
-        body = max(1, (rows - 3) // self.entry_height)
+        # W11: the fleet block above the footer, as on the desktop (fleet_block: the same rows, the phone's width)
+        block = self.fleet_block(cols, rows, time.time())
+        body = max(1, (rows - 3 - len(block)) // self.entry_height)
         self.box_top = self.entry_top + body * self.entry_height
         self.top = max(0, min(self.top, self.cursor, len(entries) - body))   # bounded by the list, as in render()
         if self.cursor >= self.top + body:
@@ -3370,8 +3870,10 @@ class Sidebar:
                 detail += sep + 'status delayed'
             line('     ' + detail, tone['ink-dim'])
             line('     ' + task if task else '', tone['ink-dim'])
-        for _ in range(max(0, rows - (2 + body * self.entry_height + 1))):
+        for _ in range(max(0, rows - (2 + body * self.entry_height + 1 + len(block)))):
             line()
+        self.block_top, self.block_rows = (rows - len(block) if block else 0), len(block)
+        out.extend(f'{row}\033[K\r\n' for row in block)
         # The footer the desktop draws (footer_text, cockpit v3 S6): every prompt, the filter, the banner, the message;
         # only the picker's way out (`Tap Cancel`) and the idle hint (`Swipe to scroll · Tap to open`) are the phone's.
         out.append(self.footer_row(cols, entries) + '\033[K\033[J')
@@ -3502,6 +4004,9 @@ class Sidebar:
                     elif button == 0 and pressed and self.box and y >= self.box_top:
                         self.begin_action()
                         self.armed = True   # the click also gave this pane the focus: the next drop lands here
+                    elif (button == 0 and pressed and self.block_top
+                          and self.block_top <= y < self.block_top + self.block_rows):
+                        self.release_focus()   # W11: the fleet block opens nothing (its link is the terminal's)
                     elif button == 0 and pressed:
                         # A click that opens nothing — a section header, `⋮ N more`, the header row, an empty row —
                         # ends there: the keyboard goes back to the lane (cockpit v3 S3). `×` and `+` open a prompt,
@@ -3637,6 +4142,8 @@ class Sidebar:
                 self.request_hide_workspace()
             elif ch == 'o':
                 self.toggle_hidden()
+            elif ch == 'i':                   # W11: fold / unfold the fleet block (the owner's profile)
+                self.toggle_fleet()
             elif ch == 'd':                   # plan W10 W7: the cursor lane's docs link in the footer
                 self.show_docs_link(entries[min(self.cursor, len(entries) - 1)] if entries else None)
             elif ch == 'P' and entries:
@@ -3707,6 +4214,7 @@ class Sidebar:
                 self.poll_health()
                 self.poll_update()
                 self.poll_economy()
+                self.poll_fleet()           # W11: the fleet block's facts turning stale (no I/O)
                 # An upload in flight no longer forces a frame: poll_upload() dirties on progress and on the end.
                 if self.armed or (self.upload_note and time.time() - self.upload_note_at < 9):
                     self.dirty = True