bermudis-pi-goodies 0.27.0 → 0.27.2

package/README.md

@@ -23,10 +23,17 @@ extensions. One entry point, thirteen independent features.
 
 ## Install
 
-After publishing the package to npm:
+First install, pinned to a published version:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.27.0
+pi install npm:bermudis-pi-goodies@0.27.2
+```
+
+Picking up a new release on an existing install (`pi install` is not the
+update path):
+
+```bash
+pi update --extensions
 ```
 
 Remove any old `bermudis-pi-goodies.ts` symlink before reloading Pi. Each
@@ -431,10 +438,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/package.json

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

package/side.ts

@@ -28,11 +28,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 +43,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 +323,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
 // ---------------------------------------------------------------------------
@@ -627,6 +673,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

package/vision-core.ts

@@ -1,14 +1,16 @@
 /**
  * vision-core — pure logic for the `vision` tool.
  *
- * No pi imports: structural types stand in for pi's registry/model objects so
- * this module (and its tests) run under plain `bun` without a pi install.
+ * No pi runtime imports: structural types stand in for registry/model objects.
+ * The request context uses pi's types so incomplete replay messages cannot
+ * silently cross the completion boundary.
  * index.ts wires these against the real pi APIs.
  */
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, extname, join, resolve } from "node:path";
+import type { Context, Message } from "@earendil-works/pi-ai/compat";
 
 // --- structural stand-ins for pi types ---------------------------------------
 
@@ -16,6 +18,7 @@ import { dirname, extname, join, resolve } from "node:path";
 export interface ModelLike {
   id: string;
   provider: string;
+  api: string;
   input: string[];
 }
 
@@ -558,9 +561,10 @@ export const VISION_SYSTEM_PROMPT = [
 export function buildVisionContext(
   prompt: string,
   image: { data: string; mimeType: string },
+  model: ModelLike,
   history: StoredTurn[] = [],
-): object {
-  const past = history.flatMap((turn) => [
+): Context {
+  const past = history.flatMap<Message>((turn) => [
     {
       role: "user",
       content: [{ type: "text", text: turn.question }],
@@ -569,6 +573,21 @@ export function buildVisionContext(
     {
       role: "assistant",
       content: [{ type: "text", text: turn.answer }],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      stopReason: "stop",
+      // These are text-only replays, not the original provider responses.
+      // Zero usage makes Pi estimate this request's actual content instead of
+      // treating a previous request's token count as an authoritative prefix.
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+      },
       timestamp: Date.now(),
     },
   ]);
@@ -644,7 +663,7 @@ export interface VisionToolDeps {
   /** pi-ai completeSimple (injected so tests stub it). */
   complete(
     model: ModelLike,
-    context: object,
+    context: Context,
     options: {
       apiKey?: string;
       headers?: Record<string, string | null>;
@@ -760,6 +779,7 @@ export async function runVisionTool(
           data: image.data as string,
           mimeType: image.mimeType as string,
         },
+        transport.model,
         history,
       ),
       {

package/vision.ts

@@ -133,6 +133,13 @@ function questionPreview(prompt: unknown, cap: number): string {
   return head;
 }
 
+/** Expanded views show the raw truth: the whole prompt, uncapped — the cap
+ *  is a compact-view aid, and ctrl+o exists to reveal what was actually
+ *  asked (bash's expanded-command rule; multi-line renders multi-line). */
+function fullQuestion(prompt: unknown): string {
+  return typeof prompt === "string" ? prompt : "";
+}
+
 /** Answer text of a recorded vision result (its content is one text block). */
 function answerText(result: unknown): string {
   const content = (result as { content?: Array<{ text?: string }> } | undefined)
@@ -160,8 +167,10 @@ const visionBurstSpec = {
         // Read-view rule: info that is missing is skipped, never rendered as
         // junk (no `: ""` when a prompt is absent) — and long answers get the
         // same 12-line preview + "... N more lines" note as every other tool.
+        // Details render only when expanded, so questions show uncapped
+        // (same rule as bash's expanded details).
         const follow = e.args.followUp ? " (follow-up)" : "";
-        const q = questionPreview(e.args.prompt, 90);
+        const q = fullQuestion(e.args.prompt);
         const label = `— ${shortenPath(e.args.path || "...")}${follow}${q ? `: "${q}"` : ""}`;
         if (!e.result) return `\n${theme.fg("warning", `${label} (pending)`)}`;
         const txt = answerText(e.result);
@@ -170,9 +179,14 @@ const visionBurstSpec = {
       })
       .join("");
   },
-  soloHeader(args: any, theme: any) {
+  soloHeader(args: any, theme: any, ctx: any) {
     const follow = args.followUp ? theme.fg("muted", " (follow-up)") : "";
-    const q = questionPreview(args.prompt, 90);
+    // Expanded shows the full question, uncapped — the 90-char preview is a
+    // compact-view aid, and the whole point of ctrl+o is to reveal what was
+    // actually asked (same rule as bash's expanded command).
+    const q = ctx?.expanded
+      ? fullQuestion(args.prompt)
+      : questionPreview(args.prompt, 90);
     return `${theme.fg("toolTitle", theme.bold("vision"))} ${theme.fg("accent", shortenPath(args.path || "..."))}${follow}${q ? ` ${theme.fg("toolOutput", `"${q}"`)}` : ""}`;
   },
   soloExpanded(entry: any, _args: any, theme: any) {
@@ -367,18 +381,14 @@ export default function (pi: ExtensionAPI): void {
             ) as Promise<{ content: ContentBlockLike[]; isError?: boolean }>,
           readRaw: readRawImage,
           complete: (model, context, options) =>
-            completeSimple(
-              model as never,
-              context as never,
-              {
-                apiKey: options.apiKey,
-                headers: options.headers,
-                maxTokens: options.maxTokens,
-                signal: options.signal,
-                timeoutMs: 120_000,
-                maxRetries: 1,
-              } as never,
-            ) as Promise<never>,
+            completeSimple(model as never, context, {
+              apiKey: options.apiKey,
+              headers: options.headers,
+              maxTokens: options.maxTokens,
+              signal: options.signal,
+              timeoutMs: 120_000,
+              maxRetries: 1,
+            } as never) as Promise<never>,
         },
         (text) =>
           onUpdate?.({