@tt-a1i/openpi 0.3.1 → 0.5.0

package/extensions/sessions/sessions.ts

@@ -162,6 +162,30 @@ export function filterSessionInfos(
   );
 }
 
+/**
+ * Mirror pi-tui SelectList's centered viewport so background stats work is
+ * limited to rows the picker can actually render. Keep the formula locked by
+ * tests because SelectList does not expose its visible range.
+ */
+export function selectSessionStatsWindow(
+  sessions: readonly SessionInfoLike[],
+  selectedPath: string,
+  maxVisible: number,
+) {
+  if (sessions.length === 0) return [];
+  const visible = Math.max(1, Math.min(maxVisible, sessions.length));
+  const found = sessions.findIndex((session) => session.path === selectedPath);
+  const selectedIndex = found >= 0 ? found : 0;
+  const startIndex = Math.max(
+    0,
+    Math.min(
+      selectedIndex - Math.floor(visible / 2),
+      sessions.length - visible,
+    ),
+  );
+  return sessions.slice(startIndex, startIndex + visible);
+}
+
 export function getSessionPaneLayout(width: number): SessionPaneLayout {
   if (width < 80) {
     return { mode: "single", listWidth: width, previewWidth: 0 };
@@ -340,12 +364,21 @@ function messageToBlocks(message: PreviewMessageLike): PreviewBlock[] {
 export function buildSessionPreview(
   session: SessionInfoLike,
   messages: PreviewMessageLike[],
-  options: { maxMessages?: number } = {},
+  options: {
+    maxMessages?: number;
+    totalMessages?: number;
+    truncatedBytes?: number;
+  } = {},
 ): SessionPreview {
   const maxMessages = options.maxMessages ?? 80;
   const blocks: PreviewBlock[] = [];
-  const omitted = Math.max(0, messages.length - maxMessages);
-  const visibleMessages = omitted > 0 ? messages.slice(-maxMessages) : messages;
+  const visibleMessages =
+    messages.length > maxMessages ? messages.slice(-maxMessages) : messages;
+  const totalMessages = Math.max(
+    visibleMessages.length,
+    options.totalMessages ?? messages.length,
+  );
+  const omitted = Math.max(0, totalMessages - visibleMessages.length);
 
   if (omitted > 0) {
     blocks.push({
@@ -353,12 +386,18 @@ export function buildSessionPreview(
       text: `… ${omitted} earlier messages omitted`,
     });
   }
+  if ((options.truncatedBytes ?? 0) > 0) {
+    blocks.push({
+      kind: "notice",
+      text: `… ${options.truncatedBytes} bytes of preview content omitted`,
+    });
+  }
 
   for (const message of visibleMessages) {
     blocks.push(...messageToBlocks(message));
   }
 
-  const messageCount = session.messageCount ?? messages.length;
+  const messageCount = session.messageCount ?? totalMessages;
   return {
     title: buildSessionLabel(session),
     subtitle: `${formatTimestamp(session.modified)} · ${messageCount} messages · ${cleanDisplayLine(session.cwd)}`,

package/extensions/setup/index.ts

@@ -1,6 +1,7 @@
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
+  ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
@@ -9,18 +10,15 @@ import {
   type SubagentRoleModel,
   type SubagentRoleModels,
 } from "../shared/subagent-roles.ts";
-import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 import {
   OPENPI_SETUP_EPISODE_CHANNEL,
   type OpenPiSetupEpisodeState,
 } from "../shared/setup-episode-state.ts";
-import { patchOwnedTools } from "../shared/tool-surface.ts";
 import {
-  formatPiIntercomStatus,
-  inspectPiIntercom,
-  installPiIntercom,
-  type PiIntercomStatus,
-} from "./intercom.ts";
+  isOwnedToolActive,
+  isOwnedToolAvailable,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
 import {
   applyFooterConfig,
   CAPABILITY_DISCOVERY_MODES,
@@ -132,12 +130,11 @@ export function buildInteractiveSetupPrompt(options: {
     "- Capability discovery: explicit is the safe default and keeps OpenPI model tools absent until the user asks for a capability. adaptive is opt-in and keeps only the small openpi_load_tools gateway visible, allowing the model to load Subagents, Workflows, background terminals, structured search, or Session tracking when it judges them useful. Loaded groups remain session-stable, and normal permission, concurrency, and workflow limits still apply.",
     "- Next-action suggestions: disabled, or model-generated after a fully settled main-agent run. A suggestion appears as dim inline text on the first row of an empty editor; reserved cells at the row end keep CJK IME preedit from overwriting it. Right accepts it without submitting, and any other editor input dismisses it. Enabling requires an available provider/model and reasoning level and adds one small model call per settled run.",
     "- Workflow fan-out: concurrency controls simultaneous agents and resource pressure; max agent calls controls the total capacity of one workflow. Valid ranges are 1-64 and 1-1024.",
-    "- UI: the large header costs vertical space; the custom footer is a declarative dashboard. Presets: powerline (one-line ANSI256 blocks), powerline-mono (one-line high-contrast gray powerline), and compact (one-line plain text); the default is plain with cwd/git/pr on the left and model/context/cost on the right. Style can also be set independently: plain, powerline, powerline-mono. Custom lines are a 2D layout of cwd/model/thinking/context/cache/cost/throughput/git/pr plus at most one flex per line for left/right alignment. Nerd Font only affects powerline separator glyphs; text stays readable without it. Changes apply immediately in the active TUI session.",
+    "- UI: the large header costs vertical space; the custom footer is a declarative dashboard. Presets: powerline (one-line ANSI256 blocks), powerline-mono (one-line high-contrast gray powerline), and compact (one-line plain text); the default is plain with model/context on the left and git/pr/cwd on the right. Style can also be set independently: plain, powerline, powerline-mono. Custom lines are a 2D layout of cwd/model/thinking/context/cache/cost/throughput/git/pr plus at most one flex per line for left/right alignment. Footer metrics use Codicon outline glyphs for model, context, and directory; a Nerd Font renders them as designed while the text stays readable without it. Changes apply immediately in the active TUI session.",
     "- Operational activity for Subagents, Workflows, and background terminals is core status and always remains visible whenever the custom footer is enabled.",
     "- Post-edit command: one optional shell command (maximum 500 characters) run in the background after a turn with successful Write/Edit operations (e.g. `npm run format`). Off by default, interactive TUI sessions only, failures surface as a notification. This is a single command, not an event-hook system.",
-    "- Result detail display: Subagent results, Bash operations, and Write/Edit operations can each default to full or compact. Compact Subagent results show only bounded status rows and keep raw child reports behind app.tools.expand; compact Bash and Write/Edit operations use folded previews. Ctrl+O expands compact output by default. Bash and Write/Edit default to compact. Recommend compact for users who do not usually inspect implementation details.",
+    "- Result detail display: Subagent results, Bash operations, and Write/Edit operations can each default to full or compact; all three default to compact. Compact Subagent results show only bounded status rows and keep raw child reports behind app.tools.expand; compact Bash and Write/Edit operations use one-line semantic activity summaries. Read, grep, find, and ls use the same compact activity-row projection. Ctrl+O restores Pi's native full arguments, output, errors, diffs, and timing. Recommend compact for users who scan activity first and inspect evidence on demand.",
     "- Agent role models: built-in explorer, implementer, reviewer, and advisor roles are shared by subagent_spawn and workflow agent_type, and inherit the parent model by default. Assign only an available registry model to an individual role when needed; clearing that role returns it to inheritance. Custom agent-type files still override a built-in role's complete definition.",
-    "- Intercom: optional cross-session messaging is installed only after a native setup confirmation. It stays parent-only; Direct/Workflow children and Replay cannot use it. The status above is informational for this model-guided step—do not install packages or edit its config yourself.",
     "",
     "Natural-language configuration examples the user might ask for:",
     '- "let the model discover OpenPI capabilities when useful" → capability_discovery=adaptive',
@@ -151,16 +148,10 @@ export function buildInteractiveSetupPrompt(options: {
     '- "make explorer use my available fast model" → subagent_role_models={explorer:{provider:"…",model:"…"}}',
     '- "make explorer inherit again" → subagent_role_models={explorer:null}',
     "",
-    "Use ask_user for the decision instead of merely printing instructions. Put the recommended choice first. Do not change configuration until the choices are clear. Then call configure_my_pi_setup at most once with the final requested changes, preserving everything else. Do not edit configuration files directly.",
+    "configure_my_pi_setup is available only for this setup run. If the run settles without a successful apply, the writer is hidden and a later change requires /openpi-setup <request>. Use ask_user for the decision instead of merely printing instructions. Put the recommended choice first. Do not change configuration until the choices are clear. Then call configure_my_pi_setup at most once with the final requested changes, preserving everything else. Do not edit configuration files directly.",
   ];
 }
 
-const safeSetupNotice = (value: unknown, maximum = 500) =>
-  sanitizeTerminalText(value instanceof Error ? value.message : String(value))
-    .replace(/\s+/gu, " ")
-    .trim()
-    .slice(0, maximum);
-
 export function buildSetupSuccessText(
   currentConfiguration: string,
   normalizationNote = "",
@@ -171,87 +162,12 @@ export function buildSetupSuccessText(
   ].join(" ");
 }
 
-export function shouldOfferPiIntercom(options: {
-  readonly request: string;
-  readonly status: PiIntercomStatus;
-  readonly mode: ExtensionCommandContext["mode"];
-  readonly idle: boolean;
-}) {
-  return (
-    !options.request &&
-    !options.status.active &&
-    !options.status.installed &&
-    !options.status.diagnostic &&
-    options.mode === "tui" &&
-    options.idle
-  );
-}
-
-async function maybeOfferPiIntercom(
-  ctx: ExtensionCommandContext,
-  status: PiIntercomStatus,
-  request: string,
-) {
-  if (
-    !shouldOfferPiIntercom({
-      request,
-      status,
-      mode: ctx.mode,
-      idle: ctx.isIdle(),
-    })
-  ) {
-    return status;
-  }
-
-  const accepted = await ctx.ui.confirm(
-    status.configured
-      ? "Repair optional pi-intercom integration?"
-      : "Install optional pi-intercom integration?",
-    [
-      "pi-intercom enables cross-session messaging through a local IPC broker.",
-      "Like every Pi package, it runs with full system access.",
-      "OpenPI will install npm:pi-intercom globally. A new private config gets safe defaults; an existing preference file is never rewritten and must already define both fields:",
-      "• confirmSend: true",
-      '• inboundTrigger: "replies"',
-      "It remains parent-only and activates after /reload.",
-    ].join("\n"),
-  );
-  if (!accepted) return status;
-
-  ctx.ui.setWorkingMessage("Installing optional pi-intercom integration...");
-  try {
-    await installPiIntercom({
-      cwd: ctx.cwd,
-      onProgress: (event) =>
-        ctx.ui.setWorkingMessage(
-          safeSetupNotice(
-            event.message ?? "Installing optional pi-intercom integration...",
-            200,
-          ),
-        ),
-    });
-    const installed = inspectPiIntercom({
-      cwd: ctx.cwd,
-      active: false,
-    });
-    const next = { ...installed, reloadRequired: true };
-    ctx.ui.notify(
-      "pi-intercom installed with existing preferences preserved or a new safe config created. Run /reload after setup to activate it.",
-      "info",
-    );
-    return next;
-  } catch (error) {
-    ctx.ui.notify(
-      `pi-intercom was not enabled: ${safeSetupNotice(error)}`,
-      "error",
-    );
-    return inspectPiIntercom({ cwd: ctx.cwd, active: false });
-  } finally {
-    ctx.ui.setWorkingMessage();
-  }
+export function buildSetupNoopClosureText() {
+  return "No configuration update was confirmed in this setup run. The configuration writer is now hidden. To make a configuration change, run /openpi-setup <request>; do not edit configuration files directly.";
 }
 
 export const CONFIGURE_MY_PI_SETUP_TOOL_NAME = "configure_my_pi_setup";
+const SETUP_REQUEST_CUSTOM_TYPE = "openpi-setup-request";
 
 type SetupEpisode = "idle" | "armed" | "active";
 
@@ -259,6 +175,7 @@ function showConfigureTool(pi: ExtensionAPI) {
   patchOwnedTools(pi, "setup", {
     enable: [CONFIGURE_MY_PI_SETUP_TOOL_NAME],
   });
+  return isOwnedToolActive(pi, "setup", CONFIGURE_MY_PI_SETUP_TOOL_NAME);
 }
 
 function hideConfigureTool(pi: ExtensionAPI) {
@@ -269,40 +186,123 @@ function hideConfigureTool(pi: ExtensionAPI) {
 
 export default function openPiSetup(pi: ExtensionAPI) {
   let episode: SetupEpisode = "idle";
+  let claimedToolCallId: string | undefined;
+  let blockedMatchingClaimCount = 0;
+  let requestSequence = 0;
+  const pendingRequests: Array<{ requestId: string; prompt: string }> = [];
   const publishEpisode = () =>
     pi.events.emit(OPENPI_SETUP_EPISODE_CHANNEL, {
-      active: episode !== "idle",
+      active: episode === "active",
     } satisfies OpenPiSetupEpisodeState);
 
-  const endEpisode = () => {
+  const hideActiveWriter = () => {
+    claimedToolCallId = undefined;
+    blockedMatchingClaimCount = 0;
+    episode = pendingRequests.length > 0 ? "armed" : "idle";
+    hideConfigureTool(pi);
+    publishEpisode();
+  };
+
+  const resetEpisode = () => {
+    claimedToolCallId = undefined;
+    blockedMatchingClaimCount = 0;
+    pendingRequests.length = 0;
     episode = "idle";
     hideConfigureTool(pi);
     publishEpisode();
   };
 
   pi.on("session_start", () => {
-    endEpisode();
+    resetEpisode();
   });
 
-  pi.on("agent_start", () => {
-    if (episode === "armed") {
-      episode = "active";
-      publishEpisode();
+  const dispatchNextRequest = (ctx: ExtensionContext) => {
+    const request = pendingRequests.shift();
+    if (!request) return;
+    if (!showConfigureTool(pi)) {
+      resetEpisode();
+      if (ctx.hasUI) {
+        ctx.ui.notify(
+          "OpenPI lost ownership of its configuration writer before setup started.",
+          "error",
+        );
+      }
+      pi.sendMessage({
+        customType: "openpi-setup-closed",
+        content:
+          "OpenPI could not activate its owned configuration writer, so setup was not started. Check for duplicate or mismatched OpenPI extension sources, then retry with /openpi-setup <request>. Do not edit configuration files directly.",
+        display: true,
+        details: { reason: "writer_activation_failed" },
+      });
+      return;
     }
+    claimedToolCallId = undefined;
+    blockedMatchingClaimCount = 0;
+    episode = "active";
+    publishEpisode();
+    pi.sendMessage(
+      {
+        customType: SETUP_REQUEST_CUSTOM_TYPE,
+        content: request.prompt,
+        display: true,
+        details: { requestId: request.requestId },
+      },
+      { triggerTurn: true },
+    );
+  };
+
+  pi.on("tool_call", (event) => {
+    if (event.toolName !== CONFIGURE_MY_PI_SETUP_TOOL_NAME) return;
+    if (
+      episode !== "active" ||
+      !isOwnedToolActive(pi, "setup", CONFIGURE_MY_PI_SETUP_TOOL_NAME)
+    ) {
+      return {
+        block: true as const,
+        reason:
+          "The OpenPI configuration writer is not active for this setup episode. Run /openpi-setup <request> to start a new setup episode.",
+      };
+    }
+    if (claimedToolCallId !== undefined) {
+      if (claimedToolCallId === event.toolCallId) {
+        blockedMatchingClaimCount += 1;
+      }
+      return {
+        block: true as const,
+        reason:
+          "This setup episode already admitted one configure_my_pi_setup call. Wait for its result before retrying.",
+      };
+    }
+    claimedToolCallId = event.toolCallId;
   });
 
   pi.on("tool_execution_end", (event) => {
     if (
-      episode === "active" &&
-      event.toolName === CONFIGURE_MY_PI_SETUP_TOOL_NAME &&
-      !event.isError
-    ) {
-      endEpisode();
+      episode !== "active" ||
+      event.toolName !== CONFIGURE_MY_PI_SETUP_TOOL_NAME ||
+      event.toolCallId !== claimedToolCallId
+    )
+      return;
+    if (!event.isError) {
+      hideActiveWriter();
+    } else if (blockedMatchingClaimCount > 0) {
+      blockedMatchingClaimCount -= 1;
+    } else {
+      claimedToolCallId = undefined;
     }
   });
 
-  pi.on("agent_settled", () => {
-    if (episode === "active") endEpisode();
+  pi.on("agent_settled", (_event, ctx) => {
+    if (episode === "active") {
+      hideActiveWriter();
+      pi.sendMessage({
+        customType: "openpi-setup-closed",
+        content: buildSetupNoopClosureText(),
+        display: true,
+        details: { reason: "settled_without_successful_apply" },
+      });
+    }
+    if (pendingRequests.length > 0) dispatchNextRequest(ctx);
   });
 
   pi.registerTool({
@@ -371,7 +371,7 @@ export default function openPiSetup(pi: ExtensionAPI) {
       ui_footer_style: Type.Optional(
         StringEnum(FOOTER_STYLES, {
           description:
-            "Footer visual style: plain (Pi theme separators), powerline (ANSI256 colored blocks with  seams), powerline-mono (high-contrast gray powerline). Nerd Font improves separator glyphs only. Omit to preserve the current style (or the preset's style when a preset is applied).",
+            "Footer visual style: plain (Pi theme separators), powerline (ANSI256 colored blocks with  seams), powerline-mono (high-contrast gray powerline). A Nerd Font renders Codicon metric glyphs and powerline seams as designed; text stays readable without it. Omit to preserve the current style (or the preset's style when a preset is applied).",
         }),
       ),
       ui_footer_lines: Type.Optional(
@@ -401,13 +401,13 @@ export default function openPiSetup(pi: ExtensionAPI) {
       bash_tool_display: Type.Optional(
         StringEnum(DETAIL_DISPLAYS, {
           description:
-            "How Bash commands and output render by default: compact keeps a one-line command plus a bounded output preview with a hidden-line count and expands with app.tools.expand; full keeps every command expanded. Omit to preserve the current value.",
+            "How Bash commands and output render by default: compact shows one semantic activity row with running/success/failure state; app.tools.expand restores Pi's native command, output, error, timing, and full-output metadata. Full keeps Pi's native rendering expanded by default. Omit to preserve the current value.",
         }),
       ),
       file_mutation_display: Type.Optional(
         StringEnum(DETAIL_DISPLAYS, {
           description:
-            "How Write/Edit content and diffs render by default: compact shows a Claude Code-style folded preview with a hidden-line count and expands with app.tools.expand; full keeps every operation expanded. Omit to preserve the current value.",
+            "How Write/Edit content and diffs render by default: compact shows one semantic activity row with path, status, and line/diff counts; app.tools.expand restores Pi's native preview, output, error, and diff. Full keeps Pi's native rendering expanded by default. Omit to preserve the current value.",
         }),
       ),
       subagent_role_models: Type.Optional(SUBAGENT_ROLE_MODELS_SCHEMA),
@@ -415,7 +415,7 @@ export default function openPiSetup(pi: ExtensionAPI) {
         Type.String({
           maxLength: POST_EDIT_COMMAND_MAX_CHARS,
           description:
-            'A single shell command (maximum 500 characters) to run in the background after a turn with successful Write/Edit operations, e.g. "npm run format". Runs once per changed turn, not per edit, and only in an interactive TUI session. Set to an empty string to turn it off. Omit to preserve the current value.',
+            'A single shell command (maximum 500 characters) to run in the background after a turn with successful Write/Edit operations, e.g. "npm run format". Set a non-empty command only when the current user\'s /openpi-setup request explicitly asks to configure Post-edit; do not infer one while changing another setting. Runs once per changed turn, not per edit, and only in an interactive TUI session. Set to an empty string to turn it off. Omit to preserve the current value.',
         }),
       ),
     }),
@@ -550,15 +550,7 @@ export default function openPiSetup(pi: ExtensionAPI) {
 
   const setupHandler = async (args: string, ctx: ExtensionCommandContext) => {
     const request = args.trim();
-    let intercomStatus = inspectPiIntercom({
-      cwd: ctx.cwd,
-      active: pi.getAllTools().some(({ name }) => name === "intercom"),
-    });
-    intercomStatus = await maybeOfferPiIntercom(ctx, intercomStatus, request);
-
-    const currentConfiguration = formatSetupConfig(loadSetupConfig(), [
-      formatPiIntercomStatus(intercomStatus),
-    ]);
+    const currentConfiguration = formatSetupConfig(loadSetupConfig());
     const savedConfigExists = hasSavedSetupConfig();
     const currentModel = ctx.model
       ? `${ctx.model.provider}/${ctx.model.id}`
@@ -573,9 +565,9 @@ export default function openPiSetup(pi: ExtensionAPI) {
           "Current configuration:",
           currentConfiguration,
           "",
-          "Capability discovery is explicit by default; adaptive is an opt-in that keeps only openpi_load_tools visible so the model may load useful groups. Footer tips: presets are powerline, powerline-mono, compact; style is plain/powerline/powerline-mono; custom layouts use ui_footer_lines (2D enum arrays with optional flex). Do not use ui_footer_items together with ui_footer_lines. Built-in Agent role models (explorer, implementer, reviewer, advisor) are shared by subagent_spawn and workflow agent_type; they inherit the parent unless assigned an available registry model, and clearing an assignment restores inheritance. Custom agent-type files still override built-in role definitions. Nerd Font only affects powerline separator glyphs. Changes apply immediately in the active TUI session. Intercom installation is handled only by the native setup confirmation; do not install packages or edit its config yourself.",
+          "Capability discovery is explicit by default; adaptive is an opt-in that keeps only openpi_load_tools visible so the model may load useful groups. Footer tips: presets are powerline, powerline-mono, compact; style is plain/powerline/powerline-mono; custom layouts use ui_footer_lines (2D enum arrays with optional flex). Do not use ui_footer_items together with ui_footer_lines. Built-in Agent role models (explorer, implementer, reviewer, advisor) are shared by subagent_spawn and workflow agent_type; they inherit the parent unless assigned an available registry model, and clearing an assignment restores inheritance. Custom agent-type files still override built-in role definitions. A Nerd Font renders Footer Codicons and powerline seams as designed; text stays readable without it. Changes apply immediately in the active TUI session.",
           "",
-          "Use configure_my_pi_setup to apply only the requested OpenPI-owned changes and preserve everything else. Interpret model names from the available Pi registry. Do not edit configuration files directly.",
+          "configure_my_pi_setup is available only for this setup run. If the run settles without a successful apply, the writer is hidden and a later change requires /openpi-setup <request>. Use configure_my_pi_setup to apply only the requested OpenPI-owned changes and preserve everything else. Interpret model names from the available Pi registry. Do not edit configuration files directly.",
         ]
       : buildInteractiveSetupPrompt({
           currentConfiguration,
@@ -584,13 +576,17 @@ export default function openPiSetup(pi: ExtensionAPI) {
           savedConfigExists,
         });
 
-    episode = "armed";
-    showConfigureTool(pi);
-    publishEpisode();
-    pi.sendUserMessage(
-      prompt.join("\n"),
-      ctx.isIdle() ? undefined : { deliverAs: "followUp" },
-    );
+    if (!isOwnedToolAvailable(pi, "setup", CONFIGURE_MY_PI_SETUP_TOOL_NAME)) {
+      resetEpisode();
+      const message =
+        "OpenPI could not find its owned configuration writer. Setup was not started; check for duplicate or mismatched OpenPI extension sources.";
+      if (ctx.hasUI) ctx.ui.notify(message, "error");
+      throw new Error(message);
+    }
+    const requestId = `setup-${++requestSequence}`;
+    pendingRequests.push({ requestId, prompt: prompt.join("\n") });
+    if (episode === "idle") episode = "armed";
+    if (ctx.isIdle() && episode === "armed") dispatchNextRequest(ctx);
   };
 
   pi.registerCommand("openpi-setup", {

package/extensions/shared/activity-status.ts

@@ -1,6 +1,7 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 type Theme = ExtensionContext["ui"]["theme"];
+type StatusUI = Pick<ExtensionContext["ui"], "setStatus">;
 
 export interface ActivityCounts {
   running: number;
@@ -8,8 +9,6 @@ export interface ActivityCounts {
   failed: number;
 }
 
-const SQUARE = "■";
-
 /**
  * Settled work is an unread notice, not a session tally: `done`/`failed` stay
  * visible until the user's next explicit request acknowledges them, while
@@ -44,20 +43,52 @@ export function hasActivity(counts: ActivityCounts) {
   return counts.running + counts.done + counts.failed > 0;
 }
 
+/**
+ * Pi's `setStatus` requests a global render unconditionally, without diffing
+ * the text, so rewriting the same value repaints the whole TUI for nothing.
+ * Managers notify on every child event (streaming text, tools, usage), and in
+ * the TUI the footer line stays `undefined` throughout, so the vast majority of
+ * those writes are no-ops. Keep the last written value and forward only real
+ * changes. The `ui` identity is part of the comparison: a new session hands out
+ * a new object whose footer starts empty, so the first write there must land.
+ */
+export function createStatusWriter(key: string) {
+  let lastUI: StatusUI | undefined;
+  let lastText: string | undefined;
+  return {
+    /** Returns whether the write reached Pi. */
+    write(ui: StatusUI, text: string | undefined) {
+      if (ui === lastUI && text === lastText) return false;
+      lastUI = ui;
+      lastText = text;
+      ui.setStatus(key, text);
+      return true;
+    },
+    /** Forget the cached value so the next write always lands. */
+    reset() {
+      lastUI = undefined;
+      lastText = undefined;
+    },
+  };
+}
+
 export function formatActivityStatus(
   theme: Theme,
   label: "subagents" | "workflows",
   counts: ActivityCounts,
 ) {
+  // No status glyphs here: the footer line is a static string refreshed on
+  // events, so a spinner would freeze between updates — the colored words
+  // carry the state on their own.
   const parts: string[] = [];
   if (counts.running > 0) {
-    parts.push(theme.fg("warning", `${SQUARE} ${counts.running} running`));
+    parts.push(theme.fg("warning", `${counts.running} running`));
   }
   if (counts.done > 0) {
-    parts.push(theme.fg("success", `${SQUARE} ${counts.done} done`));
+    parts.push(theme.fg("success", `${counts.done} done`));
   }
   if (counts.failed > 0) {
-    parts.push(theme.fg("error", `${SQUARE} ${counts.failed} failed`));
+    parts.push(theme.fg("error", `${counts.failed} failed`));
   }
   parts.push(theme.fg("accent", `/${label}`) + theme.fg("dim", " to view"));