bermudis-pi-goodies 0.24.2 → 0.25.0

package/README.md

@@ -26,7 +26,7 @@ extensions. One entry point, thirteen independent features.
 After publishing the package to npm:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.24.2
+pi install npm:bermudis-pi-goodies@0.25.0
 ```
 
 Remove any old `bermudis-pi-goodies.ts` symlink before reloading Pi. Each
@@ -357,6 +357,12 @@ session. `/side-exit` closes it and chooses what the main agent receives.
 
 How it works:
 
+- **Badge**: while a side session is open, the footer's model readout becomes
+  `side: (zai) glm-5.3 • max` — the provider-balance footer prepends the
+  badge to the stats line instead of adding a separate `side:` status line
+  (which remains the fallback when that footer is not mounted). The readout
+  tracks mid-side ctrl+l switches, and the badge clears on exit or when
+  switching to a session that is not in a side consultation.
 - **Entry**: `/side` opens pi's own model selector (falls back to a plain
   selector when pi's internal runtime is not reachable; in headless modes pass
   the model explicitly as `/side provider/model-id[:level]`). The main agent's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bermudis-pi-goodies",
-  "version": "0.24.2",
+  "version": "0.25.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bermudi/agent-extensions.git",

package/provider-balance.ts

@@ -4,7 +4,11 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import {
+  stripTerminalSequences,
+  truncateToWidth,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
 import { createHash, randomUUID } from "node:crypto";
 import {
   chmodSync,
@@ -26,6 +30,13 @@ import {
   timeoutSignal,
 } from "./json-file.ts";
 import { getKiloCatalogStatus, type KiloCatalogStatus } from "./kilo.ts";
+import { logGoodiesEvent } from "./goodies-log.ts";
+import {
+  getSideSessionModel,
+  onSideBadgeChange,
+  setMergedSideBadgeInstalled,
+  setMergedSideBadgeRendered,
+} from "./side-state.ts";
 
 const KILO_API_BASE = process.env.KILO_API_URL || "https://api.kilo.ai";
 const KILO_BALANCE_ENDPOINT = `${KILO_API_BASE}/api/profile/balance`;
@@ -1284,6 +1295,50 @@ function addBalanceToWorkingDirectoryLine(
   return [`${left}${padding}${right}`, ...lines.slice(1)];
 }
 
+const SGR_SEQUENCE = /\x1b\[[0-9;:]*m/g;
+
+/**
+ * Prepend a badge to the right-aligned model readout of the stats line pi's
+ * FooterComponent produced: `side: (zai) glm-5.3 • max`. The line is built
+ * as `<dim statsLeft><dim padding + model>` — split at the opener of the
+ * final styled run (the last SGR sequence is its closer, so the opener is
+ * the second-to-last), keep the left half verbatim (it may carry a colored
+ * context percentage), and rebuild the right half around the badge.
+ *
+ * Returns undefined when the line lacks that two-run shape — the caller then
+ * leaves the line untouched and the /side badge falls back to a status line.
+ * Deliberately structural, not textual: no assumption about stats or model
+ * spelling, only about how pi styles the two halves.
+ */
+export function mergeSideBadgeIntoStatsLine(
+  line: string,
+  width: number,
+  theme: FooterTheme,
+  prefix = "side: ",
+): string | undefined {
+  if (!line || width <= 0) return undefined;
+  const runs = [...line.matchAll(SGR_SEQUENCE)];
+  if (runs.length < 2) return undefined;
+  const opener = runs[runs.length - 2]?.index;
+  if (opener === undefined) return undefined;
+  const head = line.slice(0, opener);
+  const tail = stripTerminalSequences(line.slice(opener)).trim();
+  if (!tail || !stripTerminalSequences(head).trim()) return undefined;
+
+  const labeled = `${prefix}${tail}`;
+  const headWidth = visibleWidth(head);
+  const room = width - headWidth - 2; // pi keeps ≥2 columns between the halves
+  if (room <= 0) return undefined;
+  const right =
+    visibleWidth(labeled) <= room
+      ? labeled
+      : truncateToWidth(labeled, room, "");
+  const padding = " ".repeat(
+    Math.max(2, width - headWidth - visibleWidth(right)),
+  );
+  return `${head}${theme.fg("dim", padding + right)}`;
+}
+
 // --- Kilo catalog badge ------------------------------------------------------
 // kilo.ts serves a fallback catalog when its refresh fails (see
 // getKiloCatalogStatus in kilo.ts). The balance footer is the only
@@ -1349,6 +1404,9 @@ export default function providerBalance(
   /** True while our footer component is the one mounted in the TUI. */
   let footerInstalled = false;
   let activeThinkingLevel: ActiveThinkingLevel = "off";
+  /** Logged once per footer install: the /side badge merge stopped matching
+   *  pi's stats-line shape and the badge fell back to a status line. */
+  let sideBadgeDriftLogged = false;
 
   function clearBalance(): void {
     balance = undefined;
@@ -1648,6 +1706,7 @@ export default function providerBalance(
   function installFooter(ctx: ExtensionContext): void {
     if (ctx.mode !== "tui") return;
     activeContext = ctx;
+    const unsubscribeSideBadge = onSideBadgeChange(() => requestRender?.());
     ctx.ui.setFooter((tui, theme, footerData) => {
       requestRender = () => tui.requestRender();
       const footer = new FooterComponent(
@@ -1687,21 +1746,49 @@ export default function providerBalance(
             kiloBadge && balanceText
               ? `${kiloBadge} · ${balanceText}`
               : (kiloBadge ?? balanceText);
-          return addBalanceToWorkingDirectoryLine(
+          const lines = addBalanceToWorkingDirectoryLine(
             footer.render(width),
             width,
             theme,
             rightText,
           );
+          // Side-session badge: prepend "side: " to the stats line's
+          // right-aligned model readout (the session model IS the side model
+          // while a side session is open). Report whether the merge landed so
+          // side.ts can drop the separate status line — or fall back to it
+          // when a pi update changes the stats-line shape.
+          const sideModel = getSideSessionModel();
+          let merged = false;
+          if (sideModel && typeof lines[1] === "string") {
+            const statsLine = mergeSideBadgeIntoStatsLine(
+              lines[1],
+              width,
+              theme,
+            );
+            if (statsLine !== undefined) {
+              lines[1] = statsLine;
+              merged = true;
+            }
+          }
+          setMergedSideBadgeRendered(merged);
+          if (sideModel && !merged && !sideBadgeDriftLogged) {
+            sideBadgeDriftLogged = true;
+            logGoodiesEvent({ type: "side_badge_merge_failed" });
+          }
+          return lines;
         },
         dispose: () => {
           unsubscribeBranchChange();
+          unsubscribeSideBadge();
           footer.dispose();
           requestRender = undefined;
           footerInstalled = false;
+          sideBadgeDriftLogged = false;
+          setMergedSideBadgeInstalled(false);
         },
       };
     });
+    setMergedSideBadgeInstalled(true);
     footerInstalled = true;
   }
 

package/side-state.ts

@@ -0,0 +1,94 @@
+/**
+ * Shared side-session badge state.
+ *
+ * `side.ts` owns the truth (is a side session active, which model serves
+ * it); `provider-balance.ts` renders the badge merged into the stats line's
+ * right-hand model readout ("side: (zai) glm-5.3 • max") instead of a
+ * separate status line.
+ *
+ * Why the installed/rendered two-step: pi's footer internals are not public
+ * API — the merge rewrites the stats line pi's FooterComponent produced by
+ * splitting at its final styled run. If a pi update changes that line shape,
+ * the merge must bow out and let /side fall back to the classic status line.
+ * So the footer reports per-render whether the merge actually landed, and
+ * the badge policy (side.ts) suppresses the status line only while the
+ * merge is both installed and proven working.
+ */
+
+export interface SideModelRef {
+  provider: string;
+  id: string;
+}
+
+let activeModel: SideModelRef | undefined;
+let mergedInstalled = false;
+let mergedRendered = false;
+
+const listeners = new Set<() => void>();
+
+function sameModel(
+  a: SideModelRef | undefined,
+  b: SideModelRef | undefined,
+): boolean {
+  return (
+    a === b ||
+    (a !== undefined &&
+      b !== undefined &&
+      a.provider === b.provider &&
+      a.id === b.id)
+  );
+}
+
+function emit(): void {
+  for (const listener of listeners) listener();
+}
+
+/** side.ts: the model serving the active side session, or undefined. */
+export function setSideSessionModel(model: SideModelRef | undefined): void {
+  if (sameModel(activeModel, model)) return;
+  activeModel = model;
+  emit();
+}
+
+export function getSideSessionModel(): SideModelRef | undefined {
+  return activeModel;
+}
+
+/** provider-balance: its footer now owns (or handed back) the stats line. */
+export function setMergedSideBadgeInstalled(installed: boolean): void {
+  if (mergedInstalled === installed) return;
+  mergedInstalled = installed;
+  if (!installed) mergedRendered = false;
+  emit();
+}
+
+/**
+ * provider-balance: whether the latest render with a side session actually
+ * merged the badge into the stats line. No-op when unchanged, so the
+ * render → emit → applyStatus → render cycle always terminates.
+ */
+export function setMergedSideBadgeRendered(rendered: boolean): void {
+  if (mergedRendered === rendered) return;
+  mergedRendered = rendered;
+  emit();
+}
+
+/** True while the stats-line merge is mounted and proven working. */
+export function isMergedSideBadgeActive(): boolean {
+  return mergedInstalled && mergedRendered;
+}
+
+export function onSideBadgeChange(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/** Test-only: restore the pristine module state (undefined/false/false). */
+export function resetSideBadgeState(): void {
+  activeModel = undefined;
+  mergedInstalled = false;
+  mergedRendered = false;
+  listeners.clear();
+}

package/side.ts

@@ -48,6 +48,13 @@ import {
 import { describeError, extractTextParts } from "./json-file.ts";
 import { buildTrajectory, renderTrajectory } from "./copy-trajectory.ts";
 import { logGoodiesEvent } from "./goodies-log.ts";
+import {
+  getSideSessionModel,
+  isMergedSideBadgeActive,
+  onSideBadgeChange,
+  setSideSessionModel,
+  type SideModelRef,
+} from "./side-state.ts";
 
 type ActiveModel = NonNullable<ExtensionContext["model"]>;
 type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
@@ -491,7 +498,22 @@ function updateBadge(
   ctx: ExtensionContext,
   model: { provider: string; id: string },
 ): void {
-  ctx.ui.setStatus("side", `side: ${modelRef(model)}`);
+  setSideSessionModel(model);
+  applySideStatus(ctx);
+}
+
+/**
+ * Mirror the side state into pi's status line — unless the provider-balance
+ * footer is currently rendering the badge merged into the stats line's model
+ * readout, in which case a separate status line would duplicate it.
+ */
+export function applySideStatus(ctx: ExtensionContext): void {
+  const model: SideModelRef | undefined = getSideSessionModel();
+  const text =
+    model && !isMergedSideBadgeActive()
+      ? `side: ${modelRef(model)}`
+      : undefined;
+  ctx.ui.setStatus("side", text);
 }
 
 function sideMarkerFromBranch(
@@ -557,6 +579,9 @@ async function summarizeDelta(
 // ---------------------------------------------------------------------------
 
 let modelRegistryRef: ExtensionContext["modelRegistry"] | undefined;
+/** Latest live context, for re-applying the badge when the merged footer
+ *  toggles; cleared on session_shutdown before the ctx goes stale. */
+let lastBadgeCtx: ExtensionContext | undefined;
 
 export default function side(pi: ExtensionAPI): void {
   // Lens: rewrite side-agent requests so the main trajectory arrives as an
@@ -599,7 +624,8 @@ export default function side(pi: ExtensionAPI): void {
         activeSideModel(ctx.sessionManager.getBranch(), marker.data),
       );
     } else {
-      ctx.ui.setStatus("side", undefined);
+      setSideSessionModel(undefined);
+      applySideStatus(ctx);
     }
   });
 
@@ -608,6 +634,7 @@ export default function side(pi: ExtensionAPI): void {
   // ctrl+l switch updates it; the marker keeps the original).
   pi.on("session_start", (_event, ctx) => {
     modelRegistryRef = ctx.modelRegistry; // for /side argument completions
+    lastBadgeCtx = ctx;
     const marker = sideMarkerFromBranch(ctx);
     if (marker) {
       const active = activeSideModel(
@@ -616,9 +643,26 @@ export default function side(pi: ExtensionAPI): void {
       );
       updateBadge(ctx, active);
       logGoodiesEvent({ type: "side_resumed", model: modelRef(active) });
+    } else {
+      // Switched/new/resumed into a non-side session: drop any badge the
+      // previous session left behind (both the status line and the state
+      // the merged footer badge reads).
+      setSideSessionModel(undefined);
+      applySideStatus(ctx);
     }
   });
 
+  // The footer-rendered badge needs a re-render when side state changes;
+  // the status-line fallback needs re-applying when the merged footer
+  // appears or disappears (install order between the two modules is not
+  // guaranteed to leave the badge applied with the right policy).
+  pi.on("session_shutdown", () => {
+    lastBadgeCtx = undefined;
+  });
+  onSideBadgeChange(() => {
+    if (lastBadgeCtx) applySideStatus(lastBadgeCtx);
+  });
+
   pi.registerEntryRenderer<SideMarkerData>(
     SIDE_MARKER_TYPE,
     (entry, _options, theme) => {
@@ -889,7 +933,8 @@ export default function side(pi: ExtensionAPI): void {
           "warning",
         );
       }
-      ctx.ui.setStatus("side", undefined);
+      setSideSessionModel(undefined);
+      applySideStatus(ctx);
 
       if (
         (mode === "trajectory" || mode === "summary") &&