pi-spark 0.23.1 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.25.0](https://github.com/zlliang/pi-spark/compare/v0.24.0...v0.25.0) (2026-09-14)
+
+
+### Bug Fixes
+
+* refine recap lifecycle and feature event handling ([4bb7474](https://github.com/zlliang/pi-spark/commit/4bb7474b3d04a6d92179b1873afdd6155e5e0368))
+
+## [0.24.0](https://github.com/zlliang/pi-spark/compare/v0.23.1...v0.24.0) (2026-09-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* adopt Pi 0.85 extension APIs
+
+### Features
+
+* adopt Pi 0.85 extension APIs ([2cd3208](https://github.com/zlliang/pi-spark/commit/2cd3208fe5bf8aade7828720ae0397da6836fe99))
+
+
+### Bug Fixes
+
+* capitalize DeepSeek pricing labels ([fffcc40](https://github.com/zlliang/pi-spark/commit/fffcc40c8664056fb54d3c5fea5853f3805a2e4f))
+
 ## [0.23.1](https://github.com/zlliang/pi-spark/compare/v0.23.0...v0.23.1) (2026-09-12)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-spark",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "description": "Pi package that polishes your daily experience",
   "keywords": [
     "pi-coding-agent",
@@ -44,17 +44,17 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": ">=0.84.0",
-    "@earendil-works/pi-ai": ">=0.84.0",
-    "@earendil-works/pi-coding-agent": ">=0.84.0",
-    "@earendil-works/pi-tui": ">=0.84.0",
+    "@earendil-works/pi-agent-core": ">=0.85.0",
+    "@earendil-works/pi-ai": ">=0.85.0",
+    "@earendil-works/pi-coding-agent": ">=0.85.0",
+    "@earendil-works/pi-tui": ">=0.85.0",
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": ">=0.84.0",
-    "@earendil-works/pi-ai": ">=0.84.0",
-    "@earendil-works/pi-coding-agent": ">=0.84.0",
-    "@earendil-works/pi-tui": ">=0.84.0",
+    "@earendil-works/pi-agent-core": ">=0.85.0",
+    "@earendil-works/pi-ai": ">=0.85.0",
+    "@earendil-works/pi-coding-agent": ">=0.85.0",
+    "@earendil-works/pi-tui": ">=0.85.0",
     "@types/node": "*",
     "typebox": "*",
     "typescript": "^7.0.2"

package/src/features/credits/index.ts

@@ -50,6 +50,10 @@ export function registerCredits(pi: ExtensionAPI): void {
     creditsManager?.refresh(ctx);
   });
 
+  pi.on("session_compact_failed", (_event, ctx) => {
+    creditsManager?.refresh(ctx);
+  });
+
   pi.on("session_before_tree", (event, ctx) => {
     if (!event.preparation.userWantsSummary) return;
 

package/src/features/credits/providers/deepseek.ts

@@ -25,34 +25,34 @@ export const deepseekProvider: CreditsProvider = {
   pricingRules: [
     {
       model: "deepseek-flash",
-      defaultCost: { input: 0.15, output: 0.6, cacheRead: 0.003, cacheWrite: 0, label: "off-peak" },
+      defaultCost: { input: 0.15, output: 0.6, cacheRead: 0.003, cacheWrite: 0, label: "Off-peak" },
       windows: [
-        { start: "01:00", end: "04:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "peak" } },
-        { start: "06:00", end: "10:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "peak" } },
+        { start: "01:00", end: "04:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "Peak" } },
+        { start: "06:00", end: "10:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "Peak" } },
       ],
     },
     {
       model: "deepseek-v4-flash",
-      defaultCost: { input: 0.15, output: 0.6, cacheRead: 0.003, cacheWrite: 0, label: "off-peak" },
+      defaultCost: { input: 0.15, output: 0.6, cacheRead: 0.003, cacheWrite: 0, label: "Off-peak" },
       windows: [
-        { start: "01:00", end: "04:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "peak" } },
-        { start: "06:00", end: "10:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "peak" } },
+        { start: "01:00", end: "04:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "Peak" } },
+        { start: "06:00", end: "10:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "Peak" } },
       ],
     },
     {
       model: "deepseek-v4-flash-vision-exp",
-      defaultCost: { input: 0.15, output: 0.6, cacheRead: 0.003, cacheWrite: 0, label: "off-peak" },
+      defaultCost: { input: 0.15, output: 0.6, cacheRead: 0.003, cacheWrite: 0, label: "Off-peak" },
       windows: [
-        { start: "01:00", end: "04:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "peak" } },
-        { start: "06:00", end: "10:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "peak" } },
+        { start: "01:00", end: "04:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "Peak" } },
+        { start: "06:00", end: "10:00", days: [1, 2, 3, 4, 5], cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0, label: "Peak" } },
       ],
     },
     {
       model: "deepseek-v4-pro",
-      defaultCost: { input: 0.66, output: 1.98, cacheRead: 0.022, cacheWrite: 0, label: "off-peak" },
+      defaultCost: { input: 0.66, output: 1.98, cacheRead: 0.022, cacheWrite: 0, label: "Off-peak" },
       windows: [
-        { start: "01:00", end: "04:00", days: [1, 2, 3, 4, 5], cost: { input: 1.32, output: 3.96, cacheRead: 0.044, cacheWrite: 0, label: "peak" } },
-        { start: "06:00", end: "10:00", days: [1, 2, 3, 4, 5], cost: { input: 1.32, output: 3.96, cacheRead: 0.044, cacheWrite: 0, label: "peak" } },
+        { start: "01:00", end: "04:00", days: [1, 2, 3, 4, 5], cost: { input: 1.32, output: 3.96, cacheRead: 0.044, cacheWrite: 0, label: "Peak" } },
+        { start: "06:00", end: "10:00", days: [1, 2, 3, 4, 5], cost: { input: 1.32, output: 3.96, cacheRead: 0.044, cacheWrite: 0, label: "Peak" } },
       ],
     },
   ],

package/src/features/credits/providers/openai-codex-panel.ts

@@ -5,7 +5,7 @@ import { Loader } from "../../../components/loader";
 import { renderCredits } from "../status";
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { SelectItem } from "@earendil-works/pi-tui";
+import type { SelectItem, TuiMouseEvent } from "@earendil-works/pi-tui";
 import type { BankedRateLimitReset, RateLimitResetCreditsResponse } from "./openai-codex";
 import type { Credits } from "../types";
 
@@ -113,6 +113,7 @@ export async function showCodexResetsSelector(ctx: ExtensionContext, load: (sign
           finish(null);
         }
       },
+      handleMouse: (event: TuiMouseEvent) => container.handleMouse(event),
     };
   });
 
@@ -170,6 +171,7 @@ export async function confirmCodexReset(ctx: ExtensionContext, credit: BankedRat
         selectList.handleInput(data);
         tui.requestRender();
       },
+      handleMouse: (event: TuiMouseEvent) => container.handleMouse(event),
     };
   });
 

package/src/features/credits/status.ts

@@ -1,6 +1,7 @@
-import { hyperlink } from "@earendil-works/pi-tui";
 import prettyMilliseconds from "pretty-ms";
 
+import { formatLink } from "../../utils/format";
+
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { Credits, CreditsLane } from "./types";
 
@@ -15,7 +16,7 @@ export function renderCredits(theme: Theme, label: string, credits: Credits, lin
   const suffix = credits.suffix ? ` ${theme.fg("dim", credits.suffix)}` : "";
 
   const text = `${styledLabel}${value}${suffix}`;
-  return link ? hyperlink(text, link) : text;
+  return link ? formatLink(text, link) : text;
 }
 
 export function renderError(theme: Theme, label: string, message: string): string {

package/src/features/editor/index.ts

@@ -43,27 +43,28 @@ class Editor extends CustomEditor {
     this.tui.requestRender();
   }
 
-  render(width: number): string[] {
+  override render(width: number): string[] {
     // Pi reapplies the thinking-level border color when the level changes. Use the dim color here
-    // while preserving Bash mode's dedicated border color.
+    // while preserving Bash mode's dedicated border color. Set it before rendering, since the
+    // border helpers below run inside `super.render()`.
     if (this.thinkingLevelIndicator === "model" && !this.getText().trimStart().startsWith("!")) {
       this.borderColor = (text) => this.ctx.ui.theme.fg("dim", text);
     }
 
-    const lines = super.render(width);
-    if (lines.length === 0) return lines;
+    return super.render(width);
+  }
 
-    lines[0] = this.getTopBorder(width);
+  protected override renderTopBorder(width: number, hiddenLineCount: number): string {
+    return this.renderBorder(width, this.getTopLeft(hiddenLineCount), this.getTopRight());
+  }
 
-    return lines;
+  protected override renderBottomBorder(width: number, hiddenLineCount: number): string {
+    return this.renderBorder(width, this.getScrollHint("↓", hiddenLineCount), "");
   }
 
-  private getTopBorder(width: number): string {
+  private renderBorder(width: number, left: string, right: string): string {
     const theme = this.ctx.ui.theme;
 
-    const left = this.getLeft();
-    const right = this.getRight();
-
     return new SplitLine(left, right, {
       padding: 1,
       innerPadding: 1,
@@ -72,16 +73,17 @@ class Editor extends CustomEditor {
     }).render(width)[0];
   }
 
-  private getLeft(): string {
+  private getTopLeft(hiddenLineCount: number): string {
     const theme = this.ctx.ui.theme;
 
     const spinner = this.spinner.getFrame();
     const workingMessage = this.workingMessage;
+    const workingText = [spinner ? theme.fg("accent", spinner) : undefined, workingMessage ? theme.fg("dim", workingMessage) : undefined].filter(Boolean).join(" ");
 
-    return [theme.fg("accent", spinner), workingMessage ? theme.fg("dim", workingMessage) : undefined].filter(Boolean).join(" ");
+    return [this.getScrollHint("↑", hiddenLineCount), workingText].filter(Boolean).join(theme.fg("dim", " · "));
   }
 
-  private getRight(): string {
+  private getTopRight(): string {
     const theme = this.ctx.ui.theme;
 
     const modelBeforeText = this.slots.modelBefore;
@@ -91,6 +93,13 @@ class Editor extends CustomEditor {
     return [modelBeforeText ? theme.fg("dim", modelBeforeText) : undefined, coloredModelText].filter(Boolean).join(theme.fg("dim", " · "));
   }
 
+  /** Renders Pi's hidden-line hint, which this editor keeps on the left side of the border. */
+  private getScrollHint(direction: "↑" | "↓", hiddenLineCount: number): string {
+    if (hiddenLineCount <= 0) return "";
+
+    return this.ctx.ui.theme.fg("dim", `${direction} ${hiddenLineCount} more`);
+  }
+
   private withThinkingLevelColor(text: string): string {
     const theme = this.ctx.ui.theme;
     const thinkingLevel = this.pi.getThinkingLevel();
@@ -159,11 +168,6 @@ export function registerEditor(pi: ExtensionAPI, events: EventCollector): void {
     editor?.setWorkingMessage("Running tools");
   });
 
-  pi.on("tool_call", (event) => {
-    runningToolCallIds.add(event.toolCallId);
-    editor?.setWorkingMessage("Running tools");
-  });
-
   pi.on("tool_execution_end", (event) => {
     runningToolCallIds.delete(event.toolCallId);
     editor?.setWorkingMessage(runningToolCallIds.size > 0 ? "Running tools" : undefined);

package/src/features/footer/index.ts

@@ -1,11 +1,11 @@
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { hyperlink, Text } from "@earendil-works/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
 
 import { SplitLine } from "../../components/split-line";
 import { loadConfig } from "../../config";
-import { formatContextUsage, formatCwd, sanitizeText } from "../../utils/format";
+import { formatContextUsage, formatCwd, formatLink, sanitizeText } from "../../utils/format";
 import { getEntryUsage } from "../../utils/usage";
 
 import type { ExtensionContext, ExtensionAPI, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
@@ -48,7 +48,7 @@ class FooterComponent implements Component {
   private getLeft(): string {
     const cwd = this.ctx.sessionManager.getCwd();
     const url = pathToFileURL(resolve(cwd));
-    const cwdText = hyperlink(formatCwd(cwd, homedir()), url.href);
+    const cwdText = formatLink(formatCwd(cwd, homedir()), url.href);
     const branch = this.footerData.getGitBranch();
     const sessionName = this.ctx.sessionManager.getSessionName();
 

package/src/features/presets/selector.ts

@@ -2,6 +2,7 @@ import { keyHint, rawKeyHint, DynamicBorder } from "@earendil-works/pi-coding-ag
 import { Box, Container, SelectList, Spacer, Text } from "@earendil-works/pi-tui";
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { TuiMouseEvent } from "@earendil-works/pi-tui";
 import type { PresetManager } from "./manager";
 
 export async function showPresetSelector(ctx: ExtensionContext, presetManager: PresetManager): Promise<string | undefined> {
@@ -51,6 +52,7 @@ export async function showPresetSelector(ctx: ExtensionContext, presetManager: P
         selectList.handleInput(data);
         tui.requestRender();
       },
+      handleMouse: (event: TuiMouseEvent) => container.handleMouse(event),
     };
   });
 

package/src/features/recap/idle.ts

@@ -1,5 +1,8 @@
 import parseDuration from "parse-duration";
 import * as z from "zod";
+import { convertToLlm, sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 const MIN_IDLE_MS = 5_000;
 
@@ -17,105 +20,79 @@ export const idleTimeoutSchema = z
   })
   .pipe(z.number().min(MIN_IDLE_MS));
 
-type IdleTimeout = z.infer<typeof idleTimeoutSchema>;
-type IdleHash = string | number | boolean;
-
 const DEFAULT_IDLE_MS = 5 * 60 * 1000;
 const POLL_MS = 1_000;
 
-export class IdleListener<T> {
-  private state: "active" | "watching" | "idle" = "active";
-  private computeStateHash: (ctx: T) => IdleHash;
-  private lastStateHash: IdleHash | undefined;
-
+export class IdleListener {
+  private entered = false;
+  private lastEditorText: string | undefined;
+  private stableSince = 0;
   private idleMs: number;
-  private pollMs: number;
-  private idleTimer: ReturnType<typeof setTimeout> | undefined;
   private pollTimer: ReturnType<typeof setInterval> | undefined;
 
-  private enterCallbacks: Set<(ctx: T) => void> = new Set();
-  private wakeCallbacks: Set<(ctx: T) => void> = new Set();
+  private enterCallbacks: Set<(ctx: ExtensionContext) => void> = new Set();
+  private resetCallbacks: Set<(ctx: ExtensionContext) => void> = new Set();
 
-  constructor(computeStateHash: (ctx: T) => IdleHash, idleMs: IdleTimeout = DEFAULT_IDLE_MS, pollMs: number = POLL_MS) {
-    this.computeStateHash = computeStateHash;
+  constructor(idleMs: number = DEFAULT_IDLE_MS) {
     this.idleMs = idleMs;
-    this.pollMs = pollMs;
   }
 
-  on(event: "enter" | "wake", callback: (ctx: T) => void): () => void {
-    const callbackSet = event === "enter" ? this.enterCallbacks : this.wakeCallbacks;
-    callbackSet.add(callback);
+  on(event: "enter" | "reset", callback: (ctx: ExtensionContext) => void): () => void {
+    const callbacks = event === "enter" ? this.enterCallbacks : this.resetCallbacks;
+    callbacks.add(callback);
 
-    return () => callbackSet.delete(callback);
+    return () => callbacks.delete(callback);
   }
 
-  watch(ctx: T): void {
-    if (this.state === "idle") return;
-
-    this.stop();
-    this.state = "watching";
-
-    this.lastStateHash = this.computeStateHash(ctx);
-    this.reset(ctx);
-
-    this.pollTimer = setInterval(() => {
-      const current = this.computeStateHash(ctx);
-      if (current === this.lastStateHash) return;
+  /** Clears any recap and starts a fresh idle period, keeping observation active while Pi is busy. */
+  reset(ctx: ExtensionContext): void {
+    this.entered = false;
+    this.lastEditorText = undefined;
+    this.resetCallbacks.forEach((callback) => callback(ctx));
 
-      this.lastStateHash = current;
-      this.reset(ctx);
-    }, this.pollMs);
-  }
-
-  enter(ctx: T): void {
-    if (this.state === "idle") return;
-
-    this.stop();
-    this.state = "idle";
-
-    this.enterCallbacks.forEach((callback) => callback(ctx));
-  }
-
-  /** Emits on every wake signal, even when the listener is already active. */
-  wake(ctx: T): void {
-    this.stop();
-    this.state = "active";
-
-    this.wakeCallbacks.forEach((callback) => callback(ctx));
+    this.check(ctx);
+    if (!this.pollTimer) {
+      this.pollTimer = setInterval(() => this.check(ctx), POLL_MS);
+    }
   }
 
   dispose(): void {
-    this.stop();
-    this.state = "active";
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = undefined;
+    }
 
+    this.entered = false;
+    this.lastEditorText = undefined;
     this.enterCallbacks.clear();
-    this.wakeCallbacks.clear();
-  }
-
-  private reset(ctx: T): void {
-    this.clearIdleTimer();
-    this.idleTimer = setTimeout(() => {
-      this.idleTimer = undefined;
-      this.enter(ctx);
-    }, this.idleMs);
-  }
-
-  private stop(): void {
-    this.clearIdleTimer();
-    this.clearPollTimer();
+    this.resetCallbacks.clear();
   }
 
-  private clearIdleTimer(): void {
-    if (!this.idleTimer) return;
-
-    clearTimeout(this.idleTimer);
-    this.idleTimer = undefined;
-  }
-
-  private clearPollTimer(): void {
-    if (!this.pollTimer) return;
-
-    clearInterval(this.pollTimer);
-    this.pollTimer = undefined;
+  private check(ctx: ExtensionContext): void {
+    const canEnter = ctx.isIdle() && ctx.sessionManager.buildContextEntries().some((entry) => convertToLlm(sessionEntryToContextMessages(entry)).length > 0);
+    if (!canEnter) {
+      this.lastEditorText = undefined;
+      if (this.entered) {
+        this.entered = false;
+        this.resetCallbacks.forEach((callback) => callback(ctx));
+      }
+      return;
+    }
+
+    // Keep the recap while the user edits; only a reset or Pi becoming busy clears it.
+    if (this.entered) return;
+
+    const editorText = ctx.ui.getEditorText();
+    const now = Date.now();
+    if (editorText !== this.lastEditorText) {
+      this.lastEditorText = editorText;
+      this.stableSince = now;
+      return;
+    }
+
+    if (now - this.stableSince >= this.idleMs) {
+      this.entered = true;
+      this.enterCallbacks.forEach((callback) => callback(ctx));
+    }
   }
 }

package/src/features/recap/index.ts

@@ -2,13 +2,13 @@ import { IdleListener } from "./idle";
 import { RecapManager } from "./manager";
 import { loadConfig } from "../../config";
 
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 export function registerRecap(pi: ExtensionAPI): void {
-  let idleListener: IdleListener<ExtensionContext> | undefined = undefined;
+  let idleListener: IdleListener | undefined = undefined;
   let recapManager: RecapManager | undefined = undefined;
 
-  pi.on("session_start", (event, ctx) => {
+  pi.on("session_start", (_event, ctx) => {
     const config = loadConfig(ctx).recap;
     if (ctx.mode !== "tui" || !config) return;
 
@@ -16,48 +16,34 @@ export function registerRecap(pi: ExtensionAPI): void {
 
     pi.registerCommand("recap", {
       description: "Generate a short recap of the current session",
-      handler: async () => await recapManager?.run(ctx, { force: true }),
+      handler: async (_args, ctx) => await recapManager?.run(ctx, { force: true }),
     });
 
-    idleListener = new IdleListener((c) => `idle:${c.isIdle()};editor:${c.ui.getEditorText()}`, config.idle);
-    idleListener.on("enter", (c) => recapManager?.run(c));
-    idleListener.on("wake", (c) => recapManager?.clear(c));
+    idleListener = new IdleListener(config.idle);
+    idleListener.on("enter", (ctx) => recapManager?.run(ctx));
+    idleListener.on("reset", (ctx) => recapManager?.clear(ctx));
 
-    if (event.reason === "resume" || event.reason === "fork") {
-      idleListener.watch(ctx);
-    }
+    idleListener.reset(ctx);
   });
 
   pi.on("input", (_event, ctx) => {
-    idleListener?.wake(ctx);
+    idleListener?.reset(ctx);
   });
 
   pi.on("user_bash", (_event, ctx) => {
-    idleListener?.wake(ctx);
+    idleListener?.reset(ctx);
   });
 
   pi.on("agent_start", (_event, ctx) => {
-    idleListener?.wake(ctx);
+    idleListener?.reset(ctx);
   });
 
   pi.on("session_before_compact", (_event, ctx) => {
-    idleListener?.wake(ctx);
+    idleListener?.reset(ctx);
   });
 
   pi.on("session_before_tree", (_event, ctx) => {
-    idleListener?.wake(ctx);
-  });
-
-  pi.on("agent_settled", (_event, ctx) => {
-    idleListener?.watch(ctx);
-  });
-
-  pi.on("session_compact", (_event, ctx) => {
-    idleListener?.watch(ctx);
-  });
-
-  pi.on("session_tree", (_event, ctx) => {
-    idleListener?.watch(ctx);
+    idleListener?.reset(ctx);
   });
 
   pi.on("session_shutdown", (_event, ctx) => {

package/src/features/recap/manager.ts

@@ -1,4 +1,4 @@
-import { convertToLlm, serializeConversation } from "@earendil-works/pi-coding-agent";
+import { convertToLlm, serializeConversation, sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 
 import { clearRecapWidget, setRecapLoadingWidget, setRecapTextWidget } from "./widget";
 import { sanitizeText } from "../../utils/format";
@@ -32,7 +32,7 @@ export class RecapManager {
   }
 
   async run(ctx: ExtensionContext, options: { force?: boolean } = {}): Promise<void> {
-    if (this.active && !options.force) return;
+    if (!options.force && (this.active || this.inflight || !ctx.isIdle())) return;
 
     this.cancelInflight();
     const controller = new AbortController();
@@ -41,6 +41,7 @@ export class RecapManager {
     try {
       const modelSettings = await resolveModelSettings(ctx, this.config, "recap");
       if (controller.signal.aborted || this.inflight !== controller || !modelSettings) return;
+      if (!options.force && !ctx.isIdle()) return;
 
       const { model, thinkingLevel, warning } = modelSettings;
 
@@ -113,7 +114,7 @@ export class RecapManager {
   }
 
   private buildPrompt(ctx: ExtensionContext): string {
-    const messages = ctx.sessionManager.getBranch().filter((entry) => entry.type === "message").map((entry) => entry.message);
+    const messages = ctx.sessionManager.buildContextEntries().flatMap(sessionEntryToContextMessages);
     const text = serializeConversation(convertToLlm(messages));
     const conversation = text.length > MAX_CONVERSATION_CHARS ? text.slice(-MAX_CONVERSATION_CHARS) : text;
 

package/src/features/title/index.ts

@@ -16,12 +16,12 @@ export function registerTitle(pi: ExtensionAPI): void {
   // Generate the title after the first completed turn, without waiting for the full agent run.
   // The manager skips sessions that already have a name and prevents concurrent attempts.
   pi.on("turn_end", (_event, ctx) => {
-    void titleManager?.run(ctx);
+    titleManager?.run(ctx);
   });
 
   // Fall back to settlement if the run ends without a completed turn or an early attempt fails.
   pi.on("agent_settled", (_event, ctx) => {
-    void titleManager?.run(ctx);
+    titleManager?.run(ctx);
   });
 
   pi.on("session_shutdown", () => {

package/src/features/write/index.ts

@@ -139,29 +139,18 @@ function formatWriteCall(path: string | null, content: string | null, highlighte
 
 export function registerWrite(pi: ExtensionAPI): void {
   let enabled = true;
-  const toolCache = new Map<string, ReturnType<typeof createWriteToolDefinition>>();
 
-  function getWriteTool(cwd: string): ReturnType<typeof createWriteToolDefinition> {
-    let tool = toolCache.get(cwd);
-    if (!tool) {
-      tool = createWriteToolDefinition(cwd);
-      toolCache.set(cwd, tool);
-    }
-
-    return tool;
-  };
+  // Pi resolves paths against `ctx.cwd`, falling back to this cwd only when neither is provided.
+  const writeTool = createWriteToolDefinition(process.cwd());
 
   pi.on("session_start", (_event, ctx) => {
     enabled = loadConfig(ctx).write !== false;
   });
 
   pi.registerTool({
-    ...getWriteTool(process.cwd()),
-    execute(toolCallId, params, signal, onUpdate, ctx) {
-      return getWriteTool(ctx.cwd).execute(toolCallId, params, signal, onUpdate, ctx);
-    },
+    ...writeTool,
     renderCall(args, theme, context) {
-      if (!enabled) return getWriteTool(context.cwd).renderCall!(args, theme, context);
+      if (!enabled) return writeTool.renderCall!(args, theme, context);
 
       const renderArgs = args as { path?: string; file_path?: string; content?: string } | undefined;
       const path = parseArg(renderArgs?.file_path ?? renderArgs?.path);

package/src/features/write/path.ts

@@ -1,7 +1,8 @@
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { getCapabilities, hyperlink } from "@earendil-works/pi-tui";
+
+import { formatLink } from "../../utils/format";
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 
@@ -12,9 +13,8 @@ export function renderPath(path: string | null, cwd: string, theme: Theme): stri
   const home = homedir();
   const displayPath = path.startsWith(home) ? `~${path.slice(home.length)}` : path;
   const styledPath = theme.fg("accent", displayPath);
-  if (!getCapabilities().hyperlinks) return styledPath;
 
-  return hyperlink(styledPath, pathToFileURL(resolvePath(path, cwd)).href);
+  return formatLink(styledPath, pathToFileURL(resolvePath(path, cwd)).href);
 }
 
 function resolvePath(path: string, cwd: string): string {

package/src/utils/format.ts

@@ -1,10 +1,16 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
+import { getCapabilities, hyperlink } from "@earendil-works/pi-tui";
 
 import { http } from "./http";
 
 import type { ProviderId } from "@earendil-works/pi-ai";
 import type { ContextUsage } from "@earendil-works/pi-coding-agent";
 
+/** Links text with OSC 8, honoring the terminal's detected and user-overridden hyperlink support. */
+export function formatLink(text: string, url: string): string {
+  return getCapabilities().hyperlinks ? hyperlink(text, url) : text;
+}
+
 export function formatModel(provider?: ProviderId, model?: string, thinkingLevel?: string): string {
   return provider && model ? `${provider}/${model}${thinkingLevel ? `:${thinkingLevel}` : ""}` : "no-model";
 }