pi-spark 0.19.3 → 0.21.0

package/src/features/credits/types.ts

@@ -1,5 +1,5 @@
-import type { ProviderId } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { CreditsProviderId } from "./config";
 
 /**
  * Normalized credits/usage for a provider.
@@ -21,7 +21,7 @@ export type RefreshCredits = (ctx: ExtensionContext) => Promise<void>;
 
 /** A credits source for a Pi provider, shown in the status line while that provider is active. */
 export interface CreditsProvider {
-  readonly id: ProviderId;
+  readonly id: CreditsProviderId;
   readonly label: string;
   fetch(apiKey: string, signal: AbortSignal): Promise<Credits>;
   register?(pi: ExtensionAPI, ctx: ExtensionContext, refresh: RefreshCredits): void;

package/src/features/editor/config.ts

@@ -1,7 +1,12 @@
 import * as z from "zod";
 
-import { spinnerPresetSchema } from "./spinner";
+const spinnerPresetSchema = z.enum(["dots", "lights", "tildes", "pulse"]);
+const thinkingLevelIndicatorSchema = z.enum(["border", "model"]);
+
+export type SpinnerPreset = z.infer<typeof spinnerPresetSchema>;
+export type ThinkingLevelIndicator = z.infer<typeof thinkingLevelIndicatorSchema>;
 
 export const editorConfigSchema = z.object({
   spinner: spinnerPresetSchema.optional(),
+  thinkingLevelIndicator: thinkingLevelIndicatorSchema.optional(),
 });

package/src/features/editor/index.ts

@@ -9,16 +9,18 @@ import { formatModel } from "../../utils/format";
 import type { ExtensionAPI, ExtensionContext, KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { TUI, EditorTheme } from "@earendil-works/pi-tui";
 import type { EventCollector } from "../../events";
+import type { ThinkingLevelIndicator } from "./config";
 
 class Editor extends CustomEditor {
   private pi: ExtensionAPI;
   private ctx: ExtensionContext;
 
   private spinner: Spinner;
+  private thinkingLevelIndicator: ThinkingLevelIndicator;
   private workingMessage: string | undefined;
   private slots: { modelBefore: string | undefined };
 
-  constructor(pi: ExtensionAPI, ctx: ExtensionContext, tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, spinner: Spinner = new Spinner()) {
+  constructor(pi: ExtensionAPI, ctx: ExtensionContext, tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, spinner: Spinner = new Spinner(), thinkingLevelIndicator: ThinkingLevelIndicator = "border") {
     super(tui, theme, keybindings);
 
     this.pi = pi;
@@ -26,6 +28,7 @@ class Editor extends CustomEditor {
 
     this.spinner = spinner;
     this.spinner.setTUI(tui);
+    this.thinkingLevelIndicator = thinkingLevelIndicator;
     this.workingMessage = undefined;
     this.slots = { modelBefore: undefined };
   }
@@ -41,6 +44,12 @@ class Editor extends CustomEditor {
   }
 
   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.
+    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;
 
@@ -77,8 +86,16 @@ class Editor extends CustomEditor {
 
     const modelBeforeText = this.slots.modelBefore;
     const modelText = formatModel(this.ctx.model?.provider, this.ctx.model?.id, this.pi.getThinkingLevel());
+    const coloredModelText = this.thinkingLevelIndicator === "model" ? this.withThinkingLevelColor(modelText) : theme.fg("dim", modelText);
+
+    return [modelBeforeText ? theme.fg("dim", modelBeforeText) : undefined, coloredModelText].filter(Boolean).join(theme.fg("dim", " · "));
+  }
+
+  private withThinkingLevelColor(text: string): string {
+    const theme = this.ctx.ui.theme;
+    const thinkingLevel = this.pi.getThinkingLevel();
 
-    return theme.fg("dim", [modelBeforeText, modelText].filter(Boolean).join(" · "));
+    return theme.getThinkingBorderColor(thinkingLevel)(text);
   }
 }
 
@@ -89,13 +106,13 @@ export function registerEditor(pi: ExtensionAPI, events: EventCollector): void {
 
   pi.on("session_start", (_event, ctx) => {
     const config = loadConfig(ctx).editor;
-    if (!ctx.hasUI || !config) return;
+    if (ctx.mode !== "tui" || !config) return;
 
     spinner = new Spinner(config.spinner);
 
     ctx.ui.setWorkingVisible(false);
     ctx.ui.setEditorComponent((tui, theme, keybindings) => {
-      editor = new Editor(pi, ctx, tui, theme, keybindings, spinner);
+      editor = new Editor(pi, ctx, tui, theme, keybindings, spinner, config.thinkingLevelIndicator);
 
       events.on(PRESET_CHANGE, (data) => {
         const payload = parsePresetChange(data);

package/src/features/editor/spinner.ts

@@ -1,10 +1,5 @@
-import * as z from "zod";
-
 import type { TUI } from "@earendil-works/pi-tui";
-
-export const spinnerPresetSchema = z.enum(["dots", "lights", "tildes", "pulse"]);
-
-type SpinnerPreset = z.infer<typeof spinnerPresetSchema>;
+import type { SpinnerPreset } from "./config";
 
 interface SpinnerParams {
   frames: string[];
@@ -35,7 +30,7 @@ const SPINNER_PRESETS: Record<SpinnerPreset, SpinnerParams> = {
   },
 };
 
-const DEFAULT_SPINNER_PRESET = "tildes";
+const DEFAULT_SPINNER_PRESET: SpinnerPreset = "tildes";
 
 export class Spinner {
   private tui: TUI | undefined;

package/src/features/footer/config.ts

@@ -1,3 +1,9 @@
 import * as z from "zod";
 
-export const footerConfigSchema = z.object({});
+const statusPositionSchema = z.enum(["inline", "below"]);
+
+export type StatusPosition = z.infer<typeof statusPositionSchema>;
+
+export const footerConfigSchema = z.object({
+  statusPosition: statusPositionSchema.optional(),
+});

package/src/features/footer/index.ts

@@ -1,26 +1,30 @@
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { hyperlink, Text } from "@earendil-works/pi-tui";
 
 import { SplitLine } from "../../components/split-line";
 import { loadConfig } from "../../config";
 import { formatContextUsage, formatCost, formatCwd, sanitizeText } from "../../utils/format";
 import { getEntryUsage } from "../../utils/usage";
 
-import { hyperlink } from "@earendil-works/pi-tui";
-
 import type { ExtensionContext, ExtensionAPI, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
+import type { StatusPosition } from "./config";
+
+const DEFAULT_STATUS_POSITION: StatusPosition = "inline";
 
 class FooterComponent implements Component {
   private ctx: ExtensionContext;
   private theme: Theme;
   private footerData: ReadonlyFooterDataProvider;
+  private statusPosition: StatusPosition;
 
-  constructor(ctx: ExtensionContext, theme: Theme, footerData: ReadonlyFooterDataProvider) {
+  constructor(ctx: ExtensionContext, theme: Theme, footerData: ReadonlyFooterDataProvider, statusPosition: StatusPosition = DEFAULT_STATUS_POSITION) {
     this.ctx = ctx;
     this.theme = theme;
     this.footerData = footerData;
+    this.statusPosition = statusPosition;
   }
 
   invalidate(): void {
@@ -31,7 +35,14 @@ class FooterComponent implements Component {
     const left = this.getLeft();
     const right = this.getRight();
 
-    return new SplitLine(left, right, { primarySide: "right", ellipsis: this.theme.fg("dim", "…") }).render(width);
+    const lines = new SplitLine(left, right, { primarySide: "right", ellipsis: this.theme.fg("dim", "…") }).render(width);
+
+    if (this.statusPosition === "below") {
+      const statusesText = this.getStatusesText();
+      if (statusesText) lines.push(...new Text(statusesText, 0, 0).render(width));
+    }
+
+    return lines;
   }
 
   private getLeft(): string {
@@ -45,7 +56,7 @@ class FooterComponent implements Component {
   }
 
   private getRight(): string {
-    const statusesText = this.getStatusesText();
+    const statusesText = this.statusPosition === "inline" ? this.getStatusesText() : "";
     const styledCostText = this.getStyledCostText();
     const styledContextUsageText = this.getStyledContextUsageText();
 
@@ -64,7 +75,7 @@ class FooterComponent implements Component {
   }
 
   private getStyledCostText(): string {
-    const totalCost = this.ctx.sessionManager.getBranch().reduce((acc, entry) => acc + (getEntryUsage(entry)?.cost.total ?? 0), 0);
+    const totalCost = this.ctx.sessionManager.getEntries().reduce((acc, entry) => acc + (getEntryUsage(entry)?.cost.total ?? 0), 0);
 
     // Hide cost below half a cent, since it would render as $0.00.
     if (totalCost < 0.005) return "";
@@ -89,8 +100,8 @@ class FooterComponent implements Component {
 export function registerFooter(pi: ExtensionAPI): void {
   pi.on("session_start", (_event, ctx) => {
     const config = loadConfig(ctx).footer;
-    if (!ctx.hasUI || !config) return;
+    if (ctx.mode !== "tui" || !config) return;
 
-    ctx.ui.setFooter((_tui, theme, footerData) => new FooterComponent(ctx, theme, footerData));
+    ctx.ui.setFooter((_tui, theme, footerData) => new FooterComponent(ctx, theme, footerData, config.statusPosition));
   });
 }

package/src/features/fullscreen/filler.ts

@@ -1,38 +1,82 @@
 import type { Component, TUI } from "@earendil-works/pi-tui";
 
-/**
- * Fills the gap above the editor so the editor and footer stay pinned to the
- * bottom of the terminal when the session content is shorter than one screen.
- */
+const FILLER_MARKER = "\0pi-spark:fullscreen\0";
+
+/** Pins the editor and footer to the bottom when the rest of the UI is shorter than the terminal. */
 export class BottomFiller implements Component {
   private tui: TUI;
-  private measuring = false;
+  private active = false;
+  private restore?: () => void;
 
   constructor(tui: TUI) {
     this.tui = tui;
   }
 
-  invalidate(): void {
-    // No-op
-  }
+  /**
+   * Install the layout after Pi has added this component to its widget container.
+   *
+   * Pi has no flexible spacer or layout-measurement API. The filler therefore emits a temporary
+   * marker during Pi's normal render pass. A root render wrapper replaces that marker afterward,
+   * when the total height is known. Every component, including the transcript, renders only once.
+   */
+  mount(): void {
+    if (this.active) return;
+
+    const widgetIndex = this.tui.children.findIndex((child) => "children" in child && Array.isArray(child.children) && child.children.includes(this));
+    if (widgetIndex <= 0) return;
+
+    const statusContainer = this.tui.children[widgetIndex - 1];
+    if (!statusContainer) return;
+
+    const originalStatusRender = statusContainer.render;
+    const patchedStatusRender = (width: number): string[] => {
+      const lines = originalStatusRender.call(statusContainer, width);
+      if (!this.active) return lines;
+
+      // Fullscreen already keeps the layout stable, so Pi's two idle placeholder rows only add an
+      // unwanted gap above the editor. Real status indicators are left untouched.
+      const blankLine = " ".repeat(width);
+      return lines.length === 2 && lines.every((line) => line === blankLine) ? [] : lines;
+    };
+
+    const originalTuiRender = this.tui.render;
+    const patchedTuiRender = (width: number): string[] => {
+      const lines = originalTuiRender.call(this.tui, width);
+      if (!this.active) return lines;
 
-  render(width: number): string[] {
-    // Guard against re-entrancy: measuring the siblings below renders this component again.
-    if (this.measuring) return [];
-    this.measuring = true;
+      const markerIndex = lines.indexOf(FILLER_MARKER);
+      if (markerIndex === -1) return lines;
 
-    // Re-assert `clearOnShrink` every render pass; the TUI reads it after `render()` returns,
-    // so this wins deterministically over Pi's reset to the settings value on startup/reload.
-    this.tui.setClearOnShrink(true);
+      lines.splice(markerIndex, 1);
+      const fillerHeight = Math.max(0, this.tui.terminal.rows - lines.length);
+      if (fillerHeight > 0) lines.splice(markerIndex, 0, ...new Array<string>(fillerHeight).fill(""));
 
-    const rows = this.tui.terminal.rows;
-    let others = 0;
-    for (const child of this.tui.children) {
-      others += child.render(width).length;
-      if (others >= rows) break;
-    }
+      // Pi reads this after render() and may reset it to the configured value on startup/reload.
+      this.tui.setClearOnShrink(true);
+      return lines;
+    };
+
+    this.active = true;
+    statusContainer.render = patchedStatusRender;
+    this.tui.render = patchedTuiRender;
+
+    this.restore = () => {
+      if (this.tui.render === patchedTuiRender) this.tui.render = originalTuiRender;
+      if (statusContainer.render === patchedStatusRender) statusContainer.render = originalStatusRender;
+    };
+  }
+
+  dispose(): void {
+    this.active = false;
+    this.restore?.();
+    this.restore = undefined;
+  }
+
+  invalidate(): void {
+    // No cached render state
+  }
 
-    this.measuring = false;
-    return new Array(Math.max(0, rows - others)).fill("");
+  render(_width: number): string[] {
+    return this.active ? [FILLER_MARKER] : [];
   }
 }

package/src/features/fullscreen/index.ts

@@ -39,7 +39,7 @@ export function registerFullscreen(pi: ExtensionAPI): void {
 
   pi.on("session_start", (_event, ctx) => {
     const config = loadConfig(ctx).fullscreen;
-    if (!ctx.hasUI || !config) return;
+    if (ctx.mode !== "tui" || !config) return;
 
     enabled = true;
     pendingClear = true;
@@ -50,14 +50,17 @@ export function registerFullscreen(pi: ExtensionAPI): void {
     ctx.ui.setWidget(WIDGET_KEY, (capturedTui) => {
       tui = capturedTui;
 
-      // Defer the entry clear to a microtask: the filler isn't in the render tree until
-      // `setWidget` returns, and `session_start` has no TUI to repaint with yet.
-      if (pendingClear) {
-        pendingClear = false;
-        queueMicrotask(() => capturedTui.requestRender(true));
-      }
+      const filler = new BottomFiller(capturedTui);
+      const shouldClear = pendingClear;
+      pendingClear = false;
 
-      return new BottomFiller(capturedTui);
+      // Defer setup until `setWidget` has mounted the filler in the render tree.
+      queueMicrotask(() => {
+        filler.mount();
+        if (shouldClear) capturedTui.requestRender(true);
+      });
+
+      return filler;
     });
   });
 
@@ -76,6 +79,7 @@ export function registerFullscreen(pi: ExtensionAPI): void {
       tui.terminal.write(`${line}\r\n`);
     }
 
+    ctx.ui.setWidget(WIDGET_KEY, undefined);
     tui = undefined;
     enabled = false;
     pendingClear = false;

package/src/features/presets/config.ts

@@ -2,7 +2,8 @@ import * as z from "zod";
 
 import { modelSchema } from "../../config/model";
 
+export type PresetConfig = z.infer<typeof modelSchema>;
+
 export const presetsConfigSchema = z.record(z.string().min(1), modelSchema);
 
 export type PresetsConfig = z.infer<typeof presetsConfigSchema>;
-export type PresetConfig = PresetsConfig[string];

package/src/features/presets/manager.ts

@@ -2,7 +2,7 @@ import { PRESET_CHANGE } from "../../events";
 import { formatModel } from "../../utils/format";
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { PresetsConfig, PresetConfig } from "./config";
+import type { PresetConfig, PresetsConfig } from "./config";
 
 export class PresetManager {
   private pi: ExtensionAPI;

package/src/features/recap/index.ts

@@ -10,7 +10,7 @@ export function registerRecap(pi: ExtensionAPI): void {
 
   pi.on("session_start", (event, ctx) => {
     const config = loadConfig(ctx).recap;
-    if (!ctx.hasUI || !config) return;
+    if (ctx.mode !== "tui" || !config) return;
 
     recapManager = new RecapManager(pi, config);
 

package/src/features/title/index.ts

@@ -8,13 +8,18 @@ export function registerTitle(pi: ExtensionAPI): void {
 
   pi.on("session_start", (_event, ctx) => {
     const config = loadConfig(ctx).title;
-    if (!ctx.hasUI || !config) return;
+    if (!config) return;
 
     titleManager = new TitleManager(pi, config);
   });
 
-  // Generate the title after the first exchange, once the session has context to summarize.
-  // The manager runs at most once and skips sessions that already have a name.
+  // 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);
+  });
+
+  // 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);
   });

package/src/features/title/manager.ts

@@ -32,9 +32,8 @@ export class TitleManager {
 
   /** Generate and set the session title once, silently, from the current context. */
   async run(ctx: ExtensionContext): Promise<void> {
-    if (this.pi.getSessionName()) return;
+    if (this.pi.getSessionName() || this.inflight) return;
 
-    this.cancelInflight();
     const controller = new AbortController();
     this.inflight = controller;
 
@@ -44,7 +43,7 @@ export class TitleManager {
 
       const { model, thinkingLevel } = modelSettings;
       const result = await this.generate(ctx, model, thinkingLevel, controller.signal);
-      if (controller.signal.aborted || this.inflight !== controller || !result.content) return;
+      if (controller.signal.aborted || this.inflight !== controller || !result.content || this.pi.getSessionName()) return;
 
       this.pi.setSessionName(result.content);
       this.pi.appendEntry("title", {

package/src/features/write/config.ts

@@ -0,0 +1,3 @@
+import * as z from "zod";
+
+export const writeConfigSchema = z.object({});

package/src/features/write/index.ts

@@ -0,0 +1,177 @@
+import { createWriteToolDefinition, getLanguageFromPath, highlightCode, keyHint } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+
+import { loadConfig } from "../../config";
+import { renderPath } from "./path";
+
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+
+const PREVIEW_LINES = 10;
+const HIGHLIGHT_LOOKBACK_LINES = 50;
+
+function normalizeContent(content: string): string {
+  return content.replace(/\r/g, "").replace(/\t/g, "   ");
+}
+
+class HighlightCache {
+  private rawPath: string | null = null;
+  private rawContent = "";
+  private argsComplete = false;
+  private language = "";
+  private normalizedLines: string[] = [];
+  private highlightedLines: string[] = [];
+
+  update(rawPath: string | null, rawContent: string | null, argsComplete: boolean): string[] | undefined {
+    if (rawContent === null) {
+      this.clear();
+      return undefined;
+    }
+
+    const language = rawPath ? getLanguageFromPath(rawPath) : undefined;
+    if (!language) {
+      this.clear();
+      return undefined;
+    }
+    if (this.matches(rawPath, rawContent, argsComplete, language)) return this.highlightedLines;
+
+    if (argsComplete || !this.canExtend(rawPath, rawContent, language)) {
+      this.rebuild(rawPath, rawContent, argsComplete, language);
+    } else {
+      this.extend(rawContent);
+    }
+
+    return this.highlightedLines;
+  }
+
+  clear(): void {
+    this.rawPath = null;
+    this.rawContent = "";
+    this.argsComplete = false;
+    this.language = "";
+    this.normalizedLines = [];
+    this.highlightedLines = [];
+  }
+
+  private rebuild(rawPath: string | null, rawContent: string, argsComplete: boolean, language: string): void {
+    const normalizedContent = normalizeContent(rawContent);
+    this.rawPath = rawPath;
+    this.rawContent = rawContent;
+    this.argsComplete = argsComplete;
+    this.language = language;
+    this.normalizedLines = normalizedContent.split("\n");
+    this.highlightedLines = highlightCode(normalizedContent, language);
+  }
+
+  private matches(rawPath: string | null, rawContent: string, argsComplete: boolean, language: string): boolean {
+    return this.rawPath === rawPath && this.rawContent === rawContent && this.argsComplete === argsComplete && this.language === language;
+  }
+
+  private canExtend(rawPath: string | null, rawContent: string, language: string): boolean {
+    return this.rawPath === rawPath && this.language === language && rawContent.startsWith(this.rawContent);
+  }
+
+  private extend(rawContent: string): void {
+    const segments = normalizeContent(rawContent.slice(this.rawContent.length)).split("\n");
+    const lastIndex = this.normalizedLines.length - 1;
+    const start = Math.max(0, lastIndex - HIGHLIGHT_LOOKBACK_LINES);
+
+    this.rawContent = rawContent;
+    this.argsComplete = false;
+    this.normalizedLines[lastIndex] += segments[0] ?? "";
+    this.normalizedLines.push(...segments.slice(1));
+
+    const highlightedLines = highlightCode(this.normalizedLines.slice(start).join("\n"), this.language);
+    this.highlightedLines.splice(start, this.highlightedLines.length - start, ...highlightedLines);
+  }
+}
+
+class WriteCallComponent extends Text {
+  private highlightCache = new HighlightCache();
+
+  constructor() {
+    super("", 0, 0);
+  }
+
+  updateHighlight(rawPath: string | null, rawContent: string | null, argsComplete: boolean): string[] | undefined {
+    return this.highlightCache.update(rawPath, rawContent, argsComplete);
+  }
+
+  override invalidate(): void {
+    this.highlightCache.clear();
+    super.invalidate();
+  }
+}
+
+function parseArg(value: unknown): string | null {
+  if (typeof value === "string") return value;
+  return value == null ? "" : null;
+}
+
+function trimTrailingEmptyLines(lines: string[]): string[] {
+  let end = lines.length;
+  while (end > 0 && lines[end - 1] === "") end--;
+  return lines.slice(0, end);
+}
+
+function renderOmission(hiddenLines: number, totalLines: number, theme: Theme): string {
+  const summary = theme.fg("muted", `... (${hiddenLines} earlier lines, ${totalLines} total,`);
+  return `${summary} ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+}
+
+function formatWriteCall(path: string | null, content: string | null, highlightedLines: string[] | undefined, expanded: boolean, cwd: string, theme: Theme): string {
+  const header = `${theme.fg("toolTitle", theme.bold("write"))} ${renderPath(path, cwd, theme)}`;
+  if (content === null) return `${header}\n\n${theme.fg("error", "[invalid content arg - expected string]")}`;
+  if (!content) return header;
+
+  const language = path ? getLanguageFromPath(path) : undefined;
+  const normalizedContent = normalizeContent(content);
+  const contentLines = language ? (highlightedLines ?? highlightCode(normalizedContent, language)) : normalizedContent.split("\n");
+  const lines = trimTrailingEmptyLines(contentLines);
+
+  const visibleLines = expanded ? lines : lines.slice(-PREVIEW_LINES);
+  const hiddenLines = lines.length - visibleLines.length;
+  const displayLines = language ? visibleLines : visibleLines.map((line) => theme.fg("toolOutput", line));
+
+  const body = hiddenLines > 0 ? [renderOmission(hiddenLines, lines.length, theme), ...displayLines] : displayLines;
+
+  return [header, "", ...body].join("\n");
+}
+
+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.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);
+    },
+    renderCall(args, theme, context) {
+      if (!enabled) return getWriteTool(context.cwd).renderCall!(args, theme, context);
+
+      const renderArgs = args as { path?: string; file_path?: string; content?: string } | undefined;
+      const path = parseArg(renderArgs?.file_path ?? renderArgs?.path);
+      const content = parseArg(renderArgs?.content);
+
+      const component = context.lastComponent instanceof WriteCallComponent ? context.lastComponent : new WriteCallComponent();
+      const highlightedLines = component.updateHighlight(path, content, context.argsComplete);
+      component.setText(formatWriteCall(path, content, highlightedLines, context.expanded, context.cwd, theme));
+
+      return component;
+    },
+  });
+}

package/src/features/write/path.ts

@@ -0,0 +1,33 @@
+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 type { Theme } from "@earendil-works/pi-coding-agent";
+
+export function renderPath(path: string | null, cwd: string, theme: Theme): string {
+  if (path === null) return theme.fg("error", "[invalid arg]");
+  if (!path) return theme.fg("toolOutput", "...");
+
+  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);
+}
+
+function resolvePath(path: string, cwd: string): string {
+  const normalizedPath = normalizePath(path);
+  const normalizedCwd = normalizePath(cwd);
+  return isAbsolute(normalizedPath) ? resolve(normalizedPath) : resolve(normalizedCwd, normalizedPath);
+}
+
+function normalizePath(path: string): string {
+  const home = homedir();
+  if (path === "~") return home;
+  if (path.startsWith("~/") || (process.platform === "win32" && path.startsWith("~\\"))) {
+    return join(home, path.slice(2));
+  }
+  return path.startsWith("file://") ? fileURLToPath(path) : path;
+}