bermudis-pi-goodies 0.27.2 → 0.27.4

package/README.md

@@ -8,12 +8,11 @@ extensions. One entry point, thirteen independent features.
 | `copy-with-model`   | `/copy-with-model`            | Copy last assistant message to the clipboard in a code fence tagged with the model name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `copy-trajectory`   | `/copy-trajectory [thinking]` | Copy the whole conversation (user + assistant text, tool calls stripped) to the clipboard; `thinking` also includes assistant thinking blocks.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `name-with-ai`      | `/name-with-ai [name]`        | Generate a short session name from the first user message (or set one manually).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `zed`               | `/z`                          | Open Zed editor on the current working directory.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `prefer-tools`      | hook (no command)             | Blocks legacy tools: `rm` → `trash`, bare `python`/`pip`/`pytest`/`mypy` → `uv`. On `glm-5.*` models it also blocks bash `rg` (they invent ripgrep flags) — the built-in grep tool still works.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `prefer-tools`      | hook (no command)             | Blocks legacy tools: `rm` → `trash <path>` (and `trash-rm`/`trash-empty`, which delete permanently), bare `python`/`pip`/`pytest`/`mypy` → `uv`. On `glm-5.*` models it also blocks bash `rg` (they invent ripgrep flags) — the built-in grep tool still works.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `keep-model-on-new` | hook (no command)             | Keep the active model when `/new` starts a fresh session instead of reverting to pi's saved default model.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `model-thinking`    | `/model-thinking`             | Per-model default thinking levels: save the current level as this model's default and get it back on every switch to that model, instead of pi's global default.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `clean-tui`         | tool overrides (no command)   | Collapse built-in tool output for a cleaner TUI: back-to-back same-tool calls share one block (e.g. `read ×2`) until a boundary — visible text (assistant prose or a typed user message) or a thinking block (even an empty one, as OpenAI emits between tool calls) — so reasoning-per-call models render one block per call. Images stay visible without expanding, expand a row with ctrl+o to see the full command and results/diffs. Long bash commands get an AI-generated summary once you pick a model with `/goodies summary-model <provider/model>` (see "Smart summaries" below) — expanding a row swaps the summary back out for the raw command. While enabled, also flips `@bermudi/pi-codex`'s `apply_patch`/`web_search` into the same burst style. Long thinking runs can show a live plain-English line above the editor (`/goodies thinking-summaries on`) instead of a static `Thinking...` — see "Smart summaries". |
-| `review`            | `/review`, `/end-review`      | Code review workflow: review uncommitted changes, a branch, a commit, a GitHub PR, or folders. Prioritized findings with actionable follow-ups. Targets tab-complete.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `review`            | `/review`, `/end-review`      | Code review workflow: review uncommitted changes, a branch, a commit, a GitHub PR, or folders. Prioritized findings with actionable follow-ups. Targets tab-complete. Works in the terminal and in RPC hosts like T3 Code (plain selectors replace the search-as-you-type ones outside the TUI).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `kilo`              | provider                      | Access Kilo Gateway models via `/login kilo` or `KILO_API_KEY`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `provider-balance`  | footer (no command)           | Show remaining Kilo, OpenRouter, or CommandCode credits, z.ai token-plan quota, or OpenAI Codex quota on the right side of the working-directory footer line.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `tps`               | hook (no command)             | Notify tokens/sec and in/out/cache token usage at the end of each agent turn.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
@@ -26,7 +25,7 @@ extensions. One entry point, thirteen independent features.
 First install, pinned to a published version:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.27.2
