@selesai/code 0.13.40 → 0.14.3

package/dist/core/tools/grep.js

@@ -17,6 +17,10 @@ const grepSchema = Type.Object({
     context: Type.Optional(Type.Number({ description: "Number of lines to show before and after each match (default: 0)" })),
     limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" })),
 });
+export const grepToolSystemPromptContribution = {
+    snippet: "Search file contents for patterns (respects .gitignore)",
+    guidelines: [],
+};
 const DEFAULT_LIMIT = 100;
 const defaultGrepOperations = {
     isDirectory: async (p) => (await fsStat(p)).isDirectory(),
@@ -28,7 +32,7 @@ export function createGrepToolDefinition(cwd, options) {
         name: "grep",
         label: "grep",
         description: `Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} matches or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Long lines are truncated to ${GREP_MAX_LINE_LENGTH} chars.`,
-        promptSnippet: "Search file contents for patterns (respects .gitignore)",
+        promptSnippet: grepToolSystemPromptContribution.snippet,
         parameters: grepSchema,
         async execute(_toolCallId, { pattern, path: searchDir, glob, ignoreCase, literal, context, limit, }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {

package/dist/core/tools/index.d.ts

@@ -1,10 +1,10 @@
 export { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, createBashTool, createBashToolDefinition, createLocalBashOperations, } from "./bash.ts";
-export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, type PowerShellOperations, type PowerShellSpawnContext, type PowerShellSpawnHook, type PowerShellToolDetails, type PowerShellToolInput, type PowerShellToolOptions, } from "./powershell.ts";
 export { createEditTool, createEditToolDefinition, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, } from "./edit.ts";
 export { withFileMutationQueue } from "./file-mutation-queue.ts";
 export { createFindTool, createFindToolDefinition, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, } from "./find.ts";
 export { createGrepTool, createGrepToolDefinition, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, } from "./grep.ts";
 export { createLsTool, createLsToolDefinition, type LsOperations, type LsToolDetails, type LsToolInput, type LsToolOptions, } from "./ls.ts";
+export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, type PowerShellOperations, type PowerShellSpawnContext, type PowerShellSpawnHook, type PowerShellToolDetails, type PowerShellToolInput, type PowerShellToolOptions, } from "./powershell.ts";
 export { createReadTool, createReadToolDefinition, type ReadOperations, type ReadToolDetails, type ReadToolInput, type ReadToolOptions, } from "./read.ts";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationOptions, type TruncationResult, truncateHead, truncateLine, truncateTail, } from "./truncate.ts";
 export { createWriteTool, createWriteToolDefinition, type WriteOperations, type WriteToolInput, type WriteToolOptions, } from "./write.ts";

package/dist/core/tools/index.js

@@ -1,10 +1,10 @@
 export { createBashTool, createBashToolDefinition, createLocalBashOperations, } from "./bash.js";
-export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, } from "./powershell.js";
 export { createEditTool, createEditToolDefinition, } from "./edit.js";
 export { withFileMutationQueue } from "./file-mutation-queue.js";
 export { createFindTool, createFindToolDefinition, } from "./find.js";
 export { createGrepTool, createGrepToolDefinition, } from "./grep.js";
 export { createLsTool, createLsToolDefinition, } from "./ls.js";
+export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, } from "./powershell.js";
 export { createReadTool, createReadToolDefinition, } from "./read.js";
 export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateLine, truncateTail, } from "./truncate.js";
 export { createWriteTool, createWriteToolDefinition, } from "./write.js";
@@ -16,7 +16,16 @@ import { createLsTool, createLsToolDefinition } from "./ls.js";
 import { createPowerShellTool, createPowerShellToolDefinition } from "./powershell.js";
 import { createReadTool, createReadToolDefinition } from "./read.js";
 import { createWriteTool, createWriteToolDefinition } from "./write.js";
