@gavin-hu/my-pi-agent 0.21.0 → 0.22.0

package/extensions/board/view/team.ts

@@ -3,9 +3,20 @@
  *
  * Two panels and one strip. **Needs a decision** is the queue — one row per card,
  * carrying why it is there and the action that fixes it — and **Teammates** is the
- * people: the sessions this repository's bus knows, plus every owner a card names,
- * so a session holding nothing and a label that stopped answering are both visible.
- * Done is a quiet strip of ids that open their cards.
+ * people: the sessions this repository's bus knows, plus every owner a card names, so a
+ * session holding nothing and a label that stopped answering are both visible. Done is a
+ * quiet strip of ids that open their cards.
+ *
+ * Two of those lists only grow: an owner a card names stays one, and a finished card is
+ * finished for good. Both therefore fold — the owners the bus has no record of into one row
+ * that states what they finished, and the strip past its sixth id behind its own count — and
+ * the three slots are refilled only when what they print has moved, so a peer's write does
+ * not take the reader's scroll or their focus with it.
+ *
+ * Which owners are history, and the sentence that states them, are not decided here: the
+ * terminal's round prints the same fold, so both read `lib/board/round-text.ts`'s two bodies
+ * through {@link teamJs}. A second copy in this fragment is how the page and `/team` came to
+ * describe one board two ways.
  *
  * The roster is optional throughout: `view.teammates` is absent when `session-bus`
  * has no records here, and every state then reads `—` rather than claiming the
@@ -16,30 +27,90 @@
  * Same rule as the rest of the client: every value arrives as `textContent`.
  */
 