+pi install npm:bermudis-pi-goodies@0.27.4
 ```
 
 Picking up a new release on an existing install (`pi install` is not the

package/goodies.ts

@@ -34,7 +34,6 @@ type FeatureName =
   | "copy-with-model"
   | "copy-trajectory"
   | "name-with-ai"
-  | "zed"
   | "prefer-tools"
   | "keep-model"
   | "model-thinking"
@@ -50,7 +49,6 @@ const FEATURES: FeatureName[] = [
   "copy-with-model",
   "copy-trajectory",
   "name-with-ai",
-  "zed",
   "prefer-tools",
   "keep-model",
   "model-thinking",

package/index.ts

@@ -6,7 +6,6 @@
  *   - copy-with-model  /copy-with-model  copy last reply tagged with the model
  *   - copy-trajectory  /copy-trajectory  copy the whole conversation (text only) to the clipboard
  *   - name-with-ai     /name-with-ai     generate a session name via the model
- *   - zed              /z                open Zed on cwd
  *   - prefer-tools     hook              block legacy tools (trash/uv; blocks rg on glm-5.*)
  *   - keep-model       hook              preserve the active model across /new
  *   - model-thinking   /model-thinking   per-model default thinking levels, applied on switch
@@ -38,7 +37,6 @@ import tps from "./tps.ts";
 import vision from "./vision.ts";
 import side from "./side.ts";
 import nameWithAi from "./name-with-ai.ts";
-import zed from "./zed.ts";
 import preferTools from "./prefer-tools.ts";
 import goodies, { isEnabled } from "./goodies.ts";
 import { setCleanTuiActive } from "./clean-tui.ts";
@@ -51,7 +49,6 @@ export default function bermudisPiGoodies(pi: ExtensionAPI): void {
   if (isEnabled("copy-with-model")) copyWithModel(pi);
   if (isEnabled("copy-trajectory")) copyTrajectory(pi);
   if (isEnabled("name-with-ai")) nameWithAi(pi);
-  if (isEnabled("zed")) zed(pi);
   if (isEnabled("prefer-tools")) preferTools(pi);
   if (isEnabled("keep-model")) keepModelOnNew(pi);
   if (isEnabled("model-thinking")) modelThinking(pi);

package/package.json

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

package/prefer-tools.ts

@@ -10,7 +10,9 @@
  * Env-var assignment prefixes (`FOO=bar rm x`) are recognized and skipped so
  * the real command that follows them is still checked.
  *
- *   rm                  -> trash
+ *   rm                  -> trash <path>   (moves to the trash can; recoverable)
+ *   trash-rm            -> blocked       (permanently deletes from the trash can)
+ *   trash-empty         -> blocked       (permanently empties the trash can)
  *   python/pip/pytest/  -> uv
  *     mypy
  *
@@ -31,7 +33,13 @@ interface Rule {
 const RULES: Rule[] = [
   {
     names: ["rm"],
-    reason: "rm is blocked — use `trash` instead (recoverable beats gone)",
+    reason:
+      "rm is blocked — use `trash <path>` instead (moves to the trash can; recoverable beats gone). Do NOT use `trash-rm`: it deletes permanently from the trash can.",
+  },
+  {
+    names: ["trash-rm", "trash-empty"],
+    reason:
+      "trash-rm and trash-empty are blocked — they delete permanently from the trash can. Use `trash <path>` to move files to the trash (recoverable).",
   },
   {
     names: ["python", "python3", "pip", "pip3", "pytest", "mypy"],

package/review.ts

@@ -48,6 +48,12 @@
  *   after the abort is discarded and the review state is cleared, so a stale
  *   {active: true} entry can't resurrect the review widget (pi exposes no
  *   cancellation for an in-flight navigateTree summarization)
+ * - RPC-host compatibility (T3 Code drives Pi with --mode rpc, where
+ *   ctx.ui.custom resolves to undefined and /review silently cancelled):
+ *   the preset, base-branch, and commit selectors fall back to plain
+ *   ctx.ui.select dialogs when ctx.mode !== "tui", the end-review loader
+ *   only renders in TUI mode, and the review widget renders as string
+ *   lines outside the TUI
  */
 
 import type {
@@ -102,6 +108,15 @@ function setReviewWidget(ctx: ExtensionContext, active: boolean) {
     return;
   }
 
+  // Component factories only render in the TUI; RPC hosts like T3 Code show
+  // the plain string lines instead.
+  if (ctx.mode !== "tui") {
+    ctx.ui.setWidget("review", [
+      "Review session active, return with /end-review",
+    ]);
+    return;
+  }
+
   ctx.ui.setWidget("review", (_tui, theme) => {
     const message = "Review session active, return with /end-review";
     const text = new Text(theme.fg("warning", message), 0, 0);
@@ -846,6 +861,37 @@ function getUserFacingHint(target: ReviewTarget): string {
   }
 }
 
+/**
+ * One ctx.ui.select option: the plain dialog has no description column, so
+ * the description rides inline in the label.
+ */
+export function selectOptionLabel(label: string, description?: string): string {
+  const trimmed = description?.trim();
+  return trimmed ? `${label} ${trimmed}` : label;
+}
+
+/**
+ * Build ctx.ui.select options from value/label/description items and a
+ * lookup that maps a chosen option back to its value. Used by the selectors'
+ * non-TUI fallbacks, where ctx.ui.custom components can't render (RPC hosts
+ * like T3 Code) and only plain dialogs are available. The recommended index
+ * gets a " (recommended)" suffix since plain dialogs can't preselect.
+ */
+export function buildSelectOptions<T extends string>(
+  items: ReadonlyArray<{ value: T; label: string; description?: string }>,
+  recommendedIndex = -1,
+): { options: string[]; valueFor: (option: string) => T | undefined } {
+  const valueByOption = new Map<string, T>();
+  const options = items.map((item, index) => {
+    const option = selectOptionLabel(item.label, item.description);
+    const marked =
+      index === recommendedIndex ? `${option} (recommended)` : option;
+    valueByOption.set(marked, item.value);
+    return marked;
+  });
+  return { options, valueFor: (option: string) => valueByOption.get(option) };
+}
+
 // Review preset options for the selector (keep this order stable)
 const REVIEW_PRESETS = [
   {
@@ -1162,56 +1208,79 @@ export default function reviewExtension(pi: ExtensionAPI) {
         },
       ];
 
-      const result = await ctx.ui.custom<ReviewPresetValue | null>(
-        (tui, theme, _kb, done) => {
-          const container = new Container();
-          container.addChild(
-            new DynamicBorder((str) => theme.fg("accent", str)),
-          );
-          container.addChild(
-            new Text(theme.fg("accent", theme.bold("Select a review preset"))),
-          );
+      let result: ReviewPresetValue | null;
+      if (ctx.mode === "tui") {
+        result = await ctx.ui.custom<ReviewPresetValue | null>(
+          (tui, theme, _kb, done) => {
+            const container = new Container();
+            container.addChild(
+              new DynamicBorder((str) => theme.fg("accent", str)),
+            );
+            container.addChild(
+              new Text(
+                theme.fg("accent", theme.bold("Select a review preset")),
+              ),
+            );
 
-          const selectList = new SelectList(items, Math.min(items.length, 10), {
-            selectedPrefix: (text) => theme.fg("accent", text),
-            selectedText: (text) => theme.fg("accent", text),
-            description: (text) => theme.fg("muted", text),
-            scrollInfo: (text) => theme.fg("dim", text),
-            noMatch: (text) => theme.fg("warning", text),
-          });
+            const selectList = new SelectList(
+              items,
+              Math.min(items.length, 10),
+              {
+                selectedPrefix: (text) => theme.fg("accent", text),
+                selectedText: (text) => theme.fg("accent", text),
+                description: (text) => theme.fg("muted", text),
+                scrollInfo: (text) => theme.fg("dim", text),
+                noMatch: (text) => theme.fg("warning", text),
+              },
+            );
 
-          // Preselect the smart default without reordering the list
-          if (smartDefaultIndex >= 0) {
-            selectList.setSelectedIndex(smartDefaultIndex);
-          }
+            // Preselect the smart default without reordering the list
+            if (smartDefaultIndex >= 0) {
+              selectList.setSelectedIndex(smartDefaultIndex);
+            }
 
-          selectList.onSelect = (item) => done(item.value as ReviewPresetValue);
-          selectList.onCancel = () => done(null);
+            selectList.onSelect = (item) =>
+              done(item.value as ReviewPresetValue);
+            selectList.onCancel = () => done(null);
 
-          container.addChild(selectList);
-          container.addChild(
-            new Text(
-              theme.fg("dim", "Press enter to confirm or esc to go back"),
-            ),
-          );
-          container.addChild(
-            new DynamicBorder((str) => theme.fg("accent", str)),
-          );
+            container.addChild(selectList);
+            container.addChild(
+              new Text(
+                theme.fg("dim", "Press enter to confirm or esc to go back"),
+              ),
+            );
+            container.addChild(
+              new DynamicBorder((str) => theme.fg("accent", str)),
+            );
 
-          return {
-            render(width: number) {
-              return container.render(width);
-            },
-            invalidate() {
-              container.invalidate();
-            },
-            handleInput(data: string) {
-              selectList.handleInput(data);
-              tui.requestRender();
-            },
-          };
-        },
-      );
+            return {
+              render(width: number) {
+                return container.render(width);
+              },
+              invalidate() {
+                container.invalidate();
+              },
+              handleInput(data: string) {
+                selectList.handleInput(data);
+                tui.requestRender();
+              },
+            };
+          },
+        );
+      } else {
+        // Outside the TUI (RPC hosts like T3 Code) ctx.ui.custom resolves to
+        // undefined, so use the plain select dialog, which works everywhere.
+        const { options, valueFor } = buildSelectOptions<ReviewPresetValue>(
+          items.map((item) => ({
+            value: item.value as ReviewPresetValue,
+            label: item.label,
+            description: item.description,
+          })),
+          smartDefaultIndex,
+        );
+        const selected = await ctx.ui.select("Select a review preset", options);
+        result = selected === undefined ? null : (valueFor(selected) ?? null);
+      }
 
       if (!result) return null;
 
@@ -1335,102 +1404,119 @@ export default function reviewExtension(pi: ExtensionAPI) {
       return { value: branch, label: branch, description };
     });
 
-    const result = await ctx.ui.custom<string | null>(
-      (tui, theme, keybindings, done) => {
-        const container = new Container();
-        container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
-        container.addChild(
-          new Text(theme.fg("accent", theme.bold("Select base branch"))),
-        );
+    let result: string | null;
+    if (ctx.mode === "tui") {
+      result = await ctx.ui.custom<string | null>(
+        (tui, theme, keybindings, done) => {
+          const container = new Container();
+          container.addChild(
+            new DynamicBorder((str) => theme.fg("accent", str)),
+          );
+          container.addChild(
+            new Text(theme.fg("accent", theme.bold("Select base branch"))),
+          );
 
-        const searchInput = new Input();
-        container.addChild(searchInput);
-        container.addChild(new Spacer(1));
+          const searchInput = new Input();
+          container.addChild(searchInput);
+          container.addChild(new Spacer(1));
 
-        const listContainer = new Container();
-        container.addChild(listContainer);
-        container.addChild(
-          new Text(
-            theme.fg("dim", "Type to filter • enter to select • esc to cancel"),
-          ),
-        );
-        container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
+          const listContainer = new Container();
+          container.addChild(listContainer);
+          container.addChild(
+            new Text(
+              theme.fg(
+                "dim",
+                "Type to filter • enter to select • esc to cancel",
+              ),
+            ),
+          );
+          container.addChild(
+            new DynamicBorder((str) => theme.fg("accent", str)),
+          );
 
-        let filteredItems = items;
-        let selectList: SelectList | null = null;
+          let filteredItems = items;
+          let selectList: SelectList | null = null;
 
-        const updateList = () => {
-          listContainer.clear();
-          if (filteredItems.length === 0) {
-            listContainer.addChild(
-              new Text(theme.fg("warning", "  No matching branches")),
-            );
-            selectList = null;
-            return;
-          }
+          const updateList = () => {
+            listContainer.clear();
+            if (filteredItems.length === 0) {
+              listContainer.addChild(
+                new Text(theme.fg("warning", "  No matching branches")),
+              );
+              selectList = null;
+              return;
+            }
 
-          selectList = new SelectList(
-            filteredItems,
-            Math.min(filteredItems.length, 10),
-            {
-              selectedPrefix: (text) => theme.fg("accent", text),
-              selectedText: (text) => theme.fg("accent", text),
-              description: (text) => theme.fg("muted", text),
-              scrollInfo: (text) => theme.fg("dim", text),
-              noMatch: (text) => theme.fg("warning", text),
-            },
-          );
+            selectList = new SelectList(
+              filteredItems,
+              Math.min(filteredItems.length, 10),
+              {
+                selectedPrefix: (text) => theme.fg("accent", text),
+                selectedText: (text) => theme.fg("accent", text),
+                description: (text) => theme.fg("muted", text),
+                scrollInfo: (text) => theme.fg("dim", text),
+                noMatch: (text) => theme.fg("warning", text),
+              },
+            );
 
-          selectList.onSelect = (item) => done(item.value);
-          selectList.onCancel = () => done(null);
-          listContainer.addChild(selectList);
-        };
+            selectList.onSelect = (item) => done(item.value);
+            selectList.onCancel = () => done(null);
+            listContainer.addChild(selectList);
+          };
 
-        const applyFilter = () => {
-          const query = searchInput.getValue();
-          filteredItems = query
-            ? fuzzyFilter(
-                items,
-                query,
-                (item) =>
-                  `${item.label} ${item.value} ${item.description ?? ""}`,
-              )
-            : items;
-          updateList();
-        };
+          const applyFilter = () => {
+            const query = searchInput.getValue();
+            filteredItems = query
+              ? fuzzyFilter(
+                  items,
+                  query,
+                  (item) =>
+                    `${item.label} ${item.value} ${item.description ?? ""}`,
+                )
+              : items;
+            updateList();
+          };
 
-        applyFilter();
+          applyFilter();
 
-        return {
-          render(width: number) {
-            return container.render(width);
-          },
-          invalidate() {
-            container.invalidate();
-          },
-          handleInput(data: string) {
-            if (
-              keybindings.matches(data, "tui.select.up") ||
-              keybindings.matches(data, "tui.select.down") ||
-              keybindings.matches(data, "tui.select.confirm") ||
-              keybindings.matches(data, "tui.select.cancel")
-            ) {
-              if (selectList) {
-                selectList.handleInput(data);
-              } else if (keybindings.matches(data, "tui.select.cancel")) {
-                done(null);
+          return {
+            render(width: number) {
+              return container.render(width);
+            },
+            invalidate() {
+              container.invalidate();
+            },
+            handleInput(data: string) {
+              if (
+                keybindings.matches(data, "tui.select.up") ||
+                keybindings.matches(data, "tui.select.down") ||
+                keybindings.matches(data, "tui.select.confirm") ||
+                keybindings.matches(data, "tui.select.cancel")
+              ) {
+                if (selectList) {
+                  selectList.handleInput(data);
+                } else if (keybindings.matches(data, "tui.select.cancel")) {
+                  done(null);
+                }
+                tui.requestRender();
+                return;
               }
-              tui.requestRender();
-              return;
-            }
 
-            searchInput.handleInput(data);
-            applyFilter();
-            tui.requestRender();
-          },
-        };
-      },
-    );
+              searchInput.handleInput(data);
+              applyFilter();
+              tui.requestRender();
+            },
+          };
+        },
+      );
+    } else {
+      // Outside the TUI (RPC hosts like T3 Code) ctx.ui.custom resolves to
+      // undefined, so offer the branches as a plain select dialog. The
+      // fuzzy filter is lost — descriptions ride inline in the labels.
+      const { options, valueFor } = buildSelectOptions(items);
+      const selected = await ctx.ui.select("Select base branch", options);
+      result = selected === undefined ? null : (valueFor(selected) ?? null);
+    }
 
     if (!result) return null;
     return { type: "baseBranch", branch: result };
@@ -1455,109 +1541,129 @@ export default function reviewExtension(pi: ExtensionAPI) {
       description: "",
     }));
 
-    const result = await ctx.ui.custom<{ sha: string; title: string } | null>(
-      (tui, theme, keybindings, done) => {
-        const container = new Container();
-        container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
-        container.addChild(
-          new Text(theme.fg("accent", theme.bold("Select commit to review"))),
-        );
+    let result: { sha: string; title: string } | null;
+    if (ctx.mode === "tui") {
+      result = await ctx.ui.custom<{ sha: string; title: string } | null>(
+        (tui, theme, keybindings, done) => {
+          const container = new Container();
+          container.addChild(
+            new DynamicBorder((str) => theme.fg("accent", str)),
+          );
+          container.addChild(
+            new Text(theme.fg("accent", theme.bold("Select commit to review"))),
+          );
 
-        const searchInput = new Input();
-        container.addChild(searchInput);
-        container.addChild(new Spacer(1));
+          const searchInput = new Input();
+          container.addChild(searchInput);
+          container.addChild(new Spacer(1));
 
-        const listContainer = new Container();
-        container.addChild(listContainer);
-        container.addChild(
-          new Text(
-            theme.fg("dim", "Type to filter • enter to select • esc to cancel"),
-          ),
-        );
-        container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
+          const listContainer = new Container();
+          container.addChild(listContainer);
+          container.addChild(
+            new Text(
+              theme.fg(
+                "dim",
+                "Type to filter • enter to select • esc to cancel",
+              ),
+            ),
+          );
+          container.addChild(
+            new DynamicBorder((str) => theme.fg("accent", str)),
+          );
 
-        let filteredItems = items;
-        let selectList: SelectList | null = null;
+          let filteredItems = items;
+          let selectList: SelectList | null = null;
 
-        const updateList = () => {
-          listContainer.clear();
-          if (filteredItems.length === 0) {
-            listContainer.addChild(
-              new Text(theme.fg("warning", "  No matching commits")),
-            );
-            selectList = null;
-            return;
-          }
+          const updateList = () => {
+            listContainer.clear();
+            if (filteredItems.length === 0) {
+              listContainer.addChild(
+                new Text(theme.fg("warning", "  No matching commits")),
+              );
+              selectList = null;
+              return;
+            }
 
-          selectList = new SelectList(
-            filteredItems,
-            Math.min(filteredItems.length, 10),
-            {
-              selectedPrefix: (text) => theme.fg("accent", text),
-              selectedText: (text) => theme.fg("accent", text),
-              description: (text) => theme.fg("muted", text),
-              scrollInfo: (text) => theme.fg("dim", text),
-              noMatch: (text) => theme.fg("warning", text),
-            },
-          );
+            selectList = new SelectList(
+              filteredItems,
+              Math.min(filteredItems.length, 10),
+              {
+                selectedPrefix: (text) => theme.fg("accent", text),
+                selectedText: (text) => theme.fg("accent", text),
+                description: (text) => theme.fg("muted", text),
+                scrollInfo: (text) => theme.fg("dim", text),
+                noMatch: (text) => theme.fg("warning", text),
+              },
+            );
 
-          selectList.onSelect = (item) => {
-            const commit = commits.find((c) => c.sha === item.value);
-            if (commit) {
-              done(commit);
-            } else {
-              done(null);
-            }
+            selectList.onSelect = (item) => {
+              const commit = commits.find((c) => c.sha === item.value);
+              if (commit) {
+                done(commit);
+              } else {
+                done(null);
+              }
+            };
+            selectList.onCancel = () => done(null);
+            listContainer.addChild(selectList);
           };
-          selectList.onCancel = () => done(null);
-          listContainer.addChild(selectList);
-        };
 
-        const applyFilter = () => {
-          const query = searchInput.getValue();
-          filteredItems = query
-            ? fuzzyFilter(
-                items,
-                query,
-                (item) =>
-                  `${item.label} ${item.value} ${item.description ?? ""}`,
-              )
-            : items;
-          updateList();
-        };
+          const applyFilter = () => {
+            const query = searchInput.getValue();
+            filteredItems = query
+              ? fuzzyFilter(
+                  items,
+                  query,
+                  (item) =>
+                    `${item.label} ${item.value} ${item.description ?? ""}`,
+                )
+              : items;
+            updateList();
+          };
 
-        applyFilter();
+          applyFilter();
 
-        return {
-          render(width: number) {
-            return container.render(width);
-          },
-          invalidate() {
-            container.invalidate();
-          },
-          handleInput(data: string) {
-            if (
-              keybindings.matches(data, "tui.select.up") ||
-              keybindings.matches(data, "tui.select.down") ||
-              keybindings.matches(data, "tui.select.confirm") ||
-              keybindings.matches(data, "tui.select.cancel")
-            ) {
-              if (selectList) {
-                selectList.handleInput(data);
-              } else if (keybindings.matches(data, "tui.select.cancel")) {
-                done(null);
+          return {
+            render(width: number) {
+              return container.render(width);
+            },
+            invalidate() {
+              container.invalidate();
+            },
+            handleInput(data: string) {
+              if (
+                keybindings.matches(data, "tui.select.up") ||
+                keybindings.matches(data, "tui.select.down") ||
+                keybindings.matches(data, "tui.select.confirm") ||
+                keybindings.matches(data, "tui.select.cancel")
+              ) {
+                if (selectList) {
+                  selectList.handleInput(data);
+                } else if (keybindings.matches(data, "tui.select.cancel")) {
+                  done(null);
+                }
+                tui.requestRender();
+                return;
               }
-              tui.requestRender();
-              return;
-            }
 
-            searchInput.handleInput(data);
-            applyFilter();
-            tui.requestRender();
-          },
-        };
-      },
-    );
+              searchInput.handleInput(data);
+              applyFilter();
+              tui.requestRender();
+            },
+          };
+        },
+      );
+    } else {
+      // Outside the TUI (RPC hosts like T3 Code) ctx.ui.custom resolves to
+      // undefined, so offer the recent commits as a plain select dialog.
+      const { options, valueFor } = buildSelectOptions(
+        items.map((item) => ({ value: item.value, label: item.label })),
+      );
+      const selected = await ctx.ui.select("Select commit to review", options);
+      const sha = selected === undefined ? undefined : valueFor(selected);
+      const commit = commits.find((c) => c.sha === sha);
+      result = commit ? { sha: commit.sha, title: commit.title } : null;
+    }
 
     if (!result) return null;
     return { type: "commit", sha: result.sha, title: result.title };
@@ -1932,7 +2038,9 @@ Instructions:
     originId: string,
     showLoader: boolean,
   ): Promise<{ cancelled: boolean; error?: string } | null> {
-    if (showLoader && ctx.hasUI) {
+    // The loader is a ctx.ui.custom component, which only renders in the
+    // TUI; RPC hosts (T3 Code) get undefined back, so there navigate directly.
+    if (showLoader && ctx.mode === "tui") {
       return ctx.ui.custom<{ cancelled: boolean; error?: string } | null>(
         (tui, theme, _kb, done) => {
           const loader = new BorderedLoader(
@@ -2125,9 +2233,9 @@ Instructions:
     endReviewInProgress = true;
     try {
       const choice = await ctx.ui.select("Finish review:", [
-        "Return only",
         "Return and fix findings",
         "Return and summarize",
+        "Return only",
       ]);
 
       if (choice === undefined) {

package/side.ts

@@ -15,7 +15,8 @@
  * - /side-exit navigates back to the recorded tip, restores the main model,
  *   and hands the main agent the side conversation — also as an attributed
  *   quote — with the mode chosen at exit: trajectory (full transcript),
- *   summary (the side model summarizes), or nothing.
+ *   summary (the side model summarizes, shown as a cancellable progress
+ *   widget above the editor), or nothing.
  *
  * Durability: handoffs are appended as custom-message entries via
  * sendMessage({ triggerTurn: false }) while idle, which writes the session
@@ -636,10 +637,24 @@ function refreshSideLens(ctx: ExtensionContext): void {
   setSideLensTokens(tokens);
 }
 
+/**
+ * The summarizer's completion resolved with stopReason "aborted" (partial
+ * text after an Esc) instead of rejecting — the caller's abort-signal check
+ * never fires on that path, so this sentinel carries the cancel out to the
+ * SummaryOutcome boundary below.
+ */
+class SummaryAbortedError extends Error {
+  constructor() {
+    super("side model summary was aborted");
+    this.name = "SummaryAbortedError";
+  }
+}
+
 async function summarizeDelta(
   ctx: ExtensionCommandContext,
   sideModel: ModelRef,
   transcript: string,
+  signal?: AbortSignal,
 ): Promise<string> {
   const model = ctx.modelRegistry.find(sideModel.provider, sideModel.id);
   if (!model) {
@@ -647,22 +662,116 @@ async function summarizeDelta(
       `${modelRef(sideModel)} is no longer available to summarize — use trajectory or nothing`,
     );
   }
-  const response = await ctx.modelRegistry.complete(model, {
-    messages: [
-      {
-        role: "user",
-        timestamp: Date.now(),
-        content: [
-          { type: "text", text: `${SUMMARY_INSTRUCTIONS}\n\n${transcript}` },
-        ],
-      },
-    ],
-  });
+  const response = await ctx.modelRegistry.complete(
+    model,
+    {
+      messages: [
+        {
+          role: "user",
+          timestamp: Date.now(),
+          content: [
+            { type: "text", text: `${SUMMARY_INSTRUCTIONS}\n\n${transcript}` },
+          ],
+        },
+      ],
+    },
+    { signal },
+  );
   const text = extractTextParts(response.content).join("\n").trim();
+  // complete() RESOLVES failed and aborted calls (providers mark stopReason
+  // "error" or "aborted" and keep the partial text) rather than rejecting.
+  // Left alone, a truncated reply would reach the main agent as a finished
+  // summary. "aborted" becomes the cancel sentinel; "error" becomes a real
+  // failure so it rides the fail-closed exit path with the provider's message.
+  if (response.stopReason === "aborted") throw new SummaryAbortedError();
+  if (response.stopReason === "error") {
+    throw new Error(
+      `side model summary failed: ${response.errorMessage ?? "unknown error"}`,
+    );
+  }
   if (!text) throw new Error("side model returned an empty summary");
   return text;
 }
 
+type SummaryOutcome =
+  | { ok: true; text: string }
+  | { ok: false; cancelled: true }
+  | { ok: false; cancelled: false; error: unknown };
+
+const SUMMARIZE_WIDGET_KEY = "bermudis-pi-goodies.side-summarize";
+
+/** Fallback budget when there is no TTY to measure (tests, piped output). */
+const WIDGET_LINE_FALLBACK_WIDTH = 80;
+
+/**
+ * Visible budget for the summarize progress line. Pi renders string-array
+ * widgets as Text(line, 1, 0) — one column of side padding — so the line
+ * wraps past (terminal width − 2). Without a TTY fall back to the
+ * historical 80 and never grow past it, so known-width terminals only ever
+ * truncate harder (same pattern as clean-tui's bashLineCap).
+ */
+function widgetLineCap(): number {
+  const cols = process.stdout.columns;
+  if (typeof cols !== "number" || cols <= 0)
+    return WIDGET_LINE_FALLBACK_WIDTH;
+  return Math.max(20, Math.min(WIDGET_LINE_FALLBACK_WIDTH, cols - 2));
+}
+
+/** Widget lines render above the editor; stay single-line on narrow terminals. */
+function truncateWidgetLine(text: string, max = widgetLineCap()): string {
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+/**
+ * Exit summarization with visible, cancellable UI: a progress widget above
+ * the editor for the whole call, Esc to abort. The picker closes the moment
+ * the mode is chosen; without these the UI then sits silent until the model
+ * answers, which reads as a freeze on long consultations.
+ *
+ * setWidget/onTerminalInput are optional-called because harness stubs and
+ * limited (non-interactive) contexts lack them; headless keeps the old
+ * no-feedback behavior, which is all it ever had.
+ */
+export async function summarizeWithProgress(
+  ctx: ExtensionCommandContext,
+  sideModel: ModelRef,
+  transcript: string,
+  turnCount: number,
+): Promise<SummaryOutcome> {
+  const abort = new AbortController();
+  const turns = `${turnCount} ${turnCount === 1 ? "turn" : "turns"}`;
+  const line = truncateWidgetLine(
+    `⟳ summarizing side consultation (${turns}) with ${modelRef(sideModel)} — esc cancels`,
+  );
+  const unsubscribe = ctx.ui?.onTerminalInput?.((data) => {
+    // A bare Esc arrives as exactly "\x1b" (pi's stdin buffer flushes a lone
+    // ESC after its escape timeout); sequences like arrow keys arrive as
+    // longer chunks and pass through untouched.
+    if (data === "\x1b") {
+      abort.abort();
+      return { consume: true };
+    }
+    return undefined;
+  });
+  ctx.ui?.setWidget?.(SUMMARIZE_WIDGET_KEY, [line]);
+  try {
+    const text = await summarizeDelta(ctx, sideModel, transcript, abort.signal);
+    return { ok: true, text };
+  } catch (error) {
+    // Cancellation reaches here two ways: our own Esc (signal aborted, which
+    // may surface as a rejection or a resolved "aborted" message that
+    // summarizeDelta turns into the sentinel). Either way the user asked to
+    // stop, so it rides the stay-in-side-session path. Every other error,
+    // including a resolved "error" message, rides the fail-closed exit path.
+    if (abort.signal.aborted || error instanceof SummaryAbortedError)
+      return { ok: false, cancelled: true };
+    return { ok: false, cancelled: false, error };
+  } finally {
+    unsubscribe?.();
+    ctx.ui?.setWidget?.(SUMMARIZE_WIDGET_KEY, undefined);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Extension entry point
 // ---------------------------------------------------------------------------
@@ -1024,20 +1133,28 @@ export default function side(pi: ExtensionAPI): void {
       // mode (fail-closed) rather than exiting empty-handed.
       let summaryText: string | undefined;
       if (mode === "summary" && deltaTurns.length > 0) {
-        try {
-          summaryText = await summarizeDelta(
-            ctx,
-            effectiveSide,
-            renderTrajectory(deltaTurns),
-          );
-        } catch (error) {
-          logGoodiesEvent({
-            type: "side_summary_failed",
-            error: describeError(error),
-          });
-          ctx.ui.notify(`side-exit: ${describeError(error)}`, "error");
+        const result = await summarizeWithProgress(
+          ctx,
+          effectiveSide,
+          renderTrajectory(deltaTurns),
+          deltaTurns.length,
+        );
+        if (!result.ok) {
+          if (result.cancelled) {
+            ctx.ui.notify(
+              "side-exit: summarization cancelled — still in the side session",
+              "warning",
+            );
+          } else {
+            logGoodiesEvent({
+              type: "side_summary_failed",
+              error: describeError(result.error),
+            });
+            ctx.ui.notify(`side-exit: ${describeError(result.error)}`, "error");
+          }
           return;
         }
+        summaryText = result.text;
       }
 
       const result = await ctx.navigateTree(marker.data.mainTipId, {

package/zed.ts

@@ -1,38 +0,0 @@
-/**
- * /z — Open Zed editor on cwd.
- */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { spawn } from "node:child_process";
-
-export default function (pi: ExtensionAPI) {
-  // Arch packages the CLI as "zeditor"
-  const zedBin = process.platform === "linux" ? "zeditor" : "zed";
-
-  pi.registerCommand("z", {
-    description: "Open Zed editor on cwd (new window)",
-    handler: async (_args, ctx) => {
-      const child = spawn(zedBin, ["--new", ctx.cwd], {
-        detached: true,
-        stdio: "ignore",
-      });
-      child.on("error", (err) => {
-        const code = (err as NodeJS.ErrnoException).code;
-        if (code === "ENOENT") {
-          ctx.ui.notify(
-            `Zed not found: \`${zedBin}\` is not installed or not on PATH`,
-            "error",
-          );
-        } else {
-          ctx.ui.notify(`Failed to open Zed: ${err.message}`, "error");
-        }
-      });
-      // Only announce once the process has actually started — spawn()'s
-      // 'error' event fires asynchronously, so notifying synchronously would
-      // show "Opening Zed" before a missing-binary error lands.
-      child.on("spawn", () => {
-        ctx.ui.notify(`Opening Zed: ${ctx.cwd}`, "info");
-      });
-      child.unref();
-    },
-  });
-}