bermudis-pi-goodies 0.27.1 → 0.27.3

package/README.md

@@ -8,7 +8,6 @@ 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
@@ -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.1
+pi install npm:bermudis-pi-goodies@0.27.3
 ```
 
 Picking up a new release on an existing install (`pi install` is not the
@@ -438,10 +437,13 @@ Details worth knowing:
   path. (`deliverAs: "nextTurn"` would only queue in memory and die with
   the process.)
 - The footer's context-usage estimate reflects the raw session branch, not
-  the lens output, so it over-reports while a side session is active — by
-  the full uncompacted main history at worst, shrinking after compaction
-  (the lens renders compaction summaries into the quote rather than
-  resending summarized-away turns). Compaction summaries that cover side
+  the lens output, so it can over-report while a side session is active.
+  Threshold auto-compaction is vetoed when the **lensed side request**
+  fits the side model's window (including system/tool overhead and the
+  configured token reserve), rather than trusting the main model's usage.
+  The quoted main transcript still counts toward that window. Manual
+  `/compact` and actual context-overflow recovery remain available.
+  Compaction summaries that cover side
   turns are quoted with an explicit who-is-who caveat instead of passing as
   the consultant's own history.
 - Both quote directions carry an explicit untrusted-evidence preamble:

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.1",
+  "version": "0.27.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bermudi/agent-extensions.git",

package/review.ts

@@ -2125,9 +2125,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
@@ -28,11 +29,10 @@
  * limb that is ever resumed delivers only newer turns. v1 always starts a
  * fresh side limb, but the bookkeeping keeps that future-safe.
  *
- * Known limitation: pi's footer context-usage estimate (and its pre-send
- * compaction threshold) reflect the raw session branch, not the lens
- * output — the footer over-reports while a side session is active, and
- * premature auto-compaction is possible on large side consults (the lens
- * is compaction-aware and survives it; the main limb is never touched).
+ * Pi's footer context-usage estimate reflects the raw session branch, not
+ * the lens output, so the footer over-reports during side sessions. A
+ * session_before_compact guard vetoes threshold compaction when the lensed
+ * request fits; manual compaction and actual overflow recovery still run.
  * The side badge carries pi's own estimator applied to the lensed messages
  * ("· ~46k lensed") as the honest counterpoint to the inflated figure.
  */
@@ -44,11 +44,14 @@ import type {
   ExtensionCommandContext,
   ExtensionContext,
   SessionEntry,
+  ToolInfo,
 } from "@earendil-works/pi-coding-agent";
 import {
   ModelSelectorComponent,
+  calculateContextTokens,
   estimateTokens,
   sessionEntryToContextMessages,
+  shouldCompact,
 } from "@earendil-works/pi-coding-agent";
 import { describeError, extractTextParts } from "./json-file.ts";
 import { buildTrajectory, renderTrajectory } from "./copy-trajectory.ts";
@@ -321,6 +324,50 @@ export function estimateLensedContextTokens(
   return messages.reduce((sum, message) => sum + estimateTokens(message), 0);
 }
 
+/**
+ * Conservative side-request budget. Main-model usage cannot leak into this
+ * estimate: its assistant turns have already become quoted user text.
+ * Include system/tool overhead before the first side response, and trust
+ * valid SIDE usage as a floor (it includes provider-visible overhead).
+ */
+export function estimateSideCompactionTokens(
+  messages: ContextEvent["messages"],
+  systemPrompt: string,
+  tools: readonly Pick<ToolInfo, "name" | "description" | "parameters">[],
+  rawBranch: readonly SessionEntry[],
+): number {
+  // Kept responses still carry pre-compaction usage. Match by source
+  // message identity, not timestamp: branch order is the provenance Pi uses.
+  const lastInvalidation = rawBranch.findLastIndex(
+    (entry) => entry.type === "compaction" || entry.type === "context_edit",
+  );
+  const validUsageMessages = new Set(
+    rawBranch
+      .slice(lastInvalidation + 1)
+      .flatMap((entry) => sessionEntryToContextMessages(entry)),
+  );
+  const estimated =
+    messages.reduce((sum, message) => sum + estimateTokens(message), 0) +
+    Math.ceil(systemPrompt.length / 4) +
+    Math.ceil(JSON.stringify(tools).length / 4);
+  let trailing = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i]!;
+    if (
+      message.role === "assistant" &&
+      validUsageMessages.has(message) &&
+      message.stopReason !== "error" &&
+      message.stopReason !== "aborted" &&
+      message.usage
+    ) {
+      const usage = calculateContextTokens(message.usage);
+      if (usage > 0) return Math.max(estimated, usage + trailing);
+    }
+    trailing += estimateTokens(message);
+  }
+  return estimated;
+}
+
 // ---------------------------------------------------------------------------
 // Handoff: what the main agent is given at exit
 // ---------------------------------------------------------------------------
@@ -590,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) {
@@ -601,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
 // ---------------------------------------------------------------------------
@@ -627,6 +782,52 @@ let modelRegistryRef: ExtensionContext["modelRegistry"] | undefined;
 let lastBadgeCtx: ExtensionContext | undefined;
 
 export default function side(pi: ExtensionAPI): void {
+  // Pi checks the raw projection BEFORE emitting `context`. Recheck the
+  // same threshold against our lens at its supported cancellation boundary.
+  // Never veto manual compaction or a real provider overflow.
+  pi.on("session_before_compact", (event, ctx) => {
+    if (event.reason !== "threshold" || !ctx.model) return;
+    const raw = ctx.sessionManager.getBranch();
+    const markerIdx = findSideBoundary(raw);
+    const marker = raw[markerIdx];
+    if (marker?.type !== "custom" || !parseSideMarkerData(marker.data)) return;
+    const messages = buildLensMessages(
+      ctx.sessionManager.buildContextEntries(),
+      raw,
+      markerIdx,
+      [],
+    );
+    if (!messages || ctx.model.contextWindow <= 0) return;
+    const activeTools = new Set(pi.getActiveTools());
+    const tokens = estimateSideCompactionTokens(
+      messages,
+      ctx.getSystemPrompt(),
+      pi
+        .getAllTools()
+        .filter((tool) => activeTools.has(tool.name))
+        .map(({ name, description, parameters }) => ({
+          name,
+          description,
+          parameters,
+        })),
+      raw,
+    );
+    const needed = shouldCompact(
+      tokens,
+      ctx.model.contextWindow,
+      event.preparation.settings,
+    );
+    logGoodiesEvent({
+      type: "side_compaction_check",
+      raw_tokens: event.preparation.tokensBefore,
+      side_tokens: tokens,
+      context_window: ctx.model.contextWindow,
+      reserve_tokens: event.preparation.settings.reserveTokens,
+      cancelled: !needed,
+    });
+    if (!needed) return { cancel: true };
+  });
+
   // Lens: rewrite side-agent requests so the main trajectory arrives as an
   // attributed quote instead of the side model's own history. Detection uses
   // the raw branch (the marker is always an ancestor there); content uses
@@ -932,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();
-    },
-  });
-}