-export const allToolNames = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls"]);
+export const allToolNames = new Set([
+    "read",
+    "bash",
+    "powershell",
+    "edit",
+    "write",
+    "grep",
+    "find",
+    "ls",
+]);
 export function createToolDefinition(toolName, cwd, options) {
     switch (toolName) {
         case "read":

package/dist/core/tools/ls.d.ts

@@ -6,6 +6,10 @@ declare const lsSchema: Type.TObject<{
     path: Type.TOptional<Type.TString>;
     limit: Type.TOptional<Type.TNumber>;
 }>;
+export declare const lsToolSystemPromptContribution: {
+    readonly snippet: "List directory contents";
+    readonly guidelines: readonly [];
+};
 export type LsToolInput = Static<typeof lsSchema>;
 export interface LsToolDetails {
     truncation?: TruncationResult;

package/dist/core/tools/ls.js

@@ -9,6 +9,10 @@ const lsSchema = Type.Object({
     path: Type.Optional(Type.String({ description: "Directory to list (default: current directory)" })),
     limit: Type.Optional(Type.Number({ description: "Maximum number of entries to return (default: 500)" })),
 });
+export const lsToolSystemPromptContribution = {
+    snippet: "List directory contents",
+    guidelines: [],
+};
 const DEFAULT_LIMIT = 500;
 const defaultLsOperations = {
     exists: pathExists,
@@ -21,7 +25,7 @@ export function createLsToolDefinition(cwd, options) {
         name: "ls",
         label: "ls",
         description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to ${DEFAULT_LIMIT} entries or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
-        promptSnippet: "List directory contents",
+        promptSnippet: lsToolSystemPromptContribution.snippet,
         parameters: lsSchema,
         async execute(_toolCallId, { path, limit }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {

package/dist/core/tools/output-accumulator.d.ts

@@ -9,6 +9,11 @@ export interface OutputSnapshot {
     truncation: TruncationResult;
     fullOutputPath?: string;
 }
+export interface FullOutput {
+    content: string;
+    /** Whether `content` omits part of the output. */
+    truncated: boolean;
+}
 /**
  * Incrementally tracks streaming output with bounded memory.
  *
@@ -42,6 +47,12 @@ export declare class OutputAccumulator {
         persistIfTruncated?: boolean;
     }): OutputSnapshot;
     closeTempFile(): Promise<void>;
+    /**
+     * The complete output, for callers that can take more than the display snapshot. Call after
+     * `finish()` and `closeTempFile()`. Output longer than `maxBytes` raw bytes keeps its first and
+     * last `maxBytes / 2` bytes around an omission marker.
+     */
+    readFullOutput(maxBytes: number): Promise<FullOutput>;
     getLastLineBytes(): number;
     private appendDecodedText;
     private trimTail;

package/dist/core/tools/output-accumulator.js

@@ -1,12 +1,6 @@
-import { randomBytes } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { open } from "node:fs/promises";
+import { createOutputFileStream } from "../../utils/output-files.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "./truncate.js";
-function defaultTempFilePath(prefix) {
-    const id = randomBytes(8).toString("hex");
-    return join(tmpdir(), `${prefix}-${id}.log`);
-}
 function byteLength(text) {
     return Buffer.byteLength(text, "utf-8");
 }
@@ -113,6 +107,41 @@ export class OutputAccumulator {
             stream.end();
         });
     }
+    /**
+     * The complete output, for callers that can take more than the display snapshot. Call after
+     * `finish()` and `closeTempFile()`. Output longer than `maxBytes` raw bytes keeps its first and
+     * last `maxBytes / 2` bytes around an omission marker.
+     */
+    async readFullOutput(maxBytes) {
+        if (!this.tempFilePath) {
+            return { content: new TextDecoder().decode(Buffer.concat(this.rawChunks)), truncated: false };
+        }
+        const file = await open(this.tempFilePath, "r");
+        try {
+            const size = (await file.stat()).size;
+            if (size <= maxBytes) {
+                return { content: new TextDecoder().decode(await file.readFile()), truncated: false };
+            }
+            const headBytes = Math.floor(maxBytes / 2);
+            const tailBytes = maxBytes - headBytes;
+            const head = Buffer.alloc(headBytes);
+            const tail = Buffer.alloc(tailBytes);
+            await file.read(head, 0, headBytes, 0);
+            await file.read(tail, 0, tailBytes, size - tailBytes);
+            // Cut at character boundaries: streaming decode holds back an incomplete trailing sequence,
+            // and the tail skips leading continuation bytes.
+            const headText = new TextDecoder().decode(head, { stream: true });
+            let tailStart = 0;
+            while (tailStart < tail.length && (tail[tailStart] & 0xc0) === 0x80)
+                tailStart++;
+            const tailText = new TextDecoder().decode(tail.subarray(tailStart));
+            const omitted = size - headBytes - tailBytes;
+            return { content: `${headText}\n\n[... ${omitted} bytes omitted ...]\n\n${tailText}`, truncated: true };
+        }
+        finally {
+            await file.close();
+        }
+    }
     getLastLineBytes() {
         return this.currentLineBytes;
     }
@@ -173,8 +202,9 @@ export class OutputAccumulator {
         if (this.tempFilePath) {
             return;
         }
-        this.tempFilePath = defaultTempFilePath(this.tempFilePrefix);
-        this.tempFileStream = createWriteStream(this.tempFilePath);
+        const { path, stream } = createOutputFileStream(this.tempFilePrefix, ".log");
+        this.tempFilePath = path;
+        this.tempFileStream = stream;
         for (const chunk of this.rawChunks) {
             this.tempFileStream.write(chunk);
         }

package/dist/core/tools/read.d.ts

@@ -1,5 +1,5 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
-import type { ImageContent } from "@earendil-works/pi-ai";
+import type { ImageContent, ModelImageResizeOptions } from "@earendil-works/pi-ai";
 import { type Static, Type } from "typebox";
 import type { ExtensionContext, ToolDefinition } from "../extensions/types.ts";
 import { type TruncationResult } from "./truncate.ts";
@@ -13,6 +13,19 @@ export declare const readToolSystemPromptContribution: {
     readonly guidelines: readonly ["Use read to examine files instead of cat or sed."];
 };
 export type ReadToolInput = Static<typeof readSchema>;
+/**
+ * Result for programmatic callers such as codemode scripts: the text for text files, and an image
+ * block for images that codemode's `image()` accepts. `note` is the text that goes with the image,
+ * such as resize hints. Property descriptions are left out so the type stays on one line in tool
+ * descriptions.
+ */
+declare const readOutputSchema: Type.TUnion<[Type.TString, Type.TObject<{
+    type: Type.TLiteral<"image">;
+    data: Type.TString;
+    mimeType: Type.TString;
+    note: Type.TString;
+}>]>;
+export type ReadToolOutput = Static<typeof readOutputSchema>;
 export interface ReadToolDetails {
     truncation?: TruncationResult;
 }
@@ -29,7 +42,7 @@ export interface ReadOperations {
     detectImageMimeType?: (absolutePath: string) => Promise<string | null | undefined>;
 }
 export interface ReadToolOptions {
-    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    /** Whether to auto-resize images. Default: true */
     autoResizeImages?: boolean;
     /**
      * Vision model ("provider/modelId") used to describe images when the active
@@ -37,6 +50,8 @@ export interface ReadToolOptions {
      * the image block. Default: unset (images are omitted as before).
      */
     imageCaptionModel?: string;
+    /** Fallback resize profile when the execution context has no model metadata. */
+    resizeOptions?: ModelImageResizeOptions;
     /** Custom operations for file reading. Default: local filesystem */
     operations?: ReadOperations;
 }

package/dist/core/tools/read.js

@@ -17,11 +17,27 @@ export const readToolSystemPromptContribution = {
     snippet: "Read file contents",
     guidelines: ["Use read to examine files instead of cat or sed."],
 };
+/**
+ * Result for programmatic callers such as codemode scripts: the text for text files, and an image
+ * block for images that codemode's `image()` accepts. `note` is the text that goes with the image,
+ * such as resize hints. Property descriptions are left out so the type stays on one line in tool
+ * descriptions.
+ */
+const readOutputSchema = Type.Union([
+    Type.String(),
+    Type.Object({ type: Type.Literal("image"), data: Type.String(), mimeType: Type.String(), note: Type.String() }),
+]);
 const defaultReadOperations = {
     readFile: (path) => fsReadFile(path),
     access: (path) => fsAccess(path, constants.R_OK),
     detectImageMimeType: detectSupportedImageMimeTypeFromFile,
 };
+/** The image block and its note, or the text for text files and images that could not be processed. */
+function toReadOutput(content) {
+    const text = content.find((block) => block.type === "text")?.text ?? "";
+    const image = content.find((block) => block.type === "image");
+    return image ? { type: "image", data: image.data, mimeType: image.mimeType, note: text } : text;
+}
 function getNonVisionImageNote(model) {
     if (!model || model.input.includes("image")) {
         return undefined;
@@ -61,6 +77,7 @@ export async function captionImage(image, captionModelId, ctx, signal) {
 export function createReadToolDefinition(cwd, options) {
     const autoResizeImages = options?.autoResizeImages ?? true;
     const imageCaptionModel = options?.imageCaptionModel;
+    const fallbackResizeOptions = options?.resizeOptions;
     const ops = options?.operations ?? defaultReadOperations;
     return {
         name: "read",
@@ -69,6 +86,7 @@ export function createReadToolDefinition(cwd, options) {
         promptSnippet: readToolSystemPromptContribution.snippet,
         promptGuidelines: [...readToolSystemPromptContribution.guidelines],
         parameters: readSchema,
+        outputSchema: readOutputSchema,
         constrainedSampling: { type: "json_schema", strict: "prefer" },
         async execute(_toolCallId, { path, offset, limit }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {
@@ -98,7 +116,10 @@ export function createReadToolDefinition(cwd, options) {
                         if (mimeType) {
                             // Read image as binary.
                             const buffer = await ops.readFile(absolutePath);
-                            const processed = await processImage(buffer, mimeType, { autoResizeImages });
+                            const processed = await processImage(buffer, mimeType, {
+                                autoResizeImages,
+                                resizeOptions: ctx?.model?.inputLimits?.images?.resize ?? fallbackResizeOptions,
+                            });
                             if (!processed.ok) {
                                 let textNote = `Read image file [${mimeType}]\n${processed.message}`;
                                 if (nonVisionImageNote)
@@ -204,7 +225,7 @@ export function createReadToolDefinition(cwd, options) {
                             reject(error);
                     }
                 })();
-            });
+            }).then((result) => ({ ...result, structuredContent: toReadOutput(result.content) }));
         },
         ...readRenderers,
     };

package/dist/core/tools/render-utils.d.ts

@@ -17,6 +17,12 @@ export type ToolRenderResultLike<TDetails> = {
     content: (TextContent | ImageContent)[];
     details: TDetails;
 };
+/**
+ * Generic tool call header: the title followed by the arguments. Collapsed, they are `key=value`
+ * pairs on the title line, cut to {@link COLLAPSED_ARGS_CHARS}. Expanded, each is a `key: value`
+ * line below the title, with strings shown raw and continuation lines indented.
+ */
+export declare function formatToolCallWithArgs(title: string, args: unknown, theme: Theme, expanded: boolean): string;
 export declare function invalidArgText(theme: Theme): string;
 export declare function renderToolPath(rawPath: string | null, theme: Theme, cwd: string, options?: {
     emptyFallback?: string;

package/dist/core/tools/render-utils.js

@@ -51,6 +51,32 @@ export function getTextOutput(result, showImages) {
     }
     return output;
 }
+const COLLAPSED_ARGS_CHARS = 100;
+/**
+ * Generic tool call header: the title followed by the arguments. Collapsed, they are `key=value`
+ * pairs on the title line, cut to {@link COLLAPSED_ARGS_CHARS}. Expanded, each is a `key: value`
+ * line below the title, with strings shown raw and continuation lines indented.
+ */
+export function formatToolCallWithArgs(title, args, theme, expanded) {
+    const header = theme.fg("toolTitle", theme.bold(title));
+    if (args == null)
+        return header;
+    const entries = typeof args === "object" && !Array.isArray(args)
+        ? Object.entries(args)
+        : [["args", args]];
+    if (entries.length === 0)
+        return header;
+    if (expanded) {
+        const lines = entries.map(([key, value]) => {
+            const text = typeof value === "string" ? value : (JSON.stringify(value, null, 2) ?? String(value));
+            return `  ${key}: ${replaceTabs(text).replace(/\r/g, "").split("\n").join("\n    ")}`;
+        });
+        return `${header}\n${theme.fg("muted", lines.join("\n"))}`;
+    }
+    const pairs = entries.map(([key, value]) => `${key}=${JSON.stringify(value) ?? String(value)}`).join(" ");
+    const preview = pairs.length > COLLAPSED_ARGS_CHARS ? `${pairs.slice(0, COLLAPSED_ARGS_CHARS - 3)}...` : pairs;
+    return `${header} ${theme.fg("muted", preview)}`;
+}
 export function invalidArgText(theme) {
     return theme.fg("error", "[invalid arg]");
 }

package/dist/core/tools/renderers/bash.js

@@ -5,21 +5,14 @@
  * load the execution path or its typebox parameter schema. `bash.ts` spreads these into the shell
  * tool definition, so the tool's public shape is unchanged.
  */
-import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { keyHint } from "../../../modes/interactive/components/keybinding-hints.js";
-import { truncateToVisualLines } from "../../../modes/interactive/components/visual-truncate.js";
+import { VisualLinePreview } from "../../../modes/interactive/components/visual-truncate.js";
 import { theme } from "../../../modes/interactive/theme/theme.js";
 import { getTextOutput, invalidArgText, str } from "../render-utils.js";
 import { DEFAULT_MAX_BYTES, formatSize } from "../truncate.js";
 const BASH_PREVIEW_LINES = 5;
 export const BASH_UPDATE_THROTTLE_MS = 100;
-class BashResultRenderComponent extends Container {
-    state = {
-        cachedWidth: undefined,
-        cachedLines: undefined,
-        cachedSkipped: undefined,
-    };
-}
 function formatDuration(ms) {
     const seconds = ms / 1000;
     if (seconds < 60)
@@ -38,8 +31,7 @@ function formatShellCall(args, prompt) {
     const commandDisplay = command === null ? invalidArgText(theme) : command ? command : theme.fg("toolOutput", "...");
     return theme.fg("toolTitle", theme.bold(`${prompt} ${commandDisplay}`)) + timeoutSuffix;
 }
-function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt) {
-    const state = component.state;
+function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt, durationMs) {
     component.clear();
     let output = getTextOutput(result, showImages).trim();
     const truncation = result.details?.truncation;
@@ -59,27 +51,14 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
             component.addChild(new Text(`\n${styledOutput}`, 0, 0));
         }
         else {
-            component.addChild({
-                render: (width) => {
-                    if (state.cachedLines === undefined || state.cachedWidth !== width) {
-                        const preview = truncateToVisualLines(styledOutput, BASH_PREVIEW_LINES, width);
-                        state.cachedLines = preview.visualLines;
-                        state.cachedSkipped = preview.skippedCount;
-                        state.cachedWidth = width;
-                    }
-                    if (state.cachedSkipped && state.cachedSkipped > 0) {
-                        const hint = theme.fg("muted", `... (${state.cachedSkipped} earlier lines,`) +
-                            ` ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
-                        return ["", truncateToWidth(hint, width, "..."), ...(state.cachedLines ?? [])];
-                    }
-                    return ["", ...(state.cachedLines ?? [])];
-                },
-                invalidate: () => {
-                    state.cachedWidth = undefined;
-                    state.cachedLines = undefined;
-                    state.cachedSkipped = undefined;
-                },
-            });
+            component.addChild(new Spacer(1));
+            component.addChild(new VisualLinePreview({
+                text: styledOutput,
+                maxVisualLines: BASH_PREVIEW_LINES,
+                keep: "end",
+                formatHint: (hidden) => theme.fg("muted", `... (${hidden} earlier lines,`) +
+                    ` ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`,
+            }));
         }
     }
     if (truncation?.truncated || fullOutputPath) {
@@ -97,7 +76,12 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
         }
         component.addChild(new Text(`\n${theme.fg("warning", `[${warnings.join(". ")}]`)}`, 0, 0));
     }
-    if (startedAt !== undefined) {
+    // A final result's recorded duration wins: it is monotonic and survives reloads. The renderer's own clock is the
+    // fallback for live progress and for results stored without one.
+    if (!options.isPartial && durationMs !== undefined) {
+        component.addChild(new Text(`\n${theme.fg("muted", `Took ${formatDuration(durationMs)}`)}`, 0, 0));
+    }
+    else if (startedAt !== undefined) {
         const label = options.isPartial ? "Elapsed" : "Took";
         const endTime = endedAt ?? Date.now();
         component.addChild(new Text(`\n${theme.fg("muted", `${label} ${formatDuration(endTime - startedAt)}`)}`, 0, 0));
@@ -128,8 +112,8 @@ export function createShellRenderers(prompt) {
                     state.interval = undefined;
                 }
             }
-            const component = context.lastComponent ?? new BashResultRenderComponent();
-            rebuildBashResultRenderComponent(component, result, options, context.showImages, state.startedAt, state.endedAt);
+            const component = context.lastComponent ?? new Container();
+            rebuildBashResultRenderComponent(component, result, options, context.showImages, state.startedAt, state.endedAt, context.durationMs);
             component.invalidate();
             return component;
         },

package/dist/core/tools/renderers/edit.js

@@ -84,8 +84,9 @@ function getEditHeaderBg(preview, settledError, theme) {
     }
     return (text) => theme.bg("toolPendingBg", text);
 }
-function buildEditCallComponent(component, args, theme, cwd) {
+function buildEditCallComponent(component, args, theme, cwd, outputPad) {
     component.setBgFn(getEditHeaderBg(component.preview, component.settledError, theme));
+    component.setPaddingX(outputPad);
     component.clear();
     component.addChild(new Text(formatEditCall(args, theme, cwd), 0, 0));
     if (!component.preview) {
@@ -131,7 +132,7 @@ export const editRenderers = {
                 }
             });
         }
-        return buildEditCallComponent(component, args, theme, context.cwd);
+        return buildEditCallComponent(component, args, theme, context.cwd, context.outputPad);
     },
     renderResult(result, _options, theme, context) {
         const callComponent = context.state.callComponent;
@@ -150,7 +151,7 @@ export const editRenderers = {
                 changed = true;
             }
             if (changed) {
-                buildEditCallComponent(callComponent, context.args, theme, context.cwd);
+                buildEditCallComponent(callComponent, context.args, theme, context.cwd, context.outputPad);
             }
         }
         const output = formatEditResult(context.args, callComponent?.preview, typedResult, theme, context.isError);
@@ -160,7 +161,7 @@ export const editRenderers = {
             return component;
         }
         component.addChild(new Spacer(1));
-        component.addChild(new Text(output, 1, 0));
+        component.addChild(new Text(output, context.outputPad, 0));
         return component;
     },
 };

package/dist/core/tools/renderers/index.d.ts

@@ -5,7 +5,7 @@
  * typebox parameter schemas. Importing this instead of `core/tools/index.ts` keeps ~17 MB of module
  * graph out of a process that only renders.
  */
-import type { ToolDefinition } from "../../extensions/types.ts";
+import type { ToolRenderers } from "../../extensions/types.ts";
 import type { ToolName } from "../index.ts";
 import { createShellRenderers } from "./bash.ts";
 import { editRenderers } from "./edit.ts";
@@ -14,7 +14,7 @@ import { grepRenderers } from "./grep.ts";
 import { lsRenderers } from "./ls.ts";
 import { readRenderers } from "./read.ts";
 import { writeRenderers } from "./write.ts";
-export type ToolRenderers = Pick<ToolDefinition<any, any>, "renderCall" | "renderResult">;
+export type { ToolRenderers };
 export { createShellRenderers, editRenderers, findRenderers, grepRenderers, lsRenderers, readRenderers, writeRenderers, };
 /** Renderers for every built-in tool, keyed by tool name. */
 export declare function createAllToolRenderers(): Record<ToolName, ToolRenderers>;

package/dist/core/tools/renderers/read.js

@@ -16,10 +16,11 @@ import { getTextOutput, renderToolPath, replaceTabs, str } from "../render-utils
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "../truncate.js";
 const COMPACT_RESOURCE_FILE_NAMES = new Set(["AGENTS.override.md", "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"]);
 function formatReadLineRange(args, theme) {
-    if (args?.offset === undefined && args?.limit === undefined)
+    // Strict tool schemas make models send null for omitted optional fields.
+    if (args?.offset == null && args?.limit == null)
         return "";
     const startLine = args.offset ?? 1;
-    const endLine = args.limit !== undefined ? startLine + args.limit - 1 : "";
+    const endLine = args.limit != null ? startLine + args.limit - 1 : "";
     return theme.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
 }
 function formatReadCall(args, theme, cwd) {

package/dist/core/tools/tool-definition-wrapper.d.ts

@@ -1,9 +1,11 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
-import type { ExtensionContext, ToolDefinition } from "../extensions/types.ts";
+import type { ExtensionToolContext, ToolDefinition } from "../extensions/types.ts";
+/** Creates the context for one tool call. */
+export type ToolContextFactory = (toolCallId: string, signal: AbortSignal | undefined) => ExtensionToolContext;
 /** Wrap a ToolDefinition into an AgentTool for the core runtime. */
-export declare function wrapToolDefinition<TDetails = unknown>(definition: ToolDefinition<any, TDetails>, ctxFactory?: () => ExtensionContext): AgentTool<any, TDetails>;
+export declare function wrapToolDefinition<TDetails = unknown>(definition: ToolDefinition<any, TDetails>, ctxFactory?: ToolContextFactory): AgentTool<any, TDetails>;
 /** Wrap multiple ToolDefinitions into AgentTools for the core runtime. */
-export declare function wrapToolDefinitions(definitions: ToolDefinition<any, any>[], ctxFactory?: () => ExtensionContext): AgentTool<any>[];
+export declare function wrapToolDefinitions(definitions: ToolDefinition<any, any>[], ctxFactory?: ToolContextFactory): AgentTool<any>[];
 /**
  * Synthesize a minimal ToolDefinition from an AgentTool.
  *

package/dist/core/tools/tool-definition-wrapper.js

@@ -5,10 +5,11 @@ export function wrapToolDefinition(definition, ctxFactory) {
         label: definition.label,
         description: definition.description,
         parameters: definition.parameters,
+        outputSchema: definition.outputSchema,
         constrainedSampling: definition.constrainedSampling,
         prepareArguments: definition.prepareArguments,
         executionMode: definition.executionMode,
-        execute: (toolCallId, params, signal, onUpdate, ctx) => definition.execute(toolCallId, params, signal, onUpdate, ctx ?? ctxFactory?.()),
+        execute: (toolCallId, params, signal, onUpdate, ctx) => definition.execute(toolCallId, params, signal, onUpdate, ctx ?? ctxFactory?.(toolCallId, signal)),
     };
 }
 /** Wrap multiple ToolDefinitions into AgentTools for the core runtime. */
@@ -27,6 +28,7 @@ export function createToolDefinitionFromAgentTool(tool) {
         label: tool.label,
         description: tool.description,
         parameters: tool.parameters,
+        outputSchema: tool.outputSchema,
         constrainedSampling: tool.constrainedSampling,
         prepareArguments: tool.prepareArguments,
         executionMode: tool.executionMode,

package/dist/core/tools/truncate.d.ts

@@ -67,3 +67,17 @@ export declare function truncateLine(line: string, maxChars?: number): {
     text: string;
     wasTruncated: boolean;
 };
+export interface MiddleTruncationResult {
+    /** The start and end of the content with a `…N chars truncated…` marker between them. */
+    content: string;
+    truncated: boolean;
+    /** Characters left out. */
+    removedChars: number;
+    totalBytes: number;
+    totalLines: number;
+}
+/**
+ * Keep the start and the end of `content`, half of `maxBytes` each, and replace the middle with a
+ * `…N chars truncated…` marker, like Codex does for tool output. Cuts only at character boundaries.
+ */
+export declare function truncateMiddle(content: string, maxBytes: number): MiddleTruncationResult;

package/dist/core/tools/truncate.js

@@ -212,3 +212,32 @@ export function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
     }
     return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
 }
+/**
+ * Keep the start and the end of `content`, half of `maxBytes` each, and replace the middle with a
+ * `…N chars truncated…` marker, like Codex does for tool output. Cuts only at character boundaries.
+ */
+export function truncateMiddle(content, maxBytes) {
+    const buf = Buffer.from(content, "utf-8");
+    const totalLines = splitLinesForCounting(content).length;
+    if (buf.length <= maxBytes) {
+        return { content, truncated: false, removedChars: 0, totalBytes: buf.length, totalLines };
+    }
+    // Continuation bytes (10xxxxxx) are not character starts.
+    const isBoundary = (index) => index >= buf.length || (buf[index] & 0xc0) !== 0x80;
+    let headEnd = Math.floor(maxBytes / 2);
+    while (headEnd > 0 && !isBoundary(headEnd))
+        headEnd--;
+    let tailStart = buf.length - (maxBytes - Math.floor(maxBytes / 2));
+    while (tailStart < buf.length && !isBoundary(tailStart))
+        tailStart++;
+    const head = buf.subarray(0, headEnd).toString("utf-8");
+    const tail = buf.subarray(tailStart).toString("utf-8");
+    const removedChars = Array.from(buf.subarray(headEnd, tailStart).toString("utf-8")).length;
+    return {
+        content: `${head}…${removedChars} chars truncated…${tail}`,
+        truncated: true,
+        removedChars,
+        totalBytes: buf.length,
+        totalLines,
+    };
+}

package/dist/core/tools/write.d.ts

@@ -5,6 +5,10 @@ declare const writeSchema: Type.TObject<{
     path: Type.TString;
     content: Type.TString;
 }>;
+export declare const writeToolSystemPromptContribution: {
+    readonly snippet: "Create or overwrite files";
+    readonly guidelines: readonly ["Use write only for new files or complete rewrites."];
+};
 export type WriteToolInput = Static<typeof writeSchema>;
 /**
  * Pluggable operations for the write tool.

package/dist/core/tools/write.js

@@ -9,6 +9,10 @@ const writeSchema = Type.Object({
     path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
     content: Type.String({ description: "Content to write to the file" }),
 });
+export const writeToolSystemPromptContribution = {
+    snippet: "Create or overwrite files",
+    guidelines: ["Use write only for new files or complete rewrites."],
+};
 const defaultWriteOperations = {
     writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
     mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => { }),
@@ -19,8 +23,8 @@ export function createWriteToolDefinition(cwd, options) {
         name: "write",
         label: "write",
         description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
-        promptSnippet: "Create or overwrite files",
-        promptGuidelines: ["Use write only for new files or complete rewrites."],
+        promptSnippet: writeToolSystemPromptContribution.snippet,
+        promptGuidelines: [...writeToolSystemPromptContribution.guidelines],
         parameters: writeSchema,
         constrainedSampling: { type: "json_schema", strict: "prefer" },
         async execute(_toolCallId, { path, content }, signal, _onUpdate, ctx) {