@pi-kaush/pi-tool-call-markers 0.2.8 → 0.2.9

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+- Fix: preserve the visible text of hyperlink-wrapped paths in collapsed rows. Pi renders `read` call paths as OSC 8 hyperlinks (`ESC]8;;url ESC\ <path> ESC]8;; ESC\`); the previous greedy OSC strip consumed the path text along with the sequences, collapsing `% read: README.md:1-400` to `% read: :1-400`. OSC payloads now end at their first BEL/ST terminator, so `read`/`write`/`ls` rows show their filenames again.
+- Show settled `edit` changes inline: the call line gains a `+added/-removed` outcome stat, and the display diff from `result.details.diff` renders as a bounded block underneath (`+` lines in the added tone, `-` in the removed tone, context muted, `...` for folded regions; capped at 12 lines with a `+N more` tail). `Ctrl+O` still returns Pi's full native diff.
+- Render subagent plans with a `&` marker instead of `%`, so delegated calls read differently from ordinary tool rows (both the parsed plan shape and the generic fallback).
+- Render user-run `!` bash blocks (BashExecutionComponent) with the railed prompt shell previously owned by `pi-content-layout` — execution display now lives entirely in this package, while `pi-content-layout` keeps only the transcript surface (message insets, status rows, editor, user prompts). The bash-block inset mirrors that package's message inset.
 - Render every collapsed tool call as a `% tool: call → outcome` line with the tool name bolded — one marker per call, no bullets, no blank lines between sections; grouped blocks share only their leading blank row (supersedes the nested sub-heading layout).
 - Render subagent calls as an unboxed plan — `% subagent` heading with chain/parallel counts and numbered steps as they execute, agent names in accent with emojis scraped from the native plan component (args fallback) — replacing the accent-rail card; failed subagents follow the full-red failure tone.
 - Strip display sequences and control bytes (notably `\r` from progress writers like git) from collapsed-row text so command output cannot return the cursor to column 0 and overwrite the row.

package/README.md

@@ -21,21 +21,34 @@ Collapsed tool rows use semantic theme colors with no gear, background fill, box
 - **Quiet-turn grouping.** Sequential calls can join across an assistant row with no visible prose or thinking. Visible assistant content remains a boundary.
 - **MCP and self-rendered tools.** Their stable call labels, compact arguments, pending state, success, and first error line use the same collapsed shell. Native self-rendered details return when expanded.
 - **Images remain visible.** Image fallback text and terminal image components render below the corresponding marker with the same inset.
+- **User-run `!` bash blocks.** Execution display is owned here: user-typed commands trade Pi's green rules for the railed prompt shell (dark surface, status-colored rail) that submitted prompts use.
 - **Native expansion remains authoritative.** `Ctrl+O` restores Pi's full individual tool rendering, including complete results, custom renderers, and error details.
 
 ## Subagent plans
 
-A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic:
+A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic, marked with `&` instead of the ordinary `%` tool marker:
 
 ```text
-  % subagent chain (3 steps) [repo-review]
+  & subagent chain (3 steps) [repo-review]
     1. 🐝 bee [workhorse] Challenge the compatibility conclusion…
     2. 🐝 bee …
 ```
 
-Single calls stay on one `% subagent <agent> [profile] <task preview>` row; chain calls get a heading with the kind, count, and scope followed by numbered steps (parallel tasks list without numbers). Agent display names (emoji + name) are scraped from the native plan component with an args fallback, and render in `accent`; everything else stays muted, and failed subagents go full red. Subagents never join ordinary tool groups.
+Single calls stay on one `& subagent <agent> [profile] <task preview>` row; chain calls get a heading with the kind, count, and scope followed by numbered steps (parallel tasks list without numbers). Agent display names (emoji + name) are scraped from the native plan component with an args fallback, and render in `accent`; everything else stays muted, and failed subagents go full red. Subagents never join ordinary tool groups.
 
-Malformed, ambiguous, future, or too-narrow shapes fall back to the generic `% subagent …` collapsed row rather than dropping information, and `Ctrl+O` still exposes the native subagent renderer.
+Malformed, ambiguous, future, or too-narrow shapes fall back to the generic `& subagent …` collapsed row rather than dropping information, and `Ctrl+O` still exposes the native subagent renderer.
+
+## Edit diffs
+
+Settled `edit` calls keep their change visible without expanding: the call line gains a `+added/-removed` outcome stat, and the hunk renders as a bounded diff block underneath (`+` lines in the added tone, `-` in the removed tone, context muted, folded regions as `...`, capped at 12 lines with a count tail). The full native diff — line numbers, intra-line word highlights — still returns with `Ctrl+O`.
+
+Files and paths in collapsed rows are preserved as displayed by Pi: hyperlink-wrapped paths (Pi wraps `read` call paths in OSC 8 hyperlinks) keep their visible text when sanitized for one-line rows.
+
+## Scope boundary
+
+This package owns every **execution row** in the transcript: collapsed tool calls, tool grouping, subagent plans, thinking labels, and user-run `!` bash blocks (reshaped into the railed prompt shell). Transcript _surface_ layout — message insets, system-text and status-rule alignment, the editor surface, and the submitted-prompt shell for user messages — belongs to `@pi-kaush/pi-content-layout`, which never renders tool rows.
+
+One shared visual contract crosses the line: `!` blocks align with message text, so their inset mirrors `pi-content-layout`'s message `contentInset` (see `src/bash-block.ts`). Change indentation in both packages together.
 
 ## Bundled thinking-block extension
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-kaush/pi-tool-call-markers",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Compact and group Pi tool calls, with a bundled extension for adjacent thinking blocks.",
   "license": "MIT",
   "author": "Kaushik Gopal",

package/src/bash-block.ts

@@ -0,0 +1,289 @@
+import { BashExecutionComponent } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+type ThemeLike = {
+  bold(text: string): string;
+  fg(color: string, text: string): string;
+};
+
+const BASH_BLOCK_PATCHED = Symbol.for("kg.pi.bashBlock.v1");
+
+// The prompt surface uses a fixed near-black green tint instead of the
+// theme's selectedBg token so every user-input surface stays identical.
+const PROMPT_SURFACE_BG = "\x1b[48;2;7;19;18m"; // #071312
+const PROMPT_RAIL = "▎";
+
+// User-run bash blocks align with the message inset pi-content-layout
+// applies to transcript lines. Keep this in sync with that package's
+// contentInset (2 columns outside the rail for any width above 4); the
+// conversation surface has one shared visual contract even though the two
+// packages otherwise own disjoint components.
+function bashBlockInset(width: number): number {
+  return width > BASH_BLOCK_INSET * 2 ? BASH_BLOCK_INSET : 0;
+}
+const BASH_BLOCK_INSET = 2;
+
+const SGR_PATTERN = /\x1b\[([0-9;]*)m/g;
+const BACKGROUND_PATTERN =
+  /\x1b\[(?:4[0-8]|10[0-7]|48;5;\d{1,3}|48;2;\d{1,3};\d{1,3};\d{1,3})m/g;
+const DISPLAY_ANSI_PATTERN = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+
+function semanticControlEnd(text: string, offset: number): number | undefined {
+  if (text[offset] !== "\x1b") return undefined;
+  const kind = text[offset + 1];
+  if (kind !== "]" && kind !== "_" && kind !== "P" && kind !== "^") {
+    return undefined;
+  }
+  for (let index = offset + 2; index < text.length; index++) {
+    if (text[index] === "\x07") return index + 1;
+    if (text[index] === "\x1b" && text[index + 1] === "\\") {
+      return index + 2;
+    }
+  }
+  return undefined;
+}
+
+function splitLeadingSemanticControls(line: string): {
+  controls: string;
+  content: string;
+} {
+  let offset = 0;
+  while (offset < line.length) {
+    const end = semanticControlEnd(line, offset);
+    if (end === undefined) break;
+    offset = end;
+  }
+  return { controls: line.slice(0, offset), content: line.slice(offset) };
+}
+
+function fitLine(line: string, width: number): string {
+  if (width <= 0) return "";
+  const clipped = truncateToWidth(line, width, "");
+  return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+
+function reapplyBackgroundAfterReset(
+  text: string,
+  backgroundAnsi: string,
+): string {
+  return text.replace(SGR_PATTERN, (sequence, rawParameters: string) => {
+    const parameters =
+      rawParameters === "" ? [0] : rawParameters.split(";").map(Number);
+    return parameters.includes(0) || parameters.includes(49)
+      ? `${sequence}${backgroundAnsi}`
+      : sequence;
+  });
+}
+
+function paintBackground(
+  line: string,
+  width: number,
+  backgroundAnsi: string,
+): string {
+  const fitted = fitLine(line, width);
+  // Mirrors Theme.bg: background, content, then a background-only reset.
+  return `${backgroundAnsi}${reapplyBackgroundAfterReset(fitted, backgroundAnsi)}\x1b[49m`;
+}
+
+function stripDisplayAnsi(text: string): string {
+  return text.replace(DISPLAY_ANSI_PATTERN, "");
+}
+
+function replaceBackground(text: string, backgroundAnsi: string): string {
+  return text.replace(BACKGROUND_PATTERN, backgroundAnsi);
+}
+
+// Renders lines inside a railed, dark-surfaced block (the submitted-prompt
+// shell): optional leading semantic controls stay outside the inset, the rail
+// is recolored, and content backgrounds are normalized to the prompt surface.
+function renderRailedBlockLines(
+  lines: string[],
+  width: number,
+  theme: ThemeLike,
+  inset: number,
+  railColor: string,
+): string[] {
+  const blockWidth = width - inset * 2;
+  if (inset === 0 || blockWidth <= visibleWidth(PROMPT_RAIL)) {
+    return lines.map((line) => fitLine(line, width));
+  }
+  const bodyWidth = blockWidth - visibleWidth(PROMPT_RAIL);
+  const margin = " ".repeat(inset);
+  return lines.map((line) => {
+    const { controls, content } = splitLeadingSemanticControls(line);
+    const recolored = replaceBackground(content, PROMPT_SURFACE_BG);
+    const rail = theme.fg(railColor, PROMPT_RAIL);
+    // One extra leading space inside the body, so submitted text sits two
+    // columns right of the rail instead of one.
+    const body = paintBackground(
+      ` ${fitLine(recolored, Math.max(1, bodyWidth - 1))}`,
+      bodyWidth,
+      PROMPT_SURFACE_BG,
+    );
+    return `${controls}${margin}${rail}${body}${margin}`;
+  });
+}
+
+const RULE_LINE_RE = /^─+$/;
+
+function isRuleLine(line: string | undefined): line is string {
+  return line !== undefined && RULE_LINE_RE.test(stripDisplayAnsi(line).trim());
+}
+
+// `!!` commands draw their rules dim instead of bashMode green, but the
+// component does not store that flag, so sniff the top rule's color to keep
+// the rail consistent with the framing it replaces.
+function sniffsDimRule(rule: string, theme: ThemeLike): boolean {
+  const prefixOf = (colored: string) => colored.slice(0, colored.indexOf("─"));
+  const dimPrefix = prefixOf(theme.fg("dim", "─"));
+  return (
+    dimPrefix.length > 0 &&
+    dimPrefix !== prefixOf(theme.fg("bashMode", "─")) &&
+    rule.startsWith(dimPrefix)
+  );
+}
+
+// Rail tone for a user bash block: failures read red and cancellations
+// yellow, matching the block's status text; anything else keeps the green
+// the rules used (dim for `!!` commands).
+function bashBlockRailColor(
+  status: string | undefined,
+  topRule: string | undefined,
+  theme: ThemeLike,
+): string {
+  if (status === "error") return "error";
+  if (status === "cancelled") return "warning";
+  if (topRule !== undefined && sniffsDimRule(topRule, theme)) return "dim";
+  return "bashMode";
+}
+
+// Reshapes BashExecutionComponent output into the submitted-prompt shell: the
+// leading spacer stays outside the block, the top/bottom rules are dropped,
+// and the remaining lines get one blank padded row at each end plus the rail
+// and dark surface.
+function renderBashBlockLines(
+  lines: string[],
+  width: number,
+  theme: ThemeLike,
+  status: string | undefined,
+  inset = bashBlockInset(width),
+): string[] {
+  const [spacer, ...rest] = lines;
+  const topRule = isRuleLine(rest[0]) ? rest[0] : undefined;
+  const inner = topRule !== undefined ? rest.slice(1) : rest.slice();
+  if (isRuleLine(inner[inner.length - 1])) inner.pop();
+  const railColor = bashBlockRailColor(status, topRule, theme);
+  const block = renderRailedBlockLines(
+    ["", ...inner, ""],
+    width,
+    theme,
+    inset,
+    railColor,
+  );
+  return [fitLine(spacer ?? "", width), ...block];
+}
+
+type BashRow = { status?: unknown };
+
+type BashBlockPatchState = {
+  theme?: ThemeLike;
+  cache: WeakMap<object, { width: number; src: string[]; lines: string[] }>;
+  originalRender: (width: number) => string[];
+  patchedRender?: (width: number) => string[];
+};
+
+// User-typed `!` commands are execution rows, so their presentation belongs
+// here with every other collapsed execution display; pi-content-layout stops
+// at the message surface. Pi's BashExecutionComponent already draws the
+// command, rules, and status; this patch reshapes that output into the
+// railed prompt shell and recolors the rail from the exit outcome.
+// TODO: Replace prototype patching with a public Pi rendering API when available.
+function installBashBlockPatch(): BashBlockPatchState | undefined {
+  try {
+    const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
+      [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
+      render?: (width: number) => string[];
+    };
+    if (!proto || typeof proto.render !== "function") return undefined;
+
+    const existing = proto[BASH_BLOCK_PATCHED];
+    if (existing) return existing;
+
+    const state: BashBlockPatchState = {
+      cache: new WeakMap(),
+      originalRender: proto.render,
+    };
+    const patchedRender = function renderWithBashBlockShell(
+      this: BashRow,
+      width: number,
+    ): string[] {
+      const theme = state.theme;
+      if (!theme) return state.originalRender.call(this, width);
+      const inset = bashBlockInset(width);
+      const bodyWidth = width - inset * 2 - visibleWidth(PROMPT_RAIL);
+      if (inset === 0 || bodyWidth < 8) {
+        return state.originalRender.call(this, width);
+      }
+      const lines = state.originalRender.call(this, Math.max(1, bodyWidth));
+      const entry = state.cache.get(this);
+      if (
+        entry &&
+        entry.width === width &&
+        entry.src.length === lines.length &&
+        entry.src.every((line, index) => line === lines[index])
+      ) {
+        return entry.lines;
+      }
+      const status = this.status;
+      const decorated = renderBashBlockLines(
+        lines,
+        width,
+        theme,
+        typeof status === "string" ? status : undefined,
+        inset,
+      );
+      state.cache.set(this, { width, src: lines, lines: decorated });
+      return decorated;
+    };
+
+    try {
+      state.patchedRender = patchedRender;
+      proto.render = patchedRender;
+      Object.defineProperty(proto, BASH_BLOCK_PATCHED, {
+        configurable: true,
+        value: state,
+      });
+    } catch {
+      proto.render = state.originalRender;
+      return undefined;
+    }
+    return state;
+  } catch {
+    // Pi internals can change across versions; fail silently.
+    return undefined;
+  }
+}
+
+function uninstallBashBlockPatch(state: BashBlockPatchState | undefined): void {
+  if (!state) return;
+  const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
+    [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
+    render?: (width: number) => string[];
+  };
+  if (
+    proto[BASH_BLOCK_PATCHED] !== state ||
+    proto.render !== state.patchedRender
+  ) {
+    return;
+  }
+  proto.render = state.originalRender;
+  delete proto[BASH_BLOCK_PATCHED];
+}
+
+export {
+  PROMPT_RAIL,
+  PROMPT_SURFACE_BG,
+  installBashBlockPatch,
+  uninstallBashBlockPatch,
+};
+export type { BashBlockPatchState };

package/src/index.ts

@@ -10,10 +10,15 @@ import {
   visibleWidth,
   wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+import {
+  installBashBlockPatch,
+  uninstallBashBlockPatch,
+} from "./bash-block.ts";
 import { runChatContainerHooks } from "./container-hooks.ts";
 
 const OUTER_INSET = 2;
 const GROUP_MARKER = "%";
+const SUBAGENT_MARKER = "&";
 const PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v3");
 const LEGACY_PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v2");
 const GROUPING_PATCHED = Symbol.for("kg.pi.toolGrouping.v1");
@@ -113,9 +118,13 @@ function stripAnsi(text: string): string {
 // and overwrite the row's own marker.
 const INLINE_CONTROL_RE = /[\x00-\x08\x0b-\x1f\x7f]/g;
 // OSC first: the two-byte alternative would otherwise consume `\x1b]` and
-// leave the hyperlink payload behind as visible text.
+// leave the hyperlink payload behind as visible text. OSC sequences (OSC 8
+// hyperlinks, titles) end at their first BEL/ST terminator; a payload match
+// must stop there too, because the visible text sits BETWEEN two OSC
+// sequences — Pi wraps read paths as `ESC]8;;url ESC\ <path> ESC]8;; ESC\`,
+// and a greedy `[^\x07]*` would swallow that path along with the sequences.
 const DISPLAY_ANSI_RE =
-  /\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g;
+  /\x1b(?:\][^\x07\x1b]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g;
 
 function sanitizeInline(text: string): string {
   return text.replace(DISPLAY_ANSI_RE, "").replace(INLINE_CONTROL_RE, " ");
@@ -592,6 +601,64 @@ function diffCounts(diff: string): { added: number; removed: number } {
   return { added, removed };
 }
 
+// Pi's edit tool (renderShell "self") stores its display diff in
+// result.details.diff — lines like `+27 <content>`, `-27 <content>`,
+// ` 28 <context>`, plus `...` for folded regions. Self-rendered rows
+// normally keep only their one-line call label; edits additionally show
+// the change as a bounded diff block under the summary and a +a/-b stat in
+// the outcome tail, so the hunk stays visible without Ctrl+O while
+// expanded rows keep Pi's native rendering.
+const EDIT_DIFF_LINE_RE = /^([+\-\s])(\s*\d*)(.*)$/;
+const MAX_EDIT_DIFF_LINES = 12;
+
+function editDiffText(row: ToolExecutionRow): string | undefined {
+  if (row.toolName !== "edit") return undefined;
+  if (!row.result || row.isPartial !== false || rowHasFailed(row))
+    return undefined;
+  const diff = row.result.details?.diff;
+  return typeof diff === "string" && diff.length > 0 ? diff : undefined;
+}
+
+function renderedEditDiffStat(row: ToolExecutionRow): string | undefined {
+  const diff = editDiffText(row);
+  if (diff === undefined) return undefined;
+  const { added, removed } = diffCounts(diff);
+  return added + removed === 0 ? "applied" : `+${added}/-${removed}`;
+}
+
+function renderedEditDiffLines(
+  row: ToolExecutionRow,
+  theme: ThemeLike,
+): string[] {
+  const diff = editDiffText(row);
+  if (diff === undefined) return [];
+  const raw = diff.split("\n");
+  if (raw[raw.length - 1] === "") raw.pop();
+  const lines: string[] = [];
+  for (const line of raw.slice(0, MAX_EDIT_DIFF_LINES)) {
+    const clean = sanitizeInline(line).trimEnd();
+    if (clean.trim() === "...") {
+      lines.push(theme.fg("muted", "  ..."));
+      continue;
+    }
+    const match = EDIT_DIFF_LINE_RE.exec(clean);
+    if (!match) continue;
+    const color =
+      match[1] === "+"
+        ? "toolDiffAdded"
+        : match[1] === "-"
+          ? "toolDiffRemoved"
+          : "toolDiffContext";
+    lines.push(theme.fg(color, `  ${match[1]}${match[2]}${match[3]}`));
+  }
+  if (raw.length > MAX_EDIT_DIFF_LINES) {
+    lines.push(
+      theme.fg("muted", `  ... +${raw.length - MAX_EDIT_DIFF_LINES} more`),
+    );
+  }
+  return lines;
+}
+
 function outcomeSummary(row: ToolExecutionRow): string | undefined {
   // Self-rendered tools own their result framing; the built-in heuristics
   // (line counts, diff stats) describe default-shell rows only, so their
@@ -832,7 +899,11 @@ function collapsedOutcome(
     const elapsed = liveElapsedText(row);
     return theme.fg("warning", elapsed ? `… · ${elapsed}` : "…");
   }
-  if (row.getRenderShell?.() === "self") return renderedGenericOutcome(theme);
+  if (row.getRenderShell?.() === "self") {
+    const editStat = renderedEditDiffStat(row);
+    if (editStat) return theme.fg("muted", `→ ${editStat}`);
+    return renderedGenericOutcome(theme);
+  }
   return renderedOutcome(row, theme);
 }
 
@@ -844,7 +915,10 @@ function collapsedHeadline(
   // Failed rows render entirely in error so the row reads as the one that
   // failed, not just its outcome tail. Only the tool name is bold.
   const color = rowHasFailed(row) ? "error" : "muted";
-  const marker = `${theme.fg(color, GROUP_MARKER)} `;
+  const marker = `${theme.fg(
+    color,
+    row.toolName === "subagent" ? SUBAGENT_MARKER : GROUP_MARKER,
+  )} `;
   const budget = Math.max(1, width - visibleWidth(marker));
   const label = collapsedCallLabel(row, budget, theme, color);
   const outcome = collapsedOutcome(row, budget, theme);
@@ -1007,7 +1081,7 @@ function renderSubagentPlan(
       `${step.profile ? ` [${sanitizeInline(step.profile)}]` : ""} ${subagentStepPreview(step.task)}`,
     );
 
-  const marker = `${theme.fg(color, theme.bold(GROUP_MARKER))} `;
+  const marker = `${theme.fg(color, theme.bold(SUBAGENT_MARKER))} `;
   const budget = Math.max(1, width - visibleWidth(marker));
   const outcome = failed
     ? collapsedOutcome(row, budget, theme)
@@ -1102,6 +1176,9 @@ function renderCollapsedToolRow(
       ? renderSubagentPlan(row, layout.contentWidth, theme)
       : undefined;
   const body = plan ?? [collapsedHeadline(row, layout.contentWidth, theme)];
+  if (row.toolName === "edit") {
+    body.push(...renderedEditDiffLines(row, theme));
+  }
   body.push(...imageResultLines(row, layout.contentWidth, theme));
   return ["", ...insetLines(body, width)];
 }
@@ -1113,8 +1190,12 @@ function groupedCallComponent(
   return {
     render(width: number): string[] {
       // Every member renders like a singleton — `% tool: call → outcome` per
-      // line with the tool name bolded — no bullets or internal blanks.
-      return rows.map((row) => collapsedHeadline(row, width, theme));
+      // line with the tool name bolded — no bullets or internal blanks;
+      // settled edits keep their change visible with a bounded diff block.
+      return rows.flatMap((row) => [
+        collapsedHeadline(row, width, theme),
+        ...(row.toolName === "edit" ? renderedEditDiffLines(row, theme) : []),
+      ]);
     },
     invalidate() {},
   };
@@ -1506,14 +1587,17 @@ function uninstallPresentationPatch(
 export default function (pi: ExtensionAPI) {
   const patch = installPresentationPatch();
   const grouping = patch ? installGroupingPatch(patch) : undefined;
+  const bashPatch = installBashBlockPatch();
 
   pi.on("session_start", (_event, ctx) => {
     if (patch) patch.theme = ctx.ui.theme;
+    if (bashPatch) bashPatch.theme = ctx.ui.theme;
     ctx.ui.setToolsExpanded(false);
   });
 
   pi.on("session_shutdown", () => {
     uninstallGroupingPatch(grouping);
     uninstallPresentationPatch(patch);
+    uninstallBashBlockPatch(bashPatch);
   });
 }