-export const BOARD_TEAM_JS = String.raw`(function () {
+/**
+ * The tab's fragment, with the fold's rule and its sentence spliced in.
+ *
+ * The source crosses as text, because a page's bundle has no import graph, and the two
+ * `__NAME__` placeholders are rules a served script must never carry — `pages.test` fails an
+ * unfilled one.
+ */
+export function teamJs(rules: { historyOwner: string; historyLine: string }): string {
+	return teamTemplate.replace("__HISTORY_OWNER__", rules.historyOwner).replace("__HISTORY_LINE__", rules.historyLine);
+}
+
+const teamTemplate = String.raw`(function () {
   "use strict";
   var board = window.bfBoard || (window.bfBoard = {});
   var el = board.el;
   var chip = board.chip;
   var ago = board.ago;
   var plural = board.plural;
+  var rankOf = board.rankOf;
+  var decisionTone = board.decisionTone;
+
+__HISTORY_OWNER__
+
+__HISTORY_LINE__
 
   /** The word a teammate's state is read as; never a colour alone. */
   var STATE_WORD = { live: "live", quiet: "quiet", gone: "gone", absent: "no record", unknown: "\u2014" };
 
   /**
-   * A panel: its heading row, then its body.
+   * A slot's heading row: the panel's name and the count a reader came for.
    *
-   * With a filter on, the count reads shown/total the way a lane head does, so a
-   * reader can tell "nothing here" from "nothing matches".
+   * With a filter on, the count reads shown/total the way a lane head does, so a reader can
+   * tell "nothing here" from "nothing matches".
    */
-  function panel(text, count, total) {
-    var node = el("section", N.teamGroup);
-    node.setAttribute("aria-label", text);
-    var caption = el("h2", N.teamCaption, text);
-    caption.appendChild(chip(total !== undefined && total !== count ? count + "/" + total : String(count)));
-    node.appendChild(caption);
-    return node;
+  function caption(slot, text, count, total) {
+    var filtered = total !== undefined && total !== count;
+    var head = el("h2", N.teamCaption, text);
+    head.appendChild(chip(filtered ? count + "/" + total : String(count)));
+    // The count is the reason the panel is read, but glued to its name a heading announces
+    // "Needs a decision 4" as one word. The label says the same fact in a sentence and the
+    // pill keeps the shape a reader scans.
+    head.setAttribute("aria-label", text + ", " + (filtered ? count + " of " + total : String(count)));
+    slot.setAttribute("aria-label", text);
+    slot.appendChild(head);
+  }
+
+  /**
+   * The tab's three slots, built once and then refilled in place.
+   *
+   * A lane has always been rebuilt only when its cards moved; the Team tab used to clear
+   * itself and start again on every frame, which threw away the scroll offset of a capped
+   * roster and put the reader's focus back on the document. A slot is a fixed element, and
+   * what a signature guards is its contents.
+   */
+  function slots() {
+    if (board.teamPanels !== undefined) return board.teamPanels;
+    var root = document.getElementById("board-team");
+    if (!root) return undefined;
+    root.textContent = "";
+    var grid = el("div", N.teamGrid);
+    var queue = el("section", N.teamGroup);
+    var people = el("section", N.teamGroup);
+    grid.appendChild(queue);
+    grid.appendChild(people);
+    root.appendChild(grid);
+    var strip = el("p", N.teamDone);
+    root.appendChild(strip);
+    board.teamPanels = { queue: queue, people: people, strip: strip };
+    return board.teamPanels;
+  }
+
+  /**
+   * Refill one slot, but only when what it draws has moved.
+   *
+   * The signature is the facts the slot prints — ids, revisions, states, counts — plus the
+   * filter and the slot's own folded state, so a frame that changed nothing here leaves the
+   * rows, the scroll offset, and whatever the reader has focused alone. The data-sig hook is
+   * the lanes' own, not a second one.
+   */
+  function fill(slot, sig, build) {
+    if (slot.getAttribute("data-sig") === sig) return;
+    slot.setAttribute("data-sig", sig);
+    slot.textContent = "";
+    build(slot);
   }
 
   /**
@@ -48,13 +119,11 @@ export const BOARD_TEAM_JS = String.raw`(function () {
    * The renderer filters this list, so it has to be the data: filtering the built
    * rows would test the element instead of the card.
    *
-   * The round's groups overlap on purpose — a doing card untouched for half an hour
+   * The round's groups overlap on purpose — an executing card untouched for half an hour
    * is both idle and unplanned — so a card can arrive twice. On the page one card is
    * one row, and the strongest reason is the one it keeps: a blocker outranks silence,
    * which outranks a missing plan, which outranks nobody holding it.
    */
-  var KIND_RANK = { blocked: 0, gone: 1, waiting: 2, idle: 3, unplanned: 4, unassigned: 5 };
-
   /** The labels of the sessions whose process is gone, in the roster's own spelling. */
   function goneLabels(view) {
     var roster = view.teammates;
@@ -78,19 +147,22 @@ export const BOARD_TEAM_JS = String.raw`(function () {
         if (seen === undefined) {
           byCard[card.id] = entry;
           entries.push(entry);
-        } else if (KIND_RANK[kind] < KIND_RANK[seen.kind]) {
+        } else if (rankOf(kind) < rankOf(seen.kind)) {
           seen.why = entry.why;
           seen.kind = kind;
         }
       }
     }
-    // A blocked card in this queue is a person's decision: the reason the move recorded
-    // comes first, and the last note is only the fallback for a block nobody explained.
-    add(round.blocked, function (card) {
-      if (card.blockedBy) return card.blockedBy;
-      var last = card.notes.length > 0 ? card.notes[card.notes.length - 1] : undefined;
-      return last ? last.text : "blocked";
-    }, "blocked");
+    // The card's own sentence, from the one rule: the page's faces and the transcript read
+    // the same body, so a block and a contract cannot be described two ways.
+    function why(card, fallback) {
+      var reason = board.reasonFor(card, ago);
+      return reason === undefined ? fallback : reason.text;
+    }
+    add(round.blocked, function (card) { return why(card, "blocked"); }, "blocked");
+    // A complete contract nobody has read is the lead's decision, and the one the flow
+    // stops on: the card cannot be executed until it is approved.
+    add(round.unapproved, function (card) { return why(card, "contract ready — needs approval"); }, "approval");
     // A dead owner is a fact, not an inference from silence: the card is anyone's now.
     var gone = goneLabels(view);
     add(
@@ -102,7 +174,7 @@ export const BOARD_TEAM_JS = String.raw`(function () {
     );
     add(round.idle, function (card) { return "no touch for " + ago(card.updatedAt); }, "idle");
     // The board card says the same words for the same fact: one voice for one state.
-    add(round.unplanned, function () { return "no plan recorded"; }, "unplanned");
+    add(round.unplanned, function (card) { return why(card, "no contract yet"); }, "unplanned");
     add(round.unassigned, function () { return "nobody holds it"; }, "unassigned");
     // An order outranks nobody holding it: the claim would be refused, so the queue says
     // what it waits for instead of offering a button the rules would turn down.
@@ -126,7 +198,11 @@ export const BOARD_TEAM_JS = String.raw`(function () {
   function decision(entry, view) {
     var card = entry.card;
     var node = el("article", N.teamDecision);
+    // What the row is, and how it wears: data-kind names it for a test and a hook, and
+    // data-tone is the colour its edge is drawn in, from the table the page's stylesheet
+    // and the terminal share.
     node.setAttribute("data-kind", entry.kind);
+    node.setAttribute("data-tone", decisionTone(entry.kind));
 
     var open = el("button", N.teamOpen);
     open.type = "button";
@@ -150,16 +226,20 @@ export const BOARD_TEAM_JS = String.raw`(function () {
     // rest, because this sentence is the lead's whole reason to look at the row.
     var why = el("p", N.teamWhy, entry.why);
     why.title = entry.why;
-    if (entry.kind === "blocked") why.className = N.teamWhy + " " + N.teamWhyBlocked;
     node.appendChild(why);
     return node;
   }
 
   /**
-   * Every teammate: the bus's sessions and the owners a card names, as one list.
+   * Every teammate: the bus's sessions and the owners a card names, split in two.
    *
-   * An owner with no live session is the interesting row — work is held by a label
-   * nothing answers to — so it stays, with "no record" where a heartbeat would be.
+   * The head is who is here to read: the bus's sessions, and any owner a card names that the
+   * bus has no record of **and** that holds no card — that second kind is the one the queue
+   * reports, and folding it would hide the row the tab exists for.
+   *
+   * The tail is history: an owner the bus has no record of, holding nothing. The interesting
+   * case is why the row stays at all, but the set grows with every label that ever claimed a
+   * card, so the page states it once and unfolds it on a click.
    */
   function teammates(view, roster) {
     var round = view.round;
@@ -202,7 +282,21 @@ export const BOARD_TEAM_JS = String.raw`(function () {
       return 4;
     }
     rows.sort(function (a, b) { return rank(a) - rank(b) || a.label.localeCompare(b.label); });
-    return rows;
+
+    var head = [];
+    var tail = [];
+    for (var r = 0; r < rows.length; r++) {
+      // The rule is the round text's own (isHistoryOwner), so the tab and /team cannot answer
+      // "which owners are only history" two ways. A null roster is a machine with no bus: the
+      // rule folds nobody there, because nobody can be called absent.
+      if (isHistoryOwner(rows[r].label, rows[r].cards.live.length, roster === null ? undefined : roster)) {
+        tail.push(rows[r]);
+      } else head.push(rows[r]);
+    }
+    // Unfolded, history is read by what it finished and then by name, so the list says which
+    // labels did the work rather than which sorts first.
+    tail.sort(function (a, b) { return b.cards.done.length - a.cards.done.length || a.label.localeCompare(b.label); });
+    return { head: head, tail: tail };
   }
 
   /** A text node carrying its stamp, so refreshAges rewrites it with every other age. */
@@ -254,10 +348,106 @@ export const BOARD_TEAM_JS = String.raw`(function () {
     return node;
   }
 
+  /**
+   * The history row: how many owners nothing answers to, and what they finished.
+   *
+   * One row instead of eighteen, because a label that ever claimed a card stays an owner for
+   * good: eighteen rows of "no record · no cards · 1 done" are one fact printed eighteen
+   * times. The row wears the same absence its rows do, so its dot is the hollow ring.
+   */
+  function tailRow(tail, folded) {
+    var finished = 0;
+    for (var i = 0; i < tail.length; i++) finished += tail[i].cards.done.length;
+    var row = el("li", N.teamMate);
+    row.setAttribute("data-state", "absent");
+    var button = el("button", N.teamTail);
+    button.type = "button";
+    button.setAttribute("data-fold", "team-roster");
+    button.setAttribute("aria-expanded", String(!folded));
+    var dot = el("span", N.teamDot);
+    dot.setAttribute("aria-hidden", "true");
+    button.appendChild(dot);
+    // The row counts in the rows' own words — "no record", "11 done" — so the summary is not
+    // a second way of saying what a teammate row says.
+    button.appendChild(document.createTextNode(historyLine(tail.length, finished)));
+    button.addEventListener("click", function () { board.toggleFold("team-roster"); });
+    row.appendChild(button);
+    return row;
+  }
+
+  /** Whether the history row starts folded: once, like the Done lane, and the reader decides after. */
+  function historyFolded(tail) {
+    if (tail.length < board.foldAt.roster) return false;
+    board.collapsed = board.collapsed || {};
+    if (board.collapsed["team-roster"] === undefined) board.collapsed["team-roster"] = true;
+    return board.collapsed["team-roster"] === true;
+  }
+
+  /**
+   * Whether the strip starts folded, and stays as the reader left it.
+   *
+   * The lane folds at six because a tray of finished cards is history the moment it reaches
+   * one more than a reader checks; the strip shows six ids and folds the seventh on, because
+   * it is one line and six is what fits before it becomes a wall of underlined numbers.
+   */
+  function doneFolded(count) {
+    if (count <= board.foldAt.done) return false;
+    board.collapsed = board.collapsed || {};
+    if (board.collapsed["team-done"] === undefined) board.collapsed["team-done"] = true;
+    return board.collapsed["team-done"] === true;
+  }
+
+  /** One finished id in the strip: a button, because it opens its card. */
+  function doneId(card) {
+    var id = el("button", N.teamId, "#" + card.id);
+    id.type = "button";
+    id.setAttribute("aria-haspopup", "dialog");
+    id.addEventListener("click", function () { board.openCard(card.id); });
+    return id;
+  }
+
+  /**
+   * What a slot prints, in one string — the facts its rows are drawn from, plus the filter and
+   * the slot's own fold. A signature that leaves a fact out is a row that goes stale, so each
+   * one is built from the same expressions the rows read.
+   */
+  function queueSig(decisions, total, query) {
+    var parts = [query, String(total)];
+    for (var i = 0; i < decisions.length; i++) {
+      var card = decisions[i].card;
+      parts.push(card.id + ":" + card.rev + ":" + decisions[i].kind + ":" + decisions[i].why);
+    }
+    return parts.join("|");
+  }
+
+  function peopleSig(head, tail, query, folded, noBus) {
+    function row(mate) {
+      var ids = [];
+      for (var i = 0; i < mate.cards.live.length; i++) ids.push(mate.cards.live[i].id + ":" + mate.cards.live[i].rev);
+      // No seen: the bus moves it every few seconds, and it is churn without a fact. A live row
+      // prints no age — only a quiet one does, and a quiet session that pings is live again on the
+      // next snapshot, which moves its state and refills the row anyway. Putting the stamp here
+      // rebuilt the roster on the first frame after every heartbeat, taking the reader's scroll
+      // offset and focus with it, which is the one thing this signature exists to prevent.
+      return mate.label + "," + mate.state + "," + mate.mail + "," + mate.listening +
+        "," + (mate.you ? 1 : 0) + "," + ids.join("+") + "," + mate.cards.done.length;
+    }
+    var parts = [query, folded ? "folded" : "open", noBus ? "no bus" : "bus"];
+    for (var i = 0; i < head.length; i++) parts.push(row(head[i]));
+    parts.push("--");
+    for (var j = 0; j < tail.length; j++) parts.push(row(tail[j]));
+    return parts.join("|");
+  }
+
+  function stripSig(done, filtering, folded, total) {
+    var ids = [];
+    for (var i = 0; i < done.length; i++) ids.push(done[i].id);
+    return ids.join(",") + "|" + (filtering ? "filtered" : "all") + "|" + (folded ? "folded" : "open") + "|" + total;
+  }
+
   board.renderTeam = function (view) {
-    var root = document.getElementById("board-team");
-    if (!root) return;
-    root.textContent = "";
+    var shell = slots();
+    if (shell === undefined) return;
     var round = view.round;
     // Absent, not empty: null means no bus here, so every state reads unknown.
     var roster = view.teammates === undefined ? null : view.teammates;
@@ -268,60 +458,91 @@ export const BOARD_TEAM_JS = String.raw`(function () {
     var filtering = query !== "";
     var noMatch = "no card here matches \"" + query + "\"";
 
-    var grid = el("div", N.teamGrid);
-
     var all = needs(view);
     var decisions = all.filter(function (entry) { return keep(entry.card); });
-    var queue = panel("Needs a decision", decisions.length, all.length);
-    if (decisions.length === 0) {
-      queue.appendChild(el("p", N.teamEmpty, filtering ? noMatch : "nothing needs you: no blockers, nothing idle, every card planned and held"));
-    } else {
+    fill(shell.queue, queueSig(decisions, all.length, query), function (slot) {
+      caption(slot, "Needs a decision", decisions.length, all.length);
+      if (decisions.length === 0) {
+        slot.appendChild(el("p", N.teamEmpty, filtering ? noMatch : "nothing needs you: no blockers, no contract waiting to be read, nothing idle"));
+        return;
+      }
       var list = el("div", N.teamQueue);
       for (var i = 0; i < decisions.length; i++) list.appendChild(decision(decisions[i], view));
-      queue.appendChild(list);
-    }
-    grid.appendChild(queue);
+      slot.appendChild(list);
+    });
 
     var everyone = teammates(view, roster);
-    var shown = everyone.filter(function (m) {
+    var keepRow = function (mate) {
       if (!filtering) return true;
-      if (matchesLabel(m.label)) return true;
-      var held = m.cards.live.concat(m.cards.done);
+      if (matchesLabel(mate.label)) return true;
+      var held = mate.cards.live.concat(mate.cards.done);
       for (var k = 0; k < held.length; k++) if (keep(held[k])) return true;
       return false;
+    };
+    var head = everyone.head.filter(keepRow);
+    var history = everyone.tail.filter(keepRow);
+    var people = everyone.head.length + everyone.tail.length;
+    // A filter is a view of the rows, so it unfolds the history: a matching owner hidden
+    // inside a fold would make the panel say "nothing matches" about somebody who is here.
+    var folded = filtering ? false : historyFolded(everyone.tail);
+    fill(shell.people, peopleSig(head, history, query, folded, roster === null), function (slot) {
+      caption(slot, "Teammates", head.length + history.length, people);
+      if (head.length + history.length === 0) {
+        slot.appendChild(el("p", N.teamEmpty, filtering ? noMatch : roster === null ? "session-bus is not loaded here" : "nobody is here yet"));
+        return;
+      }
+      var list = el("ul", N.teamRoster);
+      for (var i = 0; i < head.length; i++) list.appendChild(mate(head[i]));
+      if (history.length > 0) {
+        // While a filter asks for people by name, the matches are rows like any other; unfolded,
+        // they follow the one row that states them.
+        if (!filtering) {
+          list.appendChild(tailRow(history, folded));
+          if (folded) {
+            slot.appendChild(list);
+            return;
+          }
+        }
+        for (var j = 0; j < history.length; j++) list.appendChild(mate(history[j]));
+      }
+      slot.appendChild(list);
     });
-    var people = panel("Teammates", shown.length, everyone.length);
-    if (shown.length === 0) {
-      people.appendChild(el("p", N.teamEmpty, filtering ? noMatch : roster === null ? "session-bus is not loaded here" : "nobody is here yet"));
-    } else {
-      var rosterList = el("ul", N.teamRoster);
-      for (var j = 0; j < shown.length; j++) rosterList.appendChild(mate(shown[j]));
-      people.appendChild(rosterList);
-    }
-    grid.appendChild(people);
-    root.appendChild(grid);
 
     var done = round.done.filter(keep);
-    var strip = el("p", N.teamDone);
-    if (done.length === 0) {
-      // While filtering, a third "no card here matches" line adds nothing; the two
-      // panels above already said it.
-      if (filtering) return root;
-      strip.textContent = "nothing finished yet";
-    } else {
-      strip.appendChild(document.createTextNode("Done \u00B7 "));
-      for (var m = 0; m < done.length; m++) {
-        (function (card) {
-          var id = el("button", N.teamId, "#" + card.id);
-          id.type = "button";
-          id.setAttribute("aria-haspopup", "dialog");
-          id.addEventListener("click", function () { board.openCard(card.id); });
-          strip.appendChild(id);
-        })(done[m]);
+    var stripFolded = doneFolded(done.length);
+    fill(shell.strip, stripSig(done, filtering, stripFolded, round.done.length), function (slot) {
+      if (done.length === 0) {
+        // While filtering, a third "no card here matches" line adds nothing; the two panels
+        // above already said it.
+        if (!filtering) slot.textContent = "nothing finished yet";
+        return;
       }
-      strip.appendChild(document.createTextNode(" \u00B7 " + plural(done.length, "card") +
-        (filtering && done.length !== round.done.length ? " of " + round.done.length : "")));
-    }
-    root.appendChild(strip);
+      slot.appendChild(document.createTextNode("Done \u00B7 "));
+      var shown = Math.min(done.length, board.foldAt.done);
+      for (var i = 0; i < shown; i++) slot.appendChild(doneId(done[i]));
+      if (done.length > board.foldAt.done) {
+        var rest = el("span", N.teamDoneIds);
+        rest.id = "team-done-ids";
+        rest.hidden = stripFolded;
+        for (var j = board.foldAt.done; j < done.length; j++) rest.appendChild(doneId(done[j]));
+        slot.appendChild(rest);
+      }
+      slot.appendChild(document.createTextNode(" \u00B7 "));
+      var count = plural(done.length, "card") +
+        (filtering && done.length !== round.done.length ? " of " + round.done.length : "");
+      if (done.length > board.foldAt.done) {
+        // The count is the fold's control here, the way a lane's head is its own: the strip has
+        // no room for a second button, and the number is what says how much is out of sight.
+        var toggle = el("button", N.teamFold, count);
+        toggle.type = "button";
+        toggle.setAttribute("data-fold", "team-done");
+        toggle.setAttribute("aria-expanded", String(!stripFolded));
+        toggle.setAttribute("aria-controls", "team-done-ids");
+        toggle.addEventListener("click", function () { board.toggleFold("team-done"); });
+        slot.appendChild(toggle);
+      } else {
+        slot.appendChild(document.createTextNode(count));
+      }
+    });
   };
 })();`;

package/extensions/bytefly/block/fallback.ts

@@ -114,7 +114,7 @@ export function resultFallback(
 	if (!text) return "";
 	const lines = text.split("\n");
 	const shown = expanded ? lines : lines.slice(0, FALLBACK_PREVIEW_LINES);
-	let output = theme.fg("toolOutput", shown.join("\n"));
+	let output = paint(theme, "toolOutput", shown.join("\n"));
 	const remaining = lines.length - shown.length;
 	if (remaining > 0) output += `\n${paint(theme, "meta", `... (${remaining} more lines)`)}`;
 	return output;

package/extensions/bytefly/doctor/runtime.ts

@@ -12,7 +12,7 @@ import { CONFIG_DIR_NAME, getAgentDir, type ExtensionAPI } from "@earendil-works
 import type { WebSearchProviderEvent } from "../../../lib/events.ts";
 import { PRICE_VERIFIED_AT } from "../footer/price/config.ts";
 import { readJsonResult } from "../../../lib/config.ts";
-import { isExtensionEnabled } from "../../../lib/env.ts";
+import { extensionDisabledReason } from "../../../lib/env.ts";
 import {
 	hardRequirementExtensions,
 	probeAll as probeDeclared,
@@ -91,7 +91,10 @@ export function createDoctorRuntime(
 		readJson: readJsonResult,
 		dirs: { agentDir: getAgentDir(), cwd, configDirName: CONFIG_DIR_NAME },
 		platform: process.platform,
-		isEnabled: (extension) => isExtensionEnabled(extension) && !config.skip.includes(extension),
+		// The doctor's own skip list is this report's decision, not the environment's,
+		// so it answers for the extension it holds back.
+		disabledReason: (extension) =>
+			config.skip.includes(extension) ? "skipped by `doctor.skip`" : extensionDisabledReason(extension),
 		notify: notifySeam(cwd),
 		isTTY: process.stdout.isTTY === true,
 		searchProvider: () => searchProvider,

package/extensions/bytefly/footer/collect/label.ts

@@ -0,0 +1,60 @@
+/**
+ * Following this session's roster label, for the bar.
+ *
+ * The footer renders on a frame timer, so the label cannot be a bus read per frame. It is
+ * one read of the record the bus wrote — a resumed pane can already have one — and a
+ * subscription to `SESSION_LABEL_CHANNEL` for every label the bus settles afterwards. Both
+ * report through the sink the footer handed in, so the renderer reads one field and the I/O
+ * happens once.
+ *
+ * No record is the ordinary answer, not a failure: bytefly is on by default and the bus is
+ * opt-in, so a session that never joined keeps Pi's own name.
+ *
+ * Its caller loads this module on the first footer install rather than at registration,
+ * because the read needs the bus's layout on disk and the registration graph is a budget in
+ * `test/dependencies.test.ts` that may only fall.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { SESSION_LABEL_CHANNEL, type SessionLabelEvent, sessionIdOf } from "../../../../lib/session-label.ts";
+import { readSessionLabel } from "../../../../lib/session-roster.ts";
+
+/** What to draw: the label, or `null` for "no record, keep Pi's session name". */
+export type RosterLabelSink = (label: string | null) => void;
+
+/**
+ * Read this session's label once, then report every label the bus publishes for it.
+ *
+ * The subscription is here rather than beside the footer's other listeners because the
+ * channel and the record walk are one contract, and only this module is deferred. It is
+ * never unsubscribed: Pi drops an extension's listeners when it unloads, and a footer that
+ * re-installs (a session tree change) is the same session under the same label.
+ *
+ * Answers when the record has been read, so a caller can wait for the first frame that
+ * draws a label rather than guess at a timer.
+ */
+export function followRosterLabel(input: {
+	pi: Pick<ExtensionAPI, "events">;
+	ctx: Pick<ExtensionContext, "sessionManager">;
+	agentDir: string;
+	sink: RosterLabelSink;
+}): Promise<void> {
+	const { pi, ctx, agentDir, sink } = input;
+	const own = sessionIdOf(ctx);
+	if (own === undefined) return Promise.resolve();
+	pi.events.on(SESSION_LABEL_CHANNEL, (event) => {
+		// The channel reaches every session in this process, and only one of them is this one:
+		// a peer's label would put its name on this session's bar.
+		const published = event as SessionLabelEvent | undefined;
+		if (published === undefined || published.id !== own) return;
+		sink(published.label);
+	});
+	// The record the bus wrote before this process started, if any. A failure is the same
+	// answer as no record: the bar keeps Pi's own name.
+	return readSessionLabel(agentDir, own).then(
+		(label) => {
+			if (label !== undefined) sink(label);
+		},
+		() => {},
+	);
+}

package/extensions/bytefly/footer/collect/snapshot.ts

@@ -42,7 +42,11 @@ export interface SnapshotReader {
 	peek(): PricedUsage | undefined;
 }
 
-export function createSnapshotReader(config: ByteflyConfig, delegation: DelegationLedger): SnapshotReader {
+export function createSnapshotReader(
+	config: ByteflyConfig,
+	delegation: DelegationLedger,
+	rosterLabel: () => string | null = () => null,
+): SnapshotReader {
 	const price = createPricer(config);
 	let key: string | null = null;
 	let usage: PricedUsage = { ...zeroUsage(), unpriced: 0, unpricedModels: [] };
@@ -90,6 +94,9 @@ export function createSnapshotReader(config: ByteflyConfig, delegation: Delegati
 		return {
 			cwd: ctx.cwd,
 			sessionName,
+			// Read every frame, because the bus settles a label without the session moving: a
+			// cached field, not a read — nothing here touches the bus.
+			rosterLabel: rosterLabel(),
 			branch: footerData.getGitBranch(),
 			statuses: footerData.getExtensionStatuses(),
 			model,

package/extensions/bytefly/footer/config.ts

@@ -30,12 +30,14 @@ export const CONFIG = {
 		worktree: GLYPHS.worktree,
 		http: GLYPHS.http,
 		delegation: GLYPHS.delegation,
+		autoMode: GLYPHS.autoMode,
+		planMode: GLYPHS.plan,
 	},
 	/** Status key the worktree extension uses; routed to line 1's right zone. */
 	worktreeStatusKey: STATUS_KEYS.worktree,
 	/** Status key `serve` publishes the session's one page port under. */
 	httpStatusKey: STATUS_KEYS.http,
-	/** Status key whose ` · detail` suffix (the plan file name) is dropped. */
+	/** Status key whose chip is the plan state; the mode segment renders it. */
 	planStatusKey: STATUS_KEYS.planMode,
 	/**
 	 * Status keys that are alerts rather than modes, and so are never dropped.
@@ -43,7 +45,7 @@ export const CONFIG = {
 	 * once its chip is off the bar.
 	 */
 	alertStatusKeys: ALERT_STATUS_KEYS,
-	labels: { noModel: "no model", detached: "detached" },
+	labels: { noModel: "no model", detached: "detached", autoMode: "auto", planMode: "plan" },
 	/** Minimum gap kept between the left and right zones. */
 	minGap: 2,
 	/** Worktree label length before the compact form truncates it. */