pi-sessions 0.12.1 → 0.13.1

package/README.md

@@ -34,7 +34,7 @@
 
 ## Install
 
-Requires Pi `0.82.1` or newer and Node `>=24 <26`.
+Requires Pi `0.87.1` or newer and Node `>=24 <26`.
 
 **From npm** (recommended):
 
@@ -157,18 +157,21 @@ If you want to override the shortcut, put this in your `~/.pi/agent/settings.jso
 
 `deferred.copyToClipboard` (default `true`) controls whether deferred handoffs copy the resume command to the clipboard. When off, the resume command is only shown in the tool call.
 
-Subagents require the handoff and messaging features. Limit recursive delegation depth with `sessions.subagents.maxDepth` (default `2`):
+Subagents require the handoff and messaging features. Limit recursive delegation depth with `sessions.subagents.maxDepth` (default `2`), or cap the context a subagent runs in with `sessions.subagents.contextLimit`:
 
 ```json
 {
   "sessions": {
     "subagents": {
-      "maxDepth": 2
+      "maxDepth": 2,
+      "contextLimit": 400000
     }
   }
 }
 ```
 
+`contextLimit` sets a max context limit before compaction is triggered. It works identically to setting a global value in pi itself, but only applies to subagents.
+
 ## Session Index
 
 By default, `pi-sessions` will start indexing all conversations moving forward. If you want to backfill all prior conversations:

package/extensions/pi-sessions.ts

@@ -17,7 +17,7 @@ import {
 import { installSearch } from "./session-search/install.ts";
 import type { SessionLifecycle } from "./shared/composition.ts";
 import { createSessionModelRuntime, type ModelRuntimeProvider } from "./shared/model-runtime.ts";
-import { loadSettings } from "./shared/settings.ts";
+import { loadSettings, readCompactionSettings } from "./shared/settings.ts";
 import { installSubagents } from "./subagents/install.ts";
 
 /**
@@ -55,7 +55,7 @@ export default function piSessions(pi: ExtensionAPI): void {
   }
   const subagents =
     settings.features.subagents && messaging
-      ? installSubagents(pi, { settings, messaging })
+      ? installSubagents(pi, { settings, messaging, readCompactionSettings })
       : undefined;
   if (subagents) {
     lifecycles.push(subagents);
@@ -63,11 +63,17 @@ export default function piSessions(pi: ExtensionAPI): void {
   if (messaging) {
     pi.registerTool(
       createSessionSendMessageTool(subagents ?? messaging, {
-        wakeCapable: Boolean(subagents),
+        role: subagents ? { kind: "wakeCapable" } : { kind: "plain" },
         getCachedRelationTo: messaging.getCachedRelationTo,
+        ...(subagents ? { getParentSessionId: () => subagents.getParentSessionId() } : {}),
+      }),
+    );
+    pi.registerTool(
+      createSessionCancelTool(subagents ?? messaging, {
+        role: { kind: "plain" },
+        ...(subagents ? { getParentSessionId: () => subagents.getParentSessionId() } : {}),
       }),
     );
-    pi.registerTool(createSessionCancelTool(subagents ?? messaging));
     pi.registerTool(
       createSessionReachableTool({
         indexPath: index.path,
@@ -76,6 +82,7 @@ export default function piSessions(pi: ExtensionAPI): void {
         ...(subagents
           ? {
               listSubagents: async (scope) => (await subagents.roster.resolve(scope)).entries,
+              getParentSessionId: () => subagents.getParentSessionId(),
             }
           : {}),
       }),
@@ -104,7 +111,14 @@ export default function piSessions(pi: ExtensionAPI): void {
     installSearch(pi, { settings, index });
   }
   if (settings.features.ask) {
-    installAsk(pi, { settings, index, getModelRuntime });
+    installAsk(pi, {
+      settings,
+      index,
+      getModelRuntime,
+      ...(subagents
+        ? { shouldMessageSubagent: (sessionId) => subagents.shouldMessageSubagent(sessionId) }
+        : {}),
+    });
   }
   if (settings.features.autoTitle) {
     lifecycles.push(
@@ -116,7 +130,7 @@ export default function piSessions(pi: ExtensionAPI): void {
     );
   }
   if (settings.features.hooks) {
-    lifecycles.push(installHooks(pi, { settings, index }));
+    lifecycles.push(installHooks(pi, { index }));
   }
   // Messaging leads every session_start so the broker connection is registered before any
   // other feature hook runs. A side effect is that messaging's first relation snapshot can

package/extensions/session-ask/install.ts

@@ -29,6 +29,7 @@ export function installAsk(
     settings: SessionSettings;
     index: IndexHandle;
     getModelRuntime: ModelRuntimeProvider;
+    shouldMessageSubagent?: (sessionId: string) => Promise<boolean>;
   },
 ): void {
   const { settings } = deps;
@@ -37,15 +38,22 @@ export function installAsk(
   pi.registerTool({
     name: "session_ask",
     label: "Session Ask",
-    description: "Interrogate a Pi session",
+    description: "Interrogate a Pi session transcript",
     promptSnippet: "Recall information, decisions, or reasoning from a Pi session by id",
-    promptGuidelines: ["Use session_ask with focused questions rather than broad recap requests."],
+    promptGuidelines: [
+      "Use session_ask with focused questions rather than broad recap requests.",
+      ...(deps.shouldMessageSubagent
+        ? [
+            "Use session_send_message for your unfinished subagents; session_ask can read completed subagent transcripts.",
+          ]
+        : []),
+    ],
     parameters: Type.Object({
       session: Type.String({
         description: "Bare UUID for the session",
       }),
       question: Type.String({
-        description: "What to extract, verify, or explain from that session",
+        description: "What to find in that session's transcript",
       }),
     }),
     async execute(_toolCallId, params: SessionAskToolParams, signal, onUpdate, ctx) {
@@ -59,6 +67,19 @@ export function installAsk(
         throw new Error("session_ask requires a question.");
       }
 
+      if (!isExactSessionId(sessionId)) {
+        throw new Error(
+          "session_ask requires an exact session UUID. Use autocomplete or session_search to find it.",
+        );
+      }
+
+      // Unfinished children may not have reached the index yet.
+      if (await deps.shouldMessageSubagent?.(sessionId)) {
+        throw new Error(
+          "That session is your unfinished subagent. Use session_send_message to ask it directly.",
+        );
+      }
+
       const resolvedTarget = resolveSessionAskTarget(sessionId, indexPath);
       if (!resolvedTarget.resolved) {
         throw new Error(resolvedTarget.error ?? "Unable to resolve session id.");
@@ -182,13 +203,6 @@ function resolveSessionAskTarget(
   resolved?: SessionLineageRow | undefined;
   error?: string | undefined;
 } {
-  if (!isExactSessionId(sessionId)) {
-    return {
-      error:
-        "session_ask requires an exact session UUID. Use autocomplete or session_search to find it.",
-    };
-  }
-
   try {
     return withSessionIndex(indexPath, { mode: "read", required: true }, ({ db }) => {
       const row = getSessionById(db, sessionId);

package/extensions/session-auto-title/generate.ts

@@ -1,6 +1,6 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Api, Model, TextContent, UserMessage } from "@earendil-works/pi-ai";
-import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { AutoTitleContext } from "./context.ts";
 import { type AutoTitleRun, startAutoTitleRun } from "./runs.ts";
 import type { AutoTitleTrigger } from "./state.ts";
@@ -33,7 +33,7 @@ export type AutoTitleGenerationResult =
     };
 
 export async function generateAutoTitle(
-  modelRuntime: ModelRuntime,
+  modelRegistry: ModelRegistry,
   model: Model<Api>,
   context: AutoTitleContext,
   trigger: AutoTitleTrigger,
@@ -78,18 +78,21 @@ export async function generateAutoTitle(
     : undefined;
 
   try {
-    const response = await modelRuntime.completeSimple(
-      model,
-      {
-        systemPrompt: resolvedSystemPrompt,
-        messages: [message],
-      },
-      {
-        maxTokens: generation.tokenBudget,
-        ...(thinkingLevel && thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
-        signal: abortController.signal,
-      },
-    );
+    const response = await modelRegistry
+      .streamSimple(
+        model,
+        {
+          systemPrompt: resolvedSystemPrompt,
+          messages: [message],
+        },
+        {
+          maxTokens: generation.tokenBudget,
+          ...(thinkingLevel && thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
+          signal: abortController.signal,
+          cacheRetention: "none",
+        },
+      )
+      .result();
     run?.recordResponse(response);
 
     if (response.stopReason === "error" || response.stopReason === "aborted") {

package/extensions/session-auto-title/install.ts

@@ -3,7 +3,6 @@ import type {
   ExtensionAPI,
   ExtensionCommandContext,
   ExtensionContext,
-  ModelRuntime,
   TurnEndEvent,
 } from "@earendil-works/pi-coding-agent";
 import type { SessionLifecycle } from "../shared/composition.ts";
@@ -82,7 +81,6 @@ export function installAutoTitle(
             },
           },
           ctx,
-          modelRuntime,
           resolution?.model,
           invocation,
           buildGeneration(resolution),
@@ -105,7 +103,6 @@ export function installAutoTitle(
       pi,
       controller,
       ctx,
-      modelRuntime,
       model: resolution?.model,
       isManual: false,
       existingPlan: result.plan,
@@ -147,7 +144,6 @@ async function handleTitleInvocation(
   pi: ExtensionAPI,
   state: TitleRunState,
   ctx: ExtensionCommandContext,
-  modelRuntime: ModelRuntime,
   model: Model<Api> | undefined,
   invocation: RetitleCommandInvocation,
   generation: AutoTitleGeneration,
@@ -156,7 +152,6 @@ async function handleTitleInvocation(
     pi,
     controller: state.controller,
     ctx,
-    modelRuntime,
     model,
     isManual: true,
     generation,
@@ -178,15 +173,7 @@ async function handleTitleInvocation(
       return retitleCurrentSession();
     }
 
-    return showRetitleWizard(
-      pi,
-      state.controller,
-      ctx,
-      modelRuntime,
-      model,
-      state.getSessionEpoch,
-      generation,
-    );
+    return showRetitleWizard(pi, state.controller, ctx, model, state.getSessionEpoch, generation);
   }
 
   if (invocation.scope === "this") {
@@ -194,21 +181,12 @@ async function handleTitleInvocation(
   }
 
   if (isTuiMode(ctx) && !invocation.force) {
-    return showRetitleWizard(
-      pi,
-      state.controller,
-      ctx,
-      modelRuntime,
-      model,
-      state.getSessionEpoch,
-      generation,
-      {
-        initialInvocation: {
-          scope: invocation.scope,
-          mode: invocation.mode ?? "backfill",
-        },
+    return showRetitleWizard(pi, state.controller, ctx, model, state.getSessionEpoch, generation, {
+      initialInvocation: {
+        scope: invocation.scope,
+        mode: invocation.mode ?? "backfill",
       },
-    );
+    });
   }
 
   const scan = await buildRetitleScopeScan(ctx, invocation.scope);
@@ -218,7 +196,6 @@ async function handleTitleInvocation(
       pi,
       state.controller,
       ctx,
-      modelRuntime,
       model,
       scan,
       mode,

package/extensions/session-auto-title/retitle.ts

@@ -3,7 +3,6 @@ import type {
   ExtensionAPI,
   ExtensionCommandContext,
   ExtensionContext,
-  ModelRuntime,
   SessionInfo,
 } from "@earendil-works/pi-coding-agent";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
@@ -55,7 +54,6 @@ export async function runBulkRetitle(
   pi: ExtensionAPI,
   controller: SessionAutoTitleController,
   ctx: ExtensionCommandContext,
-  modelRuntime: ModelRuntime,
   model: Model<Api> | undefined,
   scan: RetitleScopeScan,
   mode: RetitleMode,
@@ -85,7 +83,6 @@ export async function runBulkRetitle(
         pi,
         controller,
         ctx,
-        modelRuntime,
         model,
         isManual: true,
         generation,
@@ -96,7 +93,7 @@ export async function runBulkRetitle(
       continue;
     }
 
-    const outcome = await retitleStoredSession(modelRuntime, model, session.path, generation);
+    const outcome = await retitleStoredSession(ctx.modelRegistry, model, session.path, generation);
     result[outcome] += 1;
   }
 
@@ -166,7 +163,6 @@ export interface RetitlePlanOptions {
   pi: ExtensionAPI;
   controller: SessionAutoTitleController;
   ctx: ExtensionContext;
-  modelRuntime: ModelRuntime;
   model: Model<Api> | undefined;
   isManual: boolean;
   generation: AutoTitleGeneration;
@@ -178,17 +174,8 @@ export interface RetitlePlanOptions {
 export async function runRetitlePlan(
   options: RetitlePlanOptions,
 ): Promise<AutoTitleGenerationResult> {
-  const {
-    pi,
-    controller,
-    ctx,
-    modelRuntime,
-    model,
-    isManual,
-    generation,
-    existingPlan,
-    getSessionEpoch,
-  } = options;
+  const { pi, controller, ctx, model, isManual, generation, existingPlan, getSessionEpoch } =
+    options;
   const notifyOnSuccess = options.notifyOnSuccess ?? isManual;
 
   const plan = existingPlan ?? controller.handleManualRetitle(ctx);
@@ -220,7 +207,7 @@ export async function runRetitlePlan(
     },
   );
   const generatedTitle = await generateAutoTitle(
-    modelRuntime,
+    ctx.modelRegistry,
     model,
     titleContext,
     plan.reason,
@@ -267,7 +254,7 @@ export function persistAutoTitleState(
 }
 
 async function retitleStoredSession(
-  modelRuntime: ModelRuntime,
+  modelRegistry: ExtensionContext["modelRegistry"],
   model: Model<Api>,
   sessionPath: string,
   generation: AutoTitleGeneration,
@@ -288,7 +275,7 @@ async function retitleStoredSession(
     currentTitle,
   };
   const generatedTitle = await generateAutoTitle(
-    modelRuntime,
+    modelRegistry,
     model,
     titleContext,
     plan.reason,

package/extensions/session-auto-title/wizard.ts

@@ -3,11 +3,11 @@ import {
   copyToClipboard,
   type ExtensionAPI,
   type ExtensionCommandContext,
-  type ModelRuntime,
   type Theme,
 } from "@earendil-works/pi-coding-agent";
-import type { Focusable, TUI } from "@earendil-works/pi-tui";
+import type { Focusable, TUI, TuiMouseEvent, TuiMouseEventResult } from "@earendil-works/pi-tui";
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { LegendPointer } from "../shared/legend.ts";
 import type { RetitleCommandOutcome, RetitleMode, RetitleScope } from "./command.ts";
 import type { AutoRetitleStatus, SessionAutoTitleController } from "./controller.ts";
 import type { AutoTitleFailure, AutoTitleGeneration } from "./generate.ts";
@@ -55,7 +55,6 @@ export async function showRetitleWizard(
   pi: ExtensionAPI,
   controller: SessionAutoTitleController,
   ctx: ExtensionCommandContext,
-  modelRuntime: ModelRuntime,
   model: Model<Api> | undefined,
   getSessionEpoch: () => number,
   generation: AutoTitleGeneration,
@@ -69,7 +68,6 @@ export async function showRetitleWizard(
         pi,
         controller,
         ctx,
-        modelRuntime,
         model,
         getSessionEpoch,
         generation,
@@ -90,6 +88,16 @@ export async function showRetitleWizard(
 class RetitleWizardPanel implements Focusable {
   focused = false;
 
+  private mouseTargets: Array<{
+    id: string;
+    row: number;
+    start: number;
+    end: number;
+    select: (() => void) | undefined;
+    run: () => void;
+  }> = [];
+  private readonly pointer: LegendPointer;
+  private pressedStep: RetitleWizardStep | undefined;
   private selectedIndex = 0;
   private step: RetitleWizardStep;
 
@@ -99,13 +107,13 @@ class RetitleWizardPanel implements Focusable {
     private readonly pi: ExtensionAPI,
     private readonly controller: SessionAutoTitleController,
     private readonly ctx: ExtensionCommandContext,
-    private readonly modelRuntime: ModelRuntime,
     private readonly model: Model<Api> | undefined,
     private readonly getSessionEpoch: () => number,
     private readonly generation: AutoTitleGeneration,
     private readonly done: (result: RetitleCommandOutcome) => void,
     options?: RetitleWizardOptions,
   ) {
+    this.pointer = new LegendPointer(() => this.requestRender());
     this.step = options?.initialInvocation
       ? { kind: "scan", scope: options.initialInvocation.scope }
       : { kind: "scope" };
@@ -146,7 +154,29 @@ class RetitleWizardPanel implements Focusable {
     }
   }
 
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    const target = this.mouseTargets.find(
+      (target) => target.row === event.y && event.x >= target.start && event.x < target.end,
+    );
+    const result = this.pointer.handleMouse(event, target);
+    if (event.type === "press") {
+      this.pressedStep = this.step;
+      if (result?.handled) target?.select?.();
+    }
+    if (result) return result;
+    if (event.type === "wheel" && this.step.kind === "scope" && event.wheelDelta) {
+      this.selectedIndex = Math.max(
+        0,
+        Math.min(2, this.selectedIndex + Math.sign(event.wheelDelta)),
+      );
+      this.requestRender();
+      return { handled: true };
+    }
+    return undefined;
+  }
+
   render(width: number): string[] {
+    this.mouseTargets = [];
     const innerWidth = Math.max(1, width - 2);
     const lines: string[] = [this.theme.fg("border", `╭${"─".repeat(innerWidth)}╮`)];
 
@@ -251,7 +281,6 @@ class RetitleWizardPanel implements Focusable {
       pi: this.pi,
       controller: this.controller,
       ctx: this.ctx,
-      modelRuntime: this.modelRuntime,
       model: this.model,
       isManual: true,
       generation: this.generation,
@@ -310,7 +339,6 @@ class RetitleWizardPanel implements Focusable {
       this.pi,
       this.controller,
       this.ctx,
-      this.modelRuntime,
       this.model,
       scan,
       mode,
@@ -361,20 +389,23 @@ class RetitleWizardPanel implements Focusable {
     );
     lines.push(this.renderRow(innerWidth, ""));
 
-    for (const option of options) {
+    for (const [index, option] of options.entries()) {
       const prefix = option.selected ? this.theme.fg("accent", "›") : " ";
       const text = `${this.theme.bold(option.key)}${option.suffix}`;
       const label = option.selected ? this.theme.fg("accent", text) : text;
-      lines.push(this.renderRow(innerWidth, ` ${prefix} ${label}`));
+      this.pushActionRow(lines, innerWidth, ` ${prefix} ${label}`, option.key, 2, () => {
+        this.selectedIndex = index;
+        this.requestRender();
+      });
     }
 
     if (failure) {
       lines.push(this.renderRow(innerWidth, ""));
-      lines.push(
-        this.renderRow(
-          innerWidth,
-          ` ${this.theme.fg("dim", this.theme.bold("y"))}${this.theme.fg("dim", " Copy last auto-title error")}`,
-        ),
+      this.pushActionRow(
+        lines,
+        innerWidth,
+        ` ${this.theme.fg("dim", this.theme.bold("y"))}${this.theme.fg("dim", " Copy last auto-title error")}`,
+        "y",
       );
     }
   }
@@ -409,27 +440,27 @@ class RetitleWizardPanel implements Focusable {
     lines.push(this.renderRow(innerWidth, ""));
     lines.push(this.renderRow(innerWidth, ` ${message}`));
     lines.push(this.renderRow(innerWidth, ""));
-    lines.push(this.renderRow(innerWidth, ` ${this.theme.fg("dim", "Enter")} close`));
-    lines.push(this.renderRow(innerWidth, ` ${this.theme.fg("dim", "Esc")} cancel`));
+    this.pushActionRow(lines, innerWidth, ` ${this.theme.fg("dim", "Enter")} close`, "\r");
+    this.pushActionRow(lines, innerWidth, ` ${this.theme.fg("dim", "Esc")} cancel`, "\u001b");
   }
 
   private renderConfirmModeStep(lines: string[], innerWidth: number, scan: RetitleScopeScan): void {
     const title = scan.scope === "folder" ? "In This Folder" : "All of Pi";
     lines.push(this.renderRow(innerWidth, ` ${this.theme.bold(this.theme.fg("accent", title))}`));
     lines.push(this.renderRow(innerWidth, ""));
-    lines.push(
-      this.renderRow(
-        innerWidth,
-        ` ${this.theme.bold("Enter")} Generate missing titles (${scan.untitledCount})`,
-      ),
+    this.pushActionRow(
+      lines,
+      innerWidth,
+      ` ${this.theme.bold("Enter")} Generate missing titles (${scan.untitledCount})`,
+      "\r",
     );
-    lines.push(
-      this.renderRow(
-        innerWidth,
-        ` ${this.theme.bold("a")} Regenerate all sessions, even ones that already have titles (${scan.totalCount})`,
-      ),
+    this.pushActionRow(
+      lines,
+      innerWidth,
+      ` ${this.theme.bold("a")} Regenerate all sessions, even ones that already have titles (${scan.totalCount})`,
+      "a",
     );
-    lines.push(this.renderRow(innerWidth, ` ${this.theme.fg("dim", "Esc")} cancel`));
+    this.pushActionRow(lines, innerWidth, ` ${this.theme.fg("dim", "Esc")} cancel`, "\u001b");
   }
 
   private renderWarningStep(lines: string[], innerWidth: number, sessionCount: number): void {
@@ -442,8 +473,8 @@ class RetitleWizardPanel implements Focusable {
     );
     lines.push(this.renderRow(innerWidth, " This may take some time and may be expensive."));
     lines.push(this.renderRow(innerWidth, ""));
-    lines.push(this.renderRow(innerWidth, ` ${this.theme.fg("accent", "Enter")} continue`));
-    lines.push(this.renderRow(innerWidth, ` ${this.theme.fg("dim", "Esc")} cancel`));
+    this.pushActionRow(lines, innerWidth, ` ${this.theme.fg("accent", "Enter")} continue`, "\r");
+    this.pushActionRow(lines, innerWidth, ` ${this.theme.fg("dim", "Esc")} cancel`, "\u001b");
   }
 
   private renderRunningStep(lines: string[], innerWidth: number, message: string): void {
@@ -481,9 +512,44 @@ class RetitleWizardPanel implements Focusable {
     return this.renderRow(innerWidth, `${left}${" ".repeat(gap)}${right}`);
   }
 
+  private pushActionRow(
+    lines: string[],
+    innerWidth: number,
+    content: string,
+    key: string,
+    start = 1,
+    select?: () => void,
+  ): void {
+    const step = this.step;
+    const visible = visibleWidth(content) <= innerWidth;
+    if (visible) {
+      this.mouseTargets.push({
+        id: key,
+        row: lines.length,
+        start: start + 1,
+        end: visibleWidth(content) + 1,
+        select,
+        run: () => {
+          if (this.step === step) this.handleInput(key);
+        },
+      });
+    }
+    const pressed =
+      visible && !select && this.pressedStep === step && this.pointer.pressedId === key;
+    lines.push(
+      this.renderRow(
+        innerWidth,
+        pressed
+          ? content.slice(0, start) + this.theme.bg("selectedBg", content.slice(start))
+          : content,
+      ),
+    );
+  }
+
   private renderRow(innerWidth: number, content: string): string {
-    const pad = Math.max(0, innerWidth - visibleWidth(content));
-    return `${this.theme.fg("border", "│")}${content}${" ".repeat(pad)}${this.theme.fg("border", "│")}`;
+    const text = truncateToWidth(content, innerWidth, "…");
+    const pad = Math.max(0, innerWidth - visibleWidth(text));
+    return `${this.theme.fg("border", "│")}${text}${" ".repeat(pad)}${this.theme.fg("border", "│")}`;
   }
 
   private requestRender(): void {