@openlines/opl-pi-sht 0.1.19 → 0.1.20

package/README.md

@@ -17,8 +17,8 @@ A portable collection of various Pi coding agent extensions. Repository director
 Install a versioned release from npm or GitHub. Both ship identical content; pick one source per machine, because Pi treats the npm and Git entries as separate packages and installing both loads every extension twice.
 
 ```bash
-pi install npm:@openlines/opl-pi-sht@0.1.18
-pi install git:github.com/linellazatin/opl-pi-sht@v0.1.18
+pi install npm:@openlines/opl-pi-sht@<version>
+pi install git:github.com/linellazatin/opl-pi-sht@<version.tag>
 ```
 
 > Omitting the version on the npm source tracks the latest published release; Git refs stay pinned, so move them with `pi install ...@v<new>`.
@@ -76,7 +76,7 @@ Copy mode overwrites matching destinations. Link mode skips existing destination
 | [`opl-questionnaire`](extensions/opl-questionnaire/README.md) | Interactive structured-choice tool.                                                                                                                                                                                          | `questionnaire`; no config.                                                                                    |
 | [`opl-input`](extensions/opl-input/README.md)                 | Configurable replacement editor - enhanced [pikit chat-input](https://github.com/adrianapan/pikit) (because pet is life, and configurable). ![pet](images/ss-input-pet.png)                                                                                   | No commands/tools;`opl-input.json`.                                                                            |
 | [`opl-modes`](extensions/opl-modes/README.md)                 | Mode, plan, tool-safety, lazy-tool-loading, and active-appearance manager - highly-modified, configrable and enhanced mode-switcher.                                                                                         | `/mode`, `/chat`, `/plan`, `/execute`, `plan_complete`, `load_tools`; `opl-modes.json`.                        |
-| [`opl-footer`](extensions/opl-footer/README.md)               | Configurable multi-row status footer - highly-specialized, and enhanced [pikit footer](https://github.com/adrianapan/pikit).                                                                                                  | No commands/tools;`opl-footer.json`.                                                                           |
+| [`opl-footer`](extensions/opl-footer/README.md)               | Configurable multi-row status footer - highly-specialized, and enhanced [pikit footer](https://github.com/adrianapan/pikit).                                                                                                  | `/configure-opl`; `opl-footer.json`.                                                                           |
 
 ## What you'll gain
 
@@ -120,7 +120,7 @@ Cold prompt-cache write, measured /init session (opl-modes lazy tools + MCP adap
 
 ### See what the agent is doing
 
-- **`opl-footer`** surfaces model, cost, token and cache activity, git state, and per-turn timing in a configurable multi-row footer.
+- **`opl-footer`** surfaces model, cost, token and cache activity, git state, agent status, and per-turn timing in a configurable multi-row footer; `/configure-opl` edits and reorders its layout interactively.
 - **`opl-input`** is a configurable editor that reflects the active mode's identity, so you always know which mode you are typing into.
 ![input-footer](images/ss-input-footer.png)
 
@@ -186,7 +186,7 @@ Copy applicable files from [`configs/`](configs/) to `~/.pi/agent/configs/`. For
 - `opl-init` and `opl-questionnaire` have no external configuration.
 - Config files must be valid JSON, with no comments or trailing commas beyond deliberate `_comment` keys.
 - `opl-modes` owns active-mode appearance. Each mode's `appearance.prefix`, `prefixColor`, and `borderColor` style `opl-input`; `appearance.modeColor` styles `opl-footer`'s unified mode label. Renderers retain hardcoded fallbacks.
-  - `opl-modes.bashPatterns` is the shared read-only Bash policy now applied to every mode by default; a mode overrides it with its own `safePatterns`/`destructivePatterns` or disables it with `unrestrictedBash: true`.
+  - `opl-modes.bashPatterns` is the shared read-only Bash policy now applied to every mode by default; a mode overrides it with its own valid `safePatterns`/`destructivePatterns` array, an empty array explicitly removes that policy, or `unrestrictedBash: true` disables both gates. Malformed per-mode arrays retain the existing policy.
   - `opl-modes.lazyTools` withholds heavy tool schemas (e.g. `subagent`, `browser`, `simplebench`) from the resting prefix and enables them on demand via `load_tools`, shrinking the per-session prompt-cache write.
 
 See each extension README for commands, behavior, configuration fields, runtime constraints, and architecture.

package/configs/opl-footer.json.sample

@@ -1,20 +1,39 @@
 {
-  "_comment": "Available segment IDs: pi, model, path, git, thinking, caveman, plan_mode, chat_mode, mode_switcher, separator, token_in, token_out, token_total, cache_read, cache_write, cost, context_pct, context_total, session_stats, perf_stats, text:<literal>",
-  "row1LeftSegments": ["pi", "separator", "model", "separator", "path", "git"],
-  "row1RightSegments": ["context_pct"],
+  "_comment": "Available segment IDs: pi, model, path, git, thinking, caveman, plan_mode, chat_mode, mode_switcher, separator, token_in, token_out, token_total, cache_read, cache_write, cost, context_pct, context_total, session_stats, perf_stats, status, text:<literal>",
+  "row1LeftSegments": [
+    "pi",
+    "separator",
+    "model",
+    "separator",
+    "path",
+    "git"
+  ],
+  "row1RightSegments": [
+    "context_pct"
+  ],
   "row2LeftSegments": [
     "thinking",
     "separator",
     "mode_switcher"
   ],
-  "row2RightSegments": ["token_total", "separator", "cost"],
-  "row3LeftSegments": ["session_stats"],
-  "row3RightSegments": ["perf_stats"],
+  "row2RightSegments": [
+    "token_total",
+    "separator",
+    "cost"
+  ],
+  "row3LeftSegments": [
+    "session_stats"
+  ],
+  "row3RightSegments": [
+    "perf_stats",
+    "cache_read",
+    "cache_write"
+  ],
   "icons": {
-    "pi": "\ue22c",
-    "folder": "\uf115",
-    "branch": "\uf126",
-    "git": "\uf1d3",
+    "pi": "󰏿",
+    "folder": "",
+    "branch": "",
+    "git": "",
     "separator": "|"
   },
   "colors": {

package/configs/opl-modes.json.sample

@@ -91,6 +91,7 @@
   "_comment_tools": "Set modes.chat.tools or modes.plan.tools to replace their default tools. The legacy top-level chatAllowedTools and planAllowedTools keys remain supported but are deprecated.",
   "_comment_widgetColor": "available colors - accent, border, borderAccent, borderMuted, success, error, warning, muted, dim, text, thinkingText, searchMatchText, userMessageText, customMessageText, customMessageLabel, toolTitle, toolOutput, mdHeading, mdLink, mdLinkUrl, mdCode, mdCodeBlock, mdCodeBlockBorder, mdQuote, mdQuoteBorder, mdHr, mdListBullet, toolDiffAdded, toolDiffRemoved, toolDiffContext, syntaxComment, syntaxKeyword, syntaxFunction, syntaxVariable, syntaxString, syntaxNumber, syntaxType, syntaxOperator, syntaxPunctuation, thinkingOff, thinkingMinimal, thinkingLow, thinkingMedium, thinkingHigh, thinkingXhigh, thinkingMax, bashMode",
   "_comment_appearance": "Every mode owns appearance here. prefix/prefixColor/borderColor style opl-input; modeColor styles opl-footer's Mode value. All color values accept Pi theme tokens or #RRGGBB.",
+  "_comment_modePatterns": "Per-mode safePatterns/destructivePatterns must be arrays of valid regex strings. [] explicitly removes that policy; any malformed non-empty override is ignored and inherits the existing policy.",
   "modes": {
     "off": {
       "_comment": "Built-in mode — no restrictions, normal agent behavior.",

package/extensions/opl-footer/README.md

@@ -1,10 +1,10 @@
 # opl-footer
 
-A customizable three-row footer for the Pi coding agent. It shows model, path, Git, context, thinking, mode, token, cost, session, and performance information in configurable left/right segments.
+A customizable three-row footer for the Pi coding agent. It shows model, path, Git, context, thinking, mode, token, cost, agent status, session, and performance information in configurable left/right segments.
 
 ## Commands, flags, and shortcuts
 
-No commands, flags, or shortcuts. Nerd Font detection can be overridden with `FOOTER_NERD_FONTS=1` or `FOOTER_NERD_FONTS=0`.
+`/configure-opl` provides six row/side tabs to toggle or reorder standard segments and their trailing separators, applying changes immediately. Press `r` for reorder view, then `,`/`.` to move the selected segment. The `status` segment shows `Working` during agent execution, `Waiting` while Pi tools run, and `Ready` when the agent settles. Colors, icons, literal text, and other options remain JSON-only. Nerd Font detection can be overridden with `FOOTER_NERD_FONTS=1` or `FOOTER_NERD_FONTS=0`.
 
 ## Extension features
 
@@ -33,7 +33,7 @@ The third row is populated after the first completed turn. Its session and perfo
 - **Token and cost tracking**: total, cache, input/output, and accumulated cost segments
 - **Session statistics**: prompt, API-call, and model tool-call counts
 - **Performance statistics**: cumulative LLM/tool duration, most recent user-prompt-to-completion turnaround time, average time to first token, output rate, and cache-hit percentage
-- **Thinking and mode indicators**: thinking-level colors plus caveman, plan, chat, or unified mode segments when available
+- **Thinking, mode, and status indicators**: thinking-level colors plus caveman, plan, chat, unified mode, and `Working`/`Waiting`/`Ready` status segments
 - **Nerd Font support**: automatic detection with plain-icon fallbacks
 - **Live updates**: branch changes and session events request footer re-rendering
 
@@ -64,7 +64,7 @@ See the tracked [`configs/opl-footer.json.sample`](../../configs/opl-footer.json
 
 | Segment | Description | Notes |
 |---------|-------------|-------|
-| `pi` | π symbol in accent blue | — |
+| `pi` | π symbol in accent blue | `pi` icon can be modified in config file |
 | `model` | Model name in pink + `(provider)` in dim | No icon; provider omitted if unavailable |
 | `path` | Current working directory | `segmentOptions.path.mode`: `"full"` (default) · `"abbreviated"` · `"basename"` |
 | `git` | Git branch and dirty indicators | `showBranch`, `showStaged`, `showUnstaged`, `showUntracked` (all bool) |
@@ -81,6 +81,9 @@ See the tracked [`configs/opl-footer.json.sample`](../../configs/opl-footer.json
 | `cache_read` | Cache read tokens (hidden if zero) | — |
 | `cache_write` | Cache write tokens (hidden if zero) | — |
 | `context_total` | Total context window size | — |
+| `session_stats` | Prompt, API-call, and tool-call counts | Hidden until the first prompt |
+| `perf_stats` | LLM/tool timing, TTFT, output rate, and cache-hit percentage | Hidden until the first prompt |
+| `status` | `Working`, `Waiting`, or `Ready` | `accent`, `warning`, and `success` theme colors respectively; optional and hidden by default |
 | `separator` | `\|` divider | Coloured via `separator` in `colors` |
 | `text:...` | Literal text, e.g. `text:⚡` | — |
 
@@ -156,6 +159,8 @@ The `session_stats` segment shows prompt, API-call, and model tool-call counts f
 
 The `perf_stats` segment shows cumulative session LLM and tool time, average time to first token, output tokens/sec, and cache-hit percentage. The `LLM` figure is followed by the most recent user-prompt-to-completion turnaround time in parentheses, e.g. `LLM 18m 22s (2m 13s)`. This turnaround reflects only fully-settled turns (the `agent_settled` signal, after any retries or compaction), so it stays blank until the first turn completes. All `perf_stats` timing values are ephemeral — they reset each session and are not reconstructed from branch history.
 
+The `status` segment is `Working` while the agent runs, `Waiting` while one or more Pi tools execute, and `Ready` only after `agent_settled`.
+
 ## Icons
 
 Nerd Font icons are auto-detected from your terminal. Ghostty, WezTerm, Kitty, iTerm2, Alacritty, Foot, Rio, and Contour are recognised automatically — everything else falls back to plain Unicode symbols. If detection gets it wrong (e.g. when running inside tmux), override it:

package/extensions/opl-footer/config.ts

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import type { FooterUserConfig, StatusLineSegmentId, ColorScheme, StatusLineSegmentOptions } from "./types.js";
 import { getDefaultColors } from "./theme.js";
 import type { IconSet } from "./icons.js";
@@ -12,6 +12,33 @@ const DEFAULT_ROW2_RIGHT: StatusLineSegmentId[] = ["token_total", "separator", "
 const DEFAULT_ROW3_LEFT: StatusLineSegmentId[] = ["session_stats"];
 const DEFAULT_ROW3_RIGHT: StatusLineSegmentId[] = ["perf_stats"];
 
+export type FooterLayoutKey =
+  | "row1LeftSegments" | "row1RightSegments"
+  | "row2LeftSegments" | "row2RightSegments"
+  | "row3LeftSegments" | "row3RightSegments";
+
+export const FOOTER_LAYOUT_KEYS: FooterLayoutKey[] = [
+  "row1LeftSegments", "row1RightSegments",
+  "row2LeftSegments", "row2RightSegments",
+  "row3LeftSegments", "row3RightSegments",
+];
+
+export const CONFIGURABLE_SEGMENTS: StatusLineSegmentId[] = [
+  "pi", "model", "path", "git", "thinking", "caveman", "plan_mode",
+  "chat_mode", "mode_switcher", "token_in", "token_out", "token_total",
+  "cache_read", "cache_write", "cost", "context_pct", "context_total",
+  "session_stats", "perf_stats", "status",
+];
+
+const DEFAULT_LAYOUTS: Record<FooterLayoutKey, StatusLineSegmentId[]> = {
+  row1LeftSegments: DEFAULT_ROW1_LEFT,
+  row1RightSegments: DEFAULT_ROW1_RIGHT,
+  row2LeftSegments: DEFAULT_ROW2_LEFT,
+  row2RightSegments: DEFAULT_ROW2_RIGHT,
+  row3LeftSegments: DEFAULT_ROW3_LEFT,
+  row3RightSegments: DEFAULT_ROW3_RIGHT,
+};
+
 const DEFAULT_SEGMENT_OPTIONS: StatusLineSegmentOptions = {
   path: { mode: "full" },
   git: {
@@ -61,6 +88,102 @@ export function clearUserConfigCache(): void {
   userConfigCacheTime = 0;
 }
 
+export function getLayoutSegments(config: FooterUserConfig, key: FooterLayoutKey): StatusLineSegmentId[] {
+  const segments = config[key];
+  return Array.isArray(segments) && segments.every((segment) => typeof segment === "string")
+    ? segments
+    : DEFAULT_LAYOUTS[key];
+}
+
+export function hasSegmentSeparator(
+  config: FooterUserConfig,
+  key: FooterLayoutKey,
+  segment: StatusLineSegmentId,
+): boolean {
+  const layout = getLayoutSegments(config, key);
+  const index = layout.indexOf(segment);
+  return index !== -1 && layout[index + 1] === "separator";
+}
+
+export function setLayoutSegment(
+  config: FooterUserConfig,
+  key: FooterLayoutKey,
+  segment: StatusLineSegmentId,
+  shown: boolean,
+): FooterUserConfig {
+  const current = getLayoutSegments(config, key);
+  const index = current.indexOf(segment);
+  if (shown && index !== -1) return config;
+
+  const next = [...current];
+  if (!shown) {
+    if (index === -1) return config;
+    next.splice(index, 1);
+    if (next[index] === "separator") next.splice(index, 1);
+    return { ...config, [key]: next };
+  }
+
+  const order = CONFIGURABLE_SEGMENTS.indexOf(segment);
+  const insertAt = next.findIndex((item) => CONFIGURABLE_SEGMENTS.indexOf(item) > order);
+  next.splice(insertAt === -1 ? next.length : insertAt, 0, segment);
+  return { ...config, [key]: next };
+}
+
+export function moveLayoutSegment(
+  config: FooterUserConfig,
+  key: FooterLayoutKey,
+  segment: StatusLineSegmentId,
+  direction: "up" | "down",
+): FooterUserConfig {
+  const current = getLayoutSegments(config, key);
+  const start = current.indexOf(segment);
+  if (start === -1) return config;
+
+  const end = start + (current[start + 1] === "separator" ? 2 : 1);
+  if (direction === "up") {
+    let previousStart = start - 1;
+    if (current[previousStart] === "separator") previousStart--;
+    if (previousStart < 0 || !CONFIGURABLE_SEGMENTS.includes(current[previousStart]!)) return config;
+    return {
+      ...config,
+      [key]: [...current.slice(0, previousStart), ...current.slice(start, end), ...current.slice(previousStart, start), ...current.slice(end)],
+    };
+  }
+
+  const nextStart = end;
+  if (!CONFIGURABLE_SEGMENTS.includes(current[nextStart]!)) return config;
+  const nextEnd = nextStart + (current[nextStart + 1] === "separator" ? 2 : 1);
+  return {
+    ...config,
+    [key]: [...current.slice(0, start), ...current.slice(nextStart, nextEnd), ...current.slice(start, end), ...current.slice(nextEnd)],
+  };
+}
+
+export function setSegmentSeparator(
+  config: FooterUserConfig,
+  key: FooterLayoutKey,
+  segment: StatusLineSegmentId,
+  shown: boolean,
+): FooterUserConfig {
+  const current = getLayoutSegments(config, key);
+  const index = current.indexOf(segment);
+  if (index === -1) return config;
+  const hasSeparator = current[index + 1] === "separator";
+  if (shown === hasSeparator) return config;
+
+  const next = [...current];
+  if (shown) next.splice(index + 1, 0, "separator");
+  else next.splice(index + 1, 1);
+  return { ...config, [key]: next };
+}
+
+export function saveUserConfig(config: FooterUserConfig): void {
+  const configPath = getConfigPath();
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  clearUserConfigCache();
+}
+
 export function getEffectiveConfig(): {
   row1LeftSegments: StatusLineSegmentId[];
   row1RightSegments: StatusLineSegmentId[];
@@ -75,12 +198,12 @@ export function getEffectiveConfig(): {
   const userConfig = loadUserConfig();
 
   return {
-    row1LeftSegments: userConfig?.row1LeftSegments ?? DEFAULT_ROW1_LEFT,
-    row1RightSegments: userConfig?.row1RightSegments ?? DEFAULT_ROW1_RIGHT,
-    row2LeftSegments: userConfig?.row2LeftSegments ?? DEFAULT_ROW2_LEFT,
-    row2RightSegments: userConfig?.row2RightSegments ?? DEFAULT_ROW2_RIGHT,
-    row3LeftSegments: userConfig?.row3LeftSegments ?? DEFAULT_ROW3_LEFT,
-    row3RightSegments: userConfig?.row3RightSegments ?? DEFAULT_ROW3_RIGHT,
+    row1LeftSegments: getLayoutSegments(userConfig ?? {}, "row1LeftSegments"),
+    row1RightSegments: getLayoutSegments(userConfig ?? {}, "row1RightSegments"),
+    row2LeftSegments: getLayoutSegments(userConfig ?? {}, "row2LeftSegments"),
+    row2RightSegments: getLayoutSegments(userConfig ?? {}, "row2RightSegments"),
+    row3LeftSegments: getLayoutSegments(userConfig ?? {}, "row3LeftSegments"),
+    row3RightSegments: getLayoutSegments(userConfig ?? {}, "row3RightSegments"),
     colors: userConfig?.colors ?? getDefaultColors(),
     segmentOptions: {
       ...DEFAULT_SEGMENT_OPTIONS,

package/extensions/opl-footer/configure-navigation.ts

@@ -0,0 +1,13 @@
+export function nextTabIndex(activeTab: number, direction: "left" | "right", count: number): number {
+  return direction === "left"
+    ? (activeTab + count - 1) % count
+    : (activeTab + 1) % count;
+}
+
+export function restoreSelectedItem(
+  lists: Array<{ selectItem(id: string): void }>,
+  activeTab: number,
+  id: string,
+): void {
+  lists[activeTab]?.selectItem(id);
+}

package/extensions/opl-footer/configure.ts

@@ -0,0 +1,157 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, SettingsList, truncateToWidth, type SettingItem } from "@earendil-works/pi-tui";
+
+import {
+  CONFIGURABLE_SEGMENTS,
+  FOOTER_LAYOUT_KEYS,
+  getLayoutSegments,
+  hasSegmentSeparator,
+  loadUserConfig,
+  moveLayoutSegment,
+  saveUserConfig,
+  setLayoutSegment,
+  setSegmentSeparator,
+  type FooterLayoutKey,
+} from "./config.js";
+import { nextTabIndex, restoreSelectedItem } from "./configure-navigation.js";
+
+const LAYOUT_LABELS: Record<FooterLayoutKey, string> = {
+  row1LeftSegments: "Row 1 left",
+  row1RightSegments: "Row 1 right",
+  row2LeftSegments: "Row 2 left",
+  row2RightSegments: "Row 2 right",
+  row3LeftSegments: "Row 3 left",
+  row3RightSegments: "Row 3 right",
+};
+
+function segmentLabel(segment: string): string {
+  return segment.replaceAll("_", " ");
+}
+
+export async function showFooterConfigurator(ctx: ExtensionContext, onSaved: () => void): Promise<void> {
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify("/configure-opl requires TUI mode", "error");
+    return;
+  }
+
+  let config = loadUserConfig() ?? {};
+  await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+    let activeTab = 0;
+    let view: "settings" | "reorder" = "settings";
+    let reorderIndex = 0;
+    let settingsLists: SettingsList[] = [];
+
+    const persist = (next: typeof config, selectedId?: string): boolean => {
+      try {
+        saveUserConfig(next);
+        config = next;
+        settingsLists = createSettingsLists();
+        if (selectedId) restoreSelectedItem(settingsLists, activeTab, selectedId);
+        onSaved();
+        return true;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(`Could not save footer config: ${message}`, "error");
+        done(undefined);
+        return false;
+      }
+    };
+
+    const save = (id: string, value: string) => {
+      const [key, segment, kind] = id.split(":") as [FooterLayoutKey, typeof CONFIGURABLE_SEGMENTS[number], string];
+      const next = kind === "separator"
+        ? setSegmentSeparator(config, key, segment, value === "shown")
+        : setLayoutSegment(config, key, segment, value === "shown");
+      persist(next, id);
+    };
+
+    const createSettingsLists = (): SettingsList[] => FOOTER_LAYOUT_KEYS.map((key) => {
+      const layout = getLayoutSegments(config, key);
+      const items: SettingItem[] = CONFIGURABLE_SEGMENTS.flatMap((segment) => {
+        const index = layout.indexOf(segment);
+        return [
+          {
+            id: `${key}:${segment}:segment`,
+            label: segmentLabel(segment),
+            currentValue: index === -1 ? "hidden" : "shown",
+            values: ["shown", "hidden"],
+          },
+          {
+            id: `${key}:${segment}:separator`,
+            label: `${segmentLabel(segment)} separator`,
+            currentValue: hasSegmentSeparator(config, key, segment) ? "shown" : "hidden",
+            values: ["shown", "hidden"],
+          },
+        ];
+      });
+      return new SettingsList(items, 15, getSettingsListTheme(), save, () => done(undefined));
+    });
+
+    const visibleSegments = (): typeof CONFIGURABLE_SEGMENTS[number][] =>
+      getLayoutSegments(config, FOOTER_LAYOUT_KEYS[activeTab]!).filter((segment) => CONFIGURABLE_SEGMENTS.includes(segment));
+
+    settingsLists = createSettingsLists();
+
+    return {
+      render(width: number) {
+        const tabs = FOOTER_LAYOUT_KEYS.map((key, index) =>
+          theme.fg(index === activeTab ? "accent" : "dim", `[${LAYOUT_LABELS[key]}]`),
+        ).join(" ");
+        const header = [
+          truncateToWidth(theme.bold("Configure OPL Footer"), width),
+          truncateToWidth(tabs, width),
+        ];
+        if (view === "settings") {
+          return [
+            ...header,
+            truncateToWidth(theme.fg("dim", "←/→ switch layout · r reorder · Changes apply immediately"), width),
+            ...settingsLists[activeTab]!.render(width),
+          ];
+        }
+
+        const segments = visibleSegments();
+        reorderIndex = Math.min(reorderIndex, Math.max(0, segments.length - 1));
+        const rows = segments.length === 0
+          ? [theme.fg("dim", "No visible standard segments.")]
+          : segments.map((segment, index) => {
+            const text = `${index === reorderIndex ? "›" : " "} ${segmentLabel(segment)}${hasSegmentSeparator(config, FOOTER_LAYOUT_KEYS[activeTab]!, segment) ? " + separator" : ""}`;
+            return index === reorderIndex ? theme.fg("accent", text) : text;
+          });
+        return [
+          ...header,
+          truncateToWidth(theme.fg("dim", "↑/↓ select · ,/. move · r settings · esc close"), width),
+          ...rows.map((row) => truncateToWidth(row, width)),
+        ];
+      },
+      invalidate() { settingsLists.forEach((list) => list.invalidate()); },
+      handleInput(data: string) {
+        if (matchesKey(data, Key.left)) {
+          activeTab = nextTabIndex(activeTab, "left", FOOTER_LAYOUT_KEYS.length);
+          reorderIndex = 0;
+        } else if (matchesKey(data, Key.right)) {
+          activeTab = nextTabIndex(activeTab, "right", FOOTER_LAYOUT_KEYS.length);
+          reorderIndex = 0;
+        } else if (view === "reorder") {
+          const segments = visibleSegments();
+          if (data === "r") view = "settings";
+          else if (matchesKey(data, Key.escape)) done(undefined);
+          else if (matchesKey(data, Key.up) && segments.length > 0) reorderIndex = (reorderIndex + segments.length - 1) % segments.length;
+          else if (matchesKey(data, Key.down) && segments.length > 0) reorderIndex = (reorderIndex + 1) % segments.length;
+          else if ((data === "," || data === ".") && segments[reorderIndex]) {
+            const next = moveLayoutSegment(config, FOOTER_LAYOUT_KEYS[activeTab]!, segments[reorderIndex]!, data === "," ? "up" : "down");
+            if (next !== config && persist(next)) {
+              reorderIndex = data === "," ? Math.max(0, reorderIndex - 1) : Math.min(segments.length - 1, reorderIndex + 1);
+            }
+          }
+        } else if (data === "r") {
+          view = "reorder";
+          reorderIndex = 0;
+        } else {
+          settingsLists[activeTab]!.handleInput?.(data);
+        }
+        tui.requestRender();
+      },
+    };
+  });
+}

package/extensions/opl-footer/index.ts

@@ -5,10 +5,12 @@ import type { TUI } from "@earendil-works/pi-tui";
 
 import type { SegmentContext, StatusLineSegmentId, UsageStats, SessionStats, SessionEvent, ThinkingLevelEvent, AssistantMessageEvent, ToolResultEvent, UserBashEvent } from "./types.js";
 import { renderSegment } from "./segments/index.js";
+import { createAgentStatusTracker } from "./segments/status.js";
 import { getGitStatus, invalidateGitStatus, invalidateGitBranch } from "./git-status.js";
 import { getEffectiveConfig } from "./config.js";
 import { getIcons } from "./icons.js";
 import { getDefaultColors, fg } from "./theme.js";
+import { showFooterConfigurator } from "./configure.js";
 
 const GIT_BRANCH_PATTERNS: RegExp[] = [
   /\bgit\s+(checkout|switch|branch\s+-[dDmM]|merge|rebase|pull|reset|worktree)/,
@@ -112,8 +114,16 @@ export default function footer(pi: ExtensionAPI) {
   let ttftRecordedThisTurn = false;
   let agentStartMs = 0;
   let lastTurnaroundMs = 0;
+  let statusTracker = createAgentStatusTracker();
   const toolStartTimes = new Map<string, number>();
 
+  pi.registerCommand("configure-opl", {
+    description: "Interactively configure the OPL footer layout",
+    handler: async (_args, ctx) => {
+      await showFooterConfigurator(ctx, () => tuiRef?.requestRender());
+    },
+  });
+
   // Track session start
   pi.on("session_start", async (_event: unknown, ctx: ExtensionContext) => {
     sessionStartTime = Date.now();
@@ -128,6 +138,7 @@ export default function footer(pi: ExtensionAPI) {
     ttftRecordedThisTurn = false;
     agentStartMs = 0;
     lastTurnaroundMs = 0;
+    statusTracker = createAgentStatusTracker();
     toolStartTimes.clear();
 
     if (ctx.hasUI) {
@@ -141,6 +152,8 @@ export default function footer(pi: ExtensionAPI) {
   // authoritative "fully done, no auto-continuation" signal.
   pi.on("agent_start", async (_event: unknown, _ctx: ExtensionContext) => {
     if (agentStartMs === 0) agentStartMs = Date.now();
+    statusTracker.agentStarted();
+    tuiRef?.requestRender();
   });
 
   pi.on("agent_settled", async (_event: unknown, _ctx: ExtensionContext) => {
@@ -148,6 +161,8 @@ export default function footer(pi: ExtensionAPI) {
       lastTurnaroundMs = Date.now() - agentStartMs;
       agentStartMs = 0;
     }
+    statusTracker.agentSettled();
+    tuiRef?.requestRender();
   });
 
   pi.on("turn_start", async (_event: unknown, _ctx: ExtensionContext) => {
@@ -163,6 +178,8 @@ export default function footer(pi: ExtensionAPI) {
 
   pi.on("tool_execution_start", async (event: { toolCallId: string }, _ctx: ExtensionContext) => {
     toolStartTimes.set(event.toolCallId, Date.now());
+    statusTracker.toolStarted(event.toolCallId);
+    tuiRef?.requestRender();
   });
 
   pi.on("tool_execution_end", async (event: { toolCallId: string }, _ctx: ExtensionContext) => {
@@ -173,6 +190,8 @@ export default function footer(pi: ExtensionAPI) {
       toolMsThisTurn += elapsed;
       toolStartTimes.delete(event.toolCallId);
     }
+    statusTracker.toolEnded(event.toolCallId);
+    tuiRef?.requestRender();
   });
 
   pi.on("message_update", async (_event: unknown, _ctx: ExtensionContext) => {
@@ -298,6 +317,7 @@ export default function footer(pi: ExtensionAPI) {
       colors,
       icons: getIcons(effectiveConfig.icons),
       sessionStats: { prompts: branchPrompts, apiCalls: branchApiCalls, toolCalls: branchToolCalls, llmMs, toolMs, ttftSamples, lastTurnaroundMs },
+      agentStatus: statusTracker.status(),
     };
   }
 

package/extensions/opl-footer/segments/index.ts

@@ -13,6 +13,7 @@ import { planModeSegment } from "./plan-mode.js";
 import { chatModeSegment } from "./chat-mode.js";
 import { modeSwitcherSegment } from "./mode-switcher.js";
 import { sessionStatsSegment, perfStatsSegment } from "./session-stats.js";
+import { statusSegment } from "./status.js";
 
 const SEGMENTS = {
   pi: piSegment,
@@ -35,6 +36,7 @@ const SEGMENTS = {
   mode_switcher: modeSwitcherSegment,
   session_stats: sessionStatsSegment,
   perf_stats: perfStatsSegment,
+  status: statusSegment,
 };
 
 export function renderSegment(id: StatusLineSegmentId, ctx: SegmentContext): RenderedSegment {

package/extensions/opl-footer/segments/status.ts

@@ -0,0 +1,37 @@
+import type { AgentStatus, RenderedSegment, SegmentContext } from "../types.js";
+import { applyColor } from "../theme.js";
+
+export function deriveAgentStatus(agentActive: boolean, activeToolCount: number): AgentStatus {
+  if (!agentActive) return "ready";
+  return activeToolCount > 0 ? "waiting" : "working";
+}
+
+export function createAgentStatusTracker() {
+  let agentActive = false;
+  const activeToolIds = new Set<string>();
+
+  return {
+    agentStarted() { agentActive = true; },
+    agentSettled() {
+      agentActive = false;
+      activeToolIds.clear();
+    },
+    toolStarted(id: string) { activeToolIds.add(id); },
+    toolEnded(id: string) { activeToolIds.delete(id); },
+    status() { return deriveAgentStatus(agentActive, activeToolIds.size); },
+  };
+}
+
+const STATUS_DISPLAY = {
+  working: ["Working", "accent"],
+  waiting: ["Waiting", "warning"],
+  ready: ["Ready", "success"],
+} as const;
+
+export const statusSegment = {
+  id: "status" as const,
+  render(ctx: SegmentContext): RenderedSegment {
+    const [label, color] = STATUS_DISPLAY[ctx.agentStatus];
+    return { content: applyColor(ctx.theme, color, label), visible: true };
+  },
+};

package/extensions/opl-footer/segments/tokens.ts

@@ -52,7 +52,7 @@ export const cacheReadSegment = {
   render(ctx: SegmentContext): RenderedSegment {
     const { cacheRead } = ctx.usageStats;
     if (!cacheRead) return { content: "", visible: false };
-    return { content: val(ctx, formatTokens(cacheRead)), visible: true };
+    return { content: lbl(ctx, "Read ") + val(ctx, formatTokens(cacheRead)), visible: true };
   },
 };
 
@@ -61,6 +61,6 @@ export const cacheWriteSegment = {
   render(ctx: SegmentContext): RenderedSegment {
     const { cacheWrite } = ctx.usageStats;
     if (!cacheWrite) return { content: "", visible: false };
-    return { content: val(ctx, formatTokens(cacheWrite)), visible: true };
+    return { content: lbl(ctx, "Write ") + val(ctx, formatTokens(cacheWrite)), visible: true };
   },
 };

package/extensions/opl-footer/types.ts

@@ -53,6 +53,7 @@ export type StatusLineSegmentId =
   | "mode_switcher"
   | "session_stats"
   | "perf_stats"
+  | "status"
   | "separator"
   | `text:${string}`;
 
@@ -109,6 +110,8 @@ export interface SessionStats {
 }
 
 // Context passed to segment render functions
+export type AgentStatus = "working" | "waiting" | "ready";
+
 export interface SegmentContext {
   model: { id: string; name?: string; reasoning?: boolean; contextWindow?: number; provider?: string; baseUrl?: string } | undefined;
   isLocalModel: boolean;
@@ -126,6 +129,7 @@ export interface SegmentContext {
   colors: ColorScheme;
   icons: IconSet;
   sessionStats: SessionStats;
+  agentStatus: AgentStatus;
 }
 
 // Minimal event shapes used by the opl-footer handlers

package/extensions/opl-input/README.md

@@ -80,4 +80,4 @@ Invalid theme tokens fall back to the theme's `border` token; invalid hex render
 
 ## Architecture
 
-`index.ts` installs the editor integration; `mode-style.ts` resolves Bash > published mode appearance > compiled fallback; `config.ts` loads editor and companion settings; and `utils.ts` handles color and rendering helpers. `opl-modes` is the sole publisher of active mode appearance through `globalThis.__agentMode`.
+`index.ts` installs the editor integration and disposes companion render timers on editor replacement or session shutdown; `mode-style.ts` resolves Bash > published mode appearance > compiled fallback; `config.ts` loads editor and companion settings; and `utils.ts` handles color and rendering helpers. `opl-modes` is the sole publisher of active mode appearance through `globalThis.__agentMode`.

package/extensions/opl-input/index.ts

@@ -4,7 +4,7 @@ import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { CONFIG, COMPANION_PADDING, MIN_WIDTH_FOR_COMPANION } from "./config.js";
 import { resolveModeStyle, type ModeAppearance } from "./mode-style.js";
-import { applyColor, CompanionAnimator } from "./utils.js";
+import { applyColor, CompanionAnimator, startRenderTimer } from "./utils.js";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 const ANSI_RE = /\x1b\[[0-9;]*m|\x1b\[0?m/g;
@@ -28,7 +28,7 @@ class ChatInput extends CustomEditor {
 	private uiTheme: Theme;
 	private inputTheme: EditorTheme;
 	private animator = new CompanionAnimator();
-	private companionTimer: ReturnType<typeof setInterval> | null = null;
+	private stopCompanionTimer: (() => void) | null = null;
 
 	constructor(
 		tui: TUI,
@@ -43,10 +43,15 @@ class ChatInput extends CustomEditor {
 		this.inputTheme = theme;
 
 		// Animate companion even when idle — tick drives state machine
-		this.companionTimer = setInterval(() => {
+		this.stopCompanionTimer = startRenderTimer(() => {
 			this.animator.tick(Date.now());
 			this.tui.requestRender();
-		}, 100);
+		});
+	}
+
+	dispose(): void {
+		this.stopCompanionTimer?.();
+		this.stopCompanionTimer = null;
 	}
 
 	private isBashMode(): boolean {
@@ -275,10 +280,21 @@ class ChatInput extends CustomEditor {
 
 // ─── Extension entry ──────────────────────────────────────────────────────
 export default function (pi: ExtensionAPI) {
+	let activeEditor: ChatInput | null = null;
+
 	pi.on("session_start", async (_event, ctx) => {
+		activeEditor?.dispose();
+		activeEditor = null;
 		ctx.ui.setEditorComponent((tui: TUI, theme: EditorTheme, kb: KeybindingsManager) => {
+			activeEditor?.dispose();
 			const companionColorFn = (s: string) => applyColor(ctx.ui.theme, CONFIG.COMPANION_COLOR, s);
-			return new ChatInput(tui, theme, kb, companionColorFn, ctx.ui.theme);
+			activeEditor = new ChatInput(tui, theme, kb, companionColorFn, ctx.ui.theme);
+			return activeEditor;
 		});
 	});
-}
+
+	pi.on("session_shutdown", async () => {
+		activeEditor?.dispose();
+		activeEditor = null;
+	});
+}

package/extensions/opl-input/utils.ts

@@ -56,6 +56,11 @@ function hexToAnsi(hex: string): string {
 	return `\x1b[38;2;${r};${g};${b}m`;
 }
 
+export function startRenderTimer(render: () => void): () => void {
+	const timer = setInterval(render, 100);
+	return () => clearInterval(timer);
+}
+
 export function applyColor(theme: Theme, color: string, text: string): string {
 	if (isHexColor(color)) {
 		return `${hexToAnsi(color)}${text}\x1b[0m`;

package/extensions/opl-modes/README.md

@@ -17,7 +17,7 @@ Plans are Markdown files under `.pi/plans/` with the `plan-` filename prefix. `p
 
 ### Mode behavior
 
-Chat and plan modes replace the active tools with configurable read-only tool lists and restrict Bash to safe inspection patterns. Destructive patterns are checked even when a command matches a safe pattern. User-provided safe and destructive pattern arrays replace the built-in lists, rather than extending them.
+Chat and plan modes replace the active tools with configurable read-only tool lists and restrict Bash to safe inspection patterns. Destructive patterns are checked even when a command matches a safe pattern. Valid user-provided safe and destructive pattern arrays replace the built-in lists, rather than extending them. An explicit empty per-mode array replaces that policy with none; a malformed non-empty per-mode array is ignored and inherits the existing policy.
 
 The shared destructive base also blocks file mutation primitives (`rm`, `find -delete`/`-exec`, `truncate`, `git clean`/`update-ref`/`tag -d`, `sudo`, shell spawns, and output redirects). `env` and `printenv` are no longer safe-listed, since they could dump provider API keys into the model context. Destructive matching also runs against a quote/backslash-stripped command skeleton, so `r"m"` cannot dodge `\brm\b`; this is still a heuristic backstop, not a process-isolation boundary.
 
@@ -108,7 +108,7 @@ Use `modes.<name>.appearance` to keep any mode's visual identity with its defini
 
 `prefix`, `prefixColor`, and `borderColor` style `opl-input`; omitted fields use its compiled mode defaults. `modeColor` styles the value in `opl-footer`'s `mode_switcher` segment; if omitted, the footer uses hardcoded `muted`. Colors accept Pi theme tokens or six-digit hex strings.
 
-Model overrides are resolved through Pi's model registry when entering a mode and the previously active model is restored on exit when applicable. Use Pi theme color tokens for widget label colors.
+Model overrides are resolved through Pi's model registry when entering a mode and the previously active model is restored on exit when applicable. Changes are serialized, so a rapid mode exit cannot leave a superseded mode model active. Use Pi theme color tokens for widget label colors.
 
 ### Lazy tool loading
 

package/extensions/opl-modes/config.ts

@@ -3,7 +3,7 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import type { ModeSwitcherUserConfig, ModeDefinition } from "./types.js";
+import type { ModeSwitcherUserConfig, ModeDefinition, PartialModeDefinition } from "./types.js";
 
 // ─── Plan File Constants ────────────────────────────────────────────────────
 
@@ -208,10 +208,14 @@ const DEFAULT_CONFIG = {
 
 const CONFIG_PATH = join(homedir(), ".pi", "agent", "configs", "opl-modes.json");
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 export function loadUserConfig(path = CONFIG_PATH): ModeSwitcherUserConfig {
   try {
-    const raw = readFileSync(path, "utf8");
-    return JSON.parse(raw) as ModeSwitcherUserConfig;
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return isRecord(parsed) ? parsed as ModeSwitcherUserConfig : {};
   } catch {
     return {};
   }
@@ -357,10 +361,21 @@ export const USER_CONFIG = {
 /** Mode Registry — stores all registered mode definitions. */
 export const MODE_REGISTRY = new Map<string, ModeDefinition>();
 
-/** Helper to convert string patterns to RegExp. */
-function compilePatterns(patterns: string[] | undefined): RegExp[] | undefined {
-  if (!patterns) return undefined;
-  return patterns.map((p) => new RegExp(p, "i"));
+/** Compile a valid pattern array. Undefined means malformed input or no usable patterns. */
+export function compilePatterns(patterns: unknown): RegExp[] | undefined {
+  if (!Array.isArray(patterns)) return undefined;
+  if (patterns.length === 0) return [];
+  const compiled: RegExp[] = [];
+  for (const pattern of patterns) {
+    if (typeof pattern !== "string") return undefined;
+    try {
+      compiled.push(new RegExp(pattern, "i"));
+    } catch {
+      console.warn(`[opl-modes] Invalid pattern: "${pattern}" — ignoring the override`);
+      return undefined;
+    }
+  }
+  return compiled;
 }
 
 /** Resolve the Bash pattern pair for a newly registered custom mode from the shared
@@ -368,14 +383,26 @@ function compilePatterns(patterns: string[] | undefined): RegExp[] | undefined {
  *  Omitted components inherit; explicit arrays (even empty) replace; `unrestrictedBash`
  *  disables Bash gating entirely for that mode. */
 export function resolveCustomPatterns(def: {
-  safePatterns?: string[];
-  destructivePatterns?: string[];
+  safePatterns?: unknown;
+  destructivePatterns?: unknown;
   unrestrictedBash?: boolean;
 }): { safe?: RegExp[]; destructive?: RegExp[] } {
   if (def.unrestrictedBash) return { safe: undefined, destructive: undefined };
   return {
-    safe: def.safePatterns !== undefined ? compilePatterns(def.safePatterns) : SAFE_COMMAND_PATTERNS,
-    destructive: def.destructivePatterns !== undefined ? compilePatterns(def.destructivePatterns) : DESTRUCTIVE_PATTERNS,
+    safe: compilePatterns(def.safePatterns) ?? SAFE_COMMAND_PATTERNS,
+    destructive: compilePatterns(def.destructivePatterns) ?? DESTRUCTIVE_PATTERNS,
+  };
+}
+
+export function mergeModeDefinition(existing: ModeDefinition, def: PartialModeDefinition): ModeDefinition {
+  return {
+    ...existing,
+    ...def,
+    tools: def.tools ?? existing.tools,
+    safePatterns: compilePatterns(def.safePatterns) ?? existing.safePatterns,
+    destructivePatterns: compilePatterns(def.destructivePatterns) ?? existing.destructivePatterns,
+    labels: { ...existing.labels, ...def.labels },
+    appearance: def.appearance ?? existing.appearance,
   };
 }
 
@@ -450,19 +477,13 @@ function initModeRegistry(): void {
   });
 
   // Merge user-defined modes from config (can override built-ins or add new ones).
-  if (userConfig.modes) {
-    for (const [name, def] of Object.entries(userConfig.modes)) {
+  if (isRecord(userConfig.modes)) {
+    for (const [name, rawDefinition] of Object.entries(userConfig.modes)) {
+      if (!isRecord(rawDefinition)) continue;
+      const def = rawDefinition as PartialModeDefinition;
       const existing = MODE_REGISTRY.get(name);
       if (existing) {
-        registerMode(name, {
-          ...existing,
-          ...def,
-          tools: def.tools ?? existing.tools,
-          safePatterns: def.safePatterns ? compilePatterns(def.safePatterns) : existing.safePatterns,
-          destructivePatterns: def.destructivePatterns ? compilePatterns(def.destructivePatterns) : existing.destructivePatterns,
-          labels: { ...existing.labels, ...def.labels },
-          appearance: def.appearance ?? existing.appearance,
-        });
+        registerMode(name, mergeModeDefinition(existing, def));
       } else {
         const patterns = resolveCustomPatterns(def);
         registerMode(name, {

package/extensions/opl-modes/index.ts

@@ -61,6 +61,7 @@ import {
   sanitizePlanName,
   extractTextFromMessage,
   applyLabelColor,
+  createLatestModelQueue,
 } from "./utils.js";
 import {
   getMode,
@@ -118,6 +119,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
   let savedToolNames: string[] | null = null;
   // ─── Saved model for restoring ─────────────────────────────────────────────
   let savedModel: Model<any> | null = null;
+  const queueModelChange = createLatestModelQueue();
   const MAX_REFINE_CYCLES = 5;
 
   function saveAndSetActiveTools(toolNames: string[]): void {
@@ -127,22 +129,22 @@ export default function modeSwitcher(pi: ExtensionAPI) {
     pi.setActiveTools(applyLazyPolicy(toolNames));
   }
 
-  /**
-   * Resolve and switch to a specific model, notifying on failure, then refresh
-   * the footer via updateStatus. No savedModel bookkeeping — callers that need
-   * restore semantics use applyModeModel instead.
-   */
+  /** Queue model changes so a superseded async switch cannot finish after its restore. */
+  function setQueuedModel(ctx: ExtensionContext, model: Model<any>, label: string): Promise<void> {
+    return queueModelChange(async () => {
+      const success = await pi.setModel(model);
+      if (!success && ctx.hasUI) ctx.ui.notify(`[mode-switcher] No API key for model ${label}`, "error");
+      updateStatus(ctx);
+    }).then(() => undefined);
+  }
+
   async function switchToModel(ctx: ExtensionContext, modelRef: { provider: string; id: string }): Promise<void> {
     const resolved = ctx.modelRegistry.find(modelRef.provider, modelRef.id);
     if (!resolved) {
       if (ctx.hasUI) ctx.ui.notify(`[mode-switcher] Model not found: ${modelRef.provider}/${modelRef.id}`, "warning");
       return;
     }
-    const success = await pi.setModel(resolved);
-    if (!success && ctx.hasUI) {
-      ctx.ui.notify(`[mode-switcher] No API key for model ${modelRef.provider}/${modelRef.id}`, "error");
-    }
-    updateStatus(ctx);
+    await setQueuedModel(ctx, resolved, `${modelRef.provider}/${modelRef.id}`);
   }
 
   /**
@@ -167,9 +169,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
     if (savedModel === null) return;
     const toRestore = savedModel;
     savedModel = null;
-    pi.setModel(toRestore).then(() => {
-      updateStatus(ctx);
-    });
+    void setQueuedModel(ctx, toRestore, `${toRestore.provider}/${toRestore.id}`);
   }
 
   /**

package/extensions/opl-modes/utils.ts

@@ -7,6 +7,18 @@ import { join } from "node:path";
 import { SAFE_COMMAND_PATTERNS, DESTRUCTIVE_PATTERNS, PLAN_DIR, PLAN_FILE_PREFIX } from "./config.js";
 import type { PlanFileSummary } from "./types.js";
 
+/** Serialize async model changes so the final requested model wins. */
+export function createLatestModelQueue() {
+  let latest = 0;
+  let tail = Promise.resolve();
+
+  return <T>(change: () => Promise<T>): Promise<T | undefined> => {
+    const request = ++latest;
+    tail = tail.catch(() => undefined).then(() => request === latest ? change() : undefined);
+    return tail as Promise<T | undefined>;
+  };
+}
+
 /** Check if command matches safe patterns and not destructive patterns. */
 export function isSafeCommand(command: string): boolean {
   return SAFE_COMMAND_PATTERNS.some((p) => p.test(command))

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openlines/opl-pi-sht",
-  "version": "0.1.19",
-  "description": "Pi coding-agent extension kit: token-efficient context, safe modes, fingerprinted /init, model benchmarking, web access, and browser automation.",
+  "version": "0.1.20",
+  "description": "opl-pi-sht (shouldHaveThat) Pi coding-agent extension kit: token-efficient context, safe modes, fingerprinted /init, model benchmarking, web access, and browser automation.",
   "repository": {
     "type": "git",
     "url": "https://github.com/linellazatin/opl-pi-sht.git"