@selesai/code 0.13.40 → 0.14.3

package/dist/core/skills.js

@@ -79,7 +79,7 @@ export function validateName(name) {
  */
 export function validateDescription(description) {
     const errors = [];
-    if (!description || description.trim() === "") {
+    if (typeof description !== "string" || description.trim() === "") {
         errors.push("description is required");
     }
     else if (description.length > MAX_DESCRIPTION_LENGTH) {
@@ -207,45 +207,63 @@ function loadSkillsFromDirInternal(dir, source, includeRootFiles, ignoreMatcher,
 }
 function loadSkillFromFile(filePath, source) {
     const diagnostics = [];
+    const isDeclaredSkill = basename(filePath) === "SKILL.md";
+    let rawContent;
     try {
-        const rawContent = readFileSync(filePath, "utf-8");
-        const { frontmatter } = parseFrontmatter(rawContent);
-        const skillDir = dirname(filePath);
-        const parentDirName = basename(skillDir);
-        // Validate description
-        const descErrors = validateDescription(frontmatter.description);
-        for (const error of descErrors) {
-            diagnostics.push({ type: "warning", message: error, path: filePath });
-        }
-        // Use name from frontmatter, or fall back to parent directory name
-        const name = frontmatter.name || parentDirName;
-        // Validate name
-        const nameErrors = validateName(name);
-        for (const error of nameErrors) {
-            diagnostics.push({ type: "warning", message: error, path: filePath });
-        }
-        // Still load the skill even with warnings (unless description is completely missing)
-        if (!frontmatter.description || frontmatter.description.trim() === "") {
-            return { skill: null, diagnostics };
-        }
-        return {
-            skill: {
-                name,
-                description: frontmatter.description,
-                category: frontmatter.category?.trim() || undefined,
-                filePath,
-                baseDir: skillDir,
-                sourceInfo: createSkillSourceInfo(filePath, skillDir, source),
-                disableModelInvocation: frontmatter["disable-model-invocation"] === true,
-            },
-            diagnostics,
-        };
+        rawContent = readFileSync(filePath, "utf-8");
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : "failed to parse skill file";
+        const message = error instanceof Error ? error.message : "failed to read skill file";
         diagnostics.push({ type: "warning", message, path: filePath });
         return { skill: null, diagnostics };
     }
+    let frontmatter;
+    try {
+        ({ frontmatter } = parseFrontmatter(rawContent));
+    }
+    catch (error) {
+        if (isDeclaredSkill) {
+            const message = error instanceof Error ? error.message : "failed to parse skill file";
+            diagnostics.push({ type: "warning", message, path: filePath });
+        }
+        return { skill: null, diagnostics };
+    }
+    const description = frontmatter.description;
+    const hasDescription = typeof description === "string" && description.trim() !== "";
+    if (!isDeclaredSkill && !hasDescription) {
+        return { skill: null, diagnostics };
+    }
+    const skillDir = dirname(filePath);
+    const parentDirName = basename(skillDir);
+    // Validate description
+    const descErrors = validateDescription(description);
+    for (const error of descErrors) {
+        diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    // Use name from frontmatter, or fall back to parent directory name
+    const frontmatterName = typeof frontmatter.name === "string" ? frontmatter.name : undefined;
+    const name = frontmatterName || parentDirName;
+    // Validate name
+    const nameErrors = validateName(name);
+    for (const error of nameErrors) {
+        diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    // Still load the skill even with warnings, unless description is missing or empty.
+    if (!hasDescription) {
+        return { skill: null, diagnostics };
+    }
+    return {
+        skill: {
+            name,
+            description,
+            category: typeof frontmatter.category === "string" ? frontmatter.category.trim() || undefined : undefined,
+            filePath,
+            baseDir: skillDir,
+            sourceInfo: createSkillSourceInfo(filePath, skillDir, source),
+            disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+        },
+        diagnostics,
+    };
 }
 /**
  * Format skills for inclusion in a system prompt.
@@ -254,6 +272,9 @@ function loadSkillFromFile(filePath, source) {
  *
  * Skills with disableModelInvocation=true are excluded from the prompt
  * (they can only be invoked explicitly via /skill:name commands).
+ *
+ * `fileReadTool` names the tool that loads skill files; `indirect` names none, for a reader that
+ * is reachable only through another tool.
  */
 export function formatSkillsForPrompt(skills, fileReadTool = "read") {
     const visibleSkills = skills.filter((s) => !s.disableModelInvocation);
@@ -264,7 +285,9 @@ export function formatSkillsForPrompt(skills, fileReadTool = "read") {
         "\n\nThe following skills provide specialized instructions for specific tasks.",
         fileReadTool === "read"
             ? "Use the read tool to load a skill's file when the task matches its description, unless its full instructions are already embedded in the current user message inside a <skill> block."
-            : "Use bash to load a skill's file when the task matches its description, unless its full instructions are already embedded in the current user message inside a <skill> block.",
+            : fileReadTool === "bash"
+                ? "Use bash to load a skill's file when the task matches its description, unless its full instructions are already embedded in the current user message inside a <skill> block."
+                : "Load a skill's file when the task matches its description, unless its full instructions are already embedded in the current user message inside a <skill> block.",
         "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
         "",
         "<available_skills>",

package/dist/core/slash-commands.js

@@ -3,6 +3,8 @@ export const BUILTIN_SLASH_COMMANDS = [
     { name: "settings", description: "Open settings menu" },
     { name: "settings-factory-reset", description: "Reset settings to factory defaults (with confirmation)" },
     { name: "model", description: "Select model (opens selector UI)", argumentHint: "<provider/model>" },
+    { name: "tree", description: "Navigate session tree (switch branches)" },
+    { name: "thinking", description: "Set thinking level", argumentHint: "<level>" },
     { name: "scoped-models", description: "Enable/disable models for Ctrl+P cycling" },
     { name: "export", description: "Export session (HTML default, or specify path: .html/.jsonl)" },
     { name: "import", description: "Import and resume a session from a JSONL file" },
@@ -16,7 +18,6 @@ export const BUILTIN_SLASH_COMMANDS = [
     { name: "git", description: "Git helper: worktrees, checkpoints, commits, and pushes" },
     { name: "fork", description: "Create a new fork from a previous user message" },
     { name: "clone", description: "Duplicate the current session at the current position" },
-    { name: "tree", description: "Navigate session tree (switch branches)" },
     { name: "trust", description: "Save project trust decision for future sessions" },
     { name: "login", description: "Configure provider authentication", argumentHint: "<provider>" },
     { name: "logout", description: "Remove provider authentication" },

package/dist/core/source-info.d.ts

@@ -8,6 +8,14 @@ export interface SourceInfo {
     origin: SourceOrigin;
     baseDir?: string;
 }
+/** Prefix of built-in tool and extension paths, such as `builtin:read` or `builtin:mcp`. */
+export declare const BUILTIN_PATH_PREFIX = "builtin:";
+/**
+ * Source of a path that names no file: `builtin` for `builtin:<name>`, or the prefix of an
+ * angle-bracket path such as `inline` for `<inline:name>`. Undefined for file paths.
+ */
+export declare function getSyntheticPathSource(path: string): string | undefined;
+export declare function isSyntheticPath(path: string): boolean;
 export declare function createSourceInfo(path: string, metadata: PathMetadata): SourceInfo;
 export declare function createSyntheticSourceInfo(path: string, options: {
     source: string;

package/dist/core/source-info.js

@@ -1,3 +1,19 @@
+/** Prefix of built-in tool and extension paths, such as `builtin:read` or `builtin:mcp`. */
+export const BUILTIN_PATH_PREFIX = "builtin:";
+/**
+ * Source of a path that names no file: `builtin` for `builtin:<name>`, or the prefix of an
+ * angle-bracket path such as `inline` for `<inline:name>`. Undefined for file paths.
+ */
+export function getSyntheticPathSource(path) {
+    if (path.startsWith(BUILTIN_PATH_PREFIX))
+        return "builtin";
+    if (path.startsWith("<") && path.endsWith(">"))
+        return path.slice(1, -1).split(":")[0] || "temporary";
+    return undefined;
+}
+export function isSyntheticPath(path) {
+    return path.startsWith(BUILTIN_PATH_PREFIX) || path.startsWith("<");
+}
 export function createSourceInfo(path, metadata) {
     return {
         path,

package/dist/core/system-prompt.d.ts

@@ -8,15 +8,20 @@ export interface BuildSystemPromptOptions {
     customPrompt?: string;
     /** Exact full prompt replacement set by a before_agent_start handler. */
     forceSystemPrompt?: string;
-    /** Tools to include in prompt. Default: [read, bash, edit, write] */
+    /** Tools to include in prompt. Default: [read, bash, edit, write]. */
     selectedTools?: string[];
+    /**
+     * Selected tools whose declarations requests leave out (`prepareLoadout` hidden declarations).
+     * They are reachable only through another tool, so the tool list and rules leave them out too.
+     */
+    hiddenTools?: string[];
     /** Optional one-line tool snippets keyed by tool name. */
     toolSnippets?: Record<string, string>;
     /** Guideline bullets contributed by each tool, keyed by tool name. */
     toolGuidelines?: Record<string, string[]>;
-    /** Additional guideline bullets appended to the default system prompt guidelines. */
+    /** Additional guideline bullets appended to the default system prompt rules. */
     promptGuidelines?: string[];
-    /** Text to append to system prompt. */
+    /** Text appended from user configuration before project context, skills, and cwd. */
     appendSystemPrompt?: string;
     /** Additional XML-wrapped prompt sections keyed by tag name. */
     sections?: Record<string, string>;
@@ -34,6 +39,7 @@ export interface BuildSystemPromptOptions {
 }
 export type NormalizedBuildSystemPromptOptions = BuildSystemPromptOptions & {
     selectedTools: string[];
+    hiddenTools: string[];
     toolSnippets: Record<string, string>;
     toolGuidelines: Record<string, string[]>;
     promptGuidelines: string[];

package/dist/core/system-prompt.js

@@ -5,12 +5,6 @@ import { getSystemMessageText } from "@earendil-works/pi-ai";
 import { getDocsPath, getExamplesPath, getReadmePath } from "../config.js";
 import { formatAgentsForPrompt } from "./agents.js";
 import { formatSkillsForPrompt } from "./skills.js";
-/**
- * Generic delegation-routing threshold for main sessions. The text is
- * self-conditioning ("when a delegation/subagent tool is available"), so
- * sessions without such a tool are unaffected.
- */
-const DELEGATION_ROUTING_GUIDELINE = "When a delegation/subagent tool is available: keep tiny targeted reads and simple answers local; send broad local investigation, external research, and mutation/implementation work to a capable delegated agent, inspecting the delegation catalog/list before selecting; the parent remains the decision-maker and normally the sole writer.";
 const SYSTEM_PROMPT_SECTION_NAME = /^[a-z][a-z0-9_-]*$/;
 /** Normalize prompt input into the mutable, collection-complete shape exposed to extensions. */
 export function normalizeBuildSystemPromptOptions(input) {
@@ -18,6 +12,7 @@ export function normalizeBuildSystemPromptOptions(input) {
         customPrompt: input.customPrompt,
         forceSystemPrompt: input.forceSystemPrompt,
         selectedTools: [...(input.selectedTools ?? ["read", "bash", "edit", "write"])],
+        hiddenTools: [...(input.hiddenTools ?? [])],
         toolSnippets: { ...(input.toolSnippets ?? {}) },
         toolGuidelines: Object.fromEntries(Object.entries(input.toolGuidelines ?? {}).map(([name, guidelines]) => [name, [...guidelines]])),
         promptGuidelines: [...(input.promptGuidelines ?? [])],
@@ -67,8 +62,6 @@ export function buildRules(selectedTools, toolGuidelines, promptGuidelines) {
     }
     for (const rule of promptGuidelines)
         addRule(rule);
-    // Selesai fork: delegation routing is part of the default rule set.
-    addRule(DELEGATION_ROUTING_GUIDELINE);
     addRule("Be concise in your responses");
     addRule("Show file paths clearly when working with files");
     return rules.map((rule) => `- ${rule}`).join("\n");
@@ -100,12 +93,13 @@ function buildActiveToolGuidelines(promptGuidelines) {
 /** Build the ordered, independently replaceable sections of the structured system prompt. */
 export function buildSystemPromptSections(input) {
     const options = normalizeBuildSystemPromptOptions(input);
-    const { customPrompt, selectedTools, toolSnippets, toolGuidelines, promptGuidelines, appendSystemPrompt, sections: customSections, cwd, contextFiles, skills, agents, } = options;
+    const { customPrompt, selectedTools, hiddenTools, toolSnippets, toolGuidelines, promptGuidelines, appendSystemPrompt, sections: customSections, cwd, contextFiles, skills, agents, } = options;
     for (const name of Object.keys(customSections)) {
         if (!SYSTEM_PROMPT_SECTION_NAME.test(name) || name === "preamble") {
             throw new Error(`Invalid system prompt section name: ${name}`);
         }
     }
+    const declaredTools = selectedTools.filter((name) => !hiddenTools.includes(name));
     const promptSections = {};
     if (customPrompt) {
         promptSections.preamble = customPrompt;
@@ -116,17 +110,20 @@ export function buildSystemPromptSections(input) {
     }
     else {
         promptSections.preamble = buildForkPreamble();
-        const visibleTools = selectedTools.filter((name) => !!toolSnippets[name]);
+        const visibleTools = declaredTools.filter((name) => !!toolSnippets[name]);
         const tools = visibleTools.length > 0 ? visibleTools.map((name) => `- ${name}: ${toolSnippets[name]}`).join("\n") : "(none)";
         promptSections.tools = `${tools}\n\nIn addition to the tools above, you may have access to other custom tools depending on the project.`;
-        promptSections.rules = buildRules(selectedTools, toolGuidelines, promptGuidelines);
+        promptSections.rules = buildRules(declaredTools, toolGuidelines, promptGuidelines);
         promptSections.docs = buildForkDocsSection();
     }
     if (appendSystemPrompt)
         promptSections.addendum = appendSystemPrompt;
     if (contextFiles.length > 0)
         promptSections.project_context = renderProjectContext(contextFiles);
-    const skillFileReadTool = ["read", "bash"].find((tool) => selectedTools.includes(tool));
+    // A hidden reader is still reachable through another tool, so skills stay but the hint names no tool.
+    const readers = ["read", "bash"];
+    const skillFileReadTool = readers.find((tool) => declaredTools.includes(tool)) ??
+        (readers.some((tool) => selectedTools.includes(tool)) ? "indirect" : undefined);
     if (skillFileReadTool && skills.length > 0) {
         const skillsPrompt = formatSkillsForPrompt(skills, skillFileReadTool).trim();
         if (skillsPrompt)

package/dist/core/system-prompt.test.js

@@ -17,14 +17,9 @@ const agent = {
     frontmatter: {},
 };
 describe("buildSystemPrompt", () => {
-    it("includes the generic delegation-routing threshold in the default prompt", () => {
+    it("leaves delegation policy to the subagent tool (no generic routing rule)", () => {
         const prompt = buildSystemPrompt({ cwd: "/tmp/project" });
-        expect(prompt).toMatch(/When a delegation\/subagent tool is available/i);
-        expect(prompt).toMatch(/keep tiny targeted reads and simple answers local/i);
-        expect(prompt).toMatch(/broad local investigation, external research, and mutation\/implementation work/i);
-        expect(prompt).toMatch(/capable delegated agent/i);
-        expect(prompt).toMatch(/inspecting the delegation catalog\/list before selecting/i);
-        expect(prompt).toMatch(/parent remains the decision-maker and normally the sole writer/i);
+        expect(prompt).not.toMatch(/delegation\/subagent tool is available/i);
         expect(prompt).toContain("<rules>");
         expect(prompt).toContain("- Be concise in your responses");
         expect(prompt).toContain("<cwd>\n/tmp/project\n</cwd>");

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

@@ -12,6 +12,18 @@ export declare const bashToolSystemPromptContribution: {
     readonly guidelines: readonly ["You can inspect PI_* environment variables for current model and session details."];
 };
 export type BashToolInput = Static<typeof bashSchema>;
+/**
+ * Result for programmatic callers such as codemode scripts. A non-zero exit code is an error result for the model, but scripts still resolve to this value.
+ * `output` is not limited like the model-facing output: callers decide how much of it reaches the model.
+ */
+declare const bashOutputSchema: Type.TObject<{
+    output: Type.TString;
+    truncated: Type.TBoolean;
+    full_output_path: Type.TOptional<Type.TString>;
+    exit_code: Type.TNumber;
+    wall_time_seconds: Type.TNumber;
+}>;
+export type BashToolOutput = Static<typeof bashOutputSchema>;
 export interface BashToolDetails {
     truncation?: TruncationResult;
     fullOutputPath?: string;

package/dist/core/tools/bash.js

@@ -10,6 +10,8 @@ import { BASH_UPDATE_THROTTLE_MS, createShellRenderers } from "./renderers/bash.
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "./truncate.js";
 const MAX_TIMEOUT_MS = 2_147_483_647;
+/** Output limit of `structuredContent.output`, which programmatic callers such as codemode scripts receive. */
+const STRUCTURED_OUTPUT_MAX_BYTES = 1024 * 1024;
 const MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1000;
 function resolveTimeoutMs(timeout) {
     if (timeout === undefined)
@@ -31,6 +33,17 @@ export const bashToolSystemPromptContribution = {
     snippet: "Execute bash commands (ls, grep, find, etc.)",
     guidelines: ["You can inspect PI_* environment variables for current model and session details."],
 };
+/**
+ * Result for programmatic callers such as codemode scripts. A non-zero exit code is an error result for the model, but scripts still resolve to this value.
+ * `output` is not limited like the model-facing output: callers decide how much of it reaches the model.
+ */
+const bashOutputSchema = Type.Object({
+    output: Type.String({ description: "Combined stdout and stderr, possibly truncated" }),
+    truncated: Type.Boolean(),
+    full_output_path: Type.Optional(Type.String({ description: "Full output, when truncated" })),
+    exit_code: Type.Number(),
+    wall_time_seconds: Type.Number(),
+});
 /** Shared process execution used by the built-in shell tools. */
 export function createLocalShellOperations(shellName, resolveShellConfig) {
     return {
@@ -154,6 +167,7 @@ export function createShellToolDefinition(cwd, config, options) {
         promptSnippet: config.promptSnippet,
         promptGuidelines: exposeSessionEnvironment && config.promptGuidelines ? [...config.promptGuidelines] : undefined,
         parameters: bashSchema,
+        outputSchema: bashOutputSchema,
         constrainedSampling: { type: "json_schema", strict: "prefer" },
         async execute(_toolCallId, { command, timeout }, signal, onUpdate, ctx) {
             const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
@@ -238,6 +252,7 @@ export function createShellToolDefinition(cwd, config, options) {
                 return { text, details };
             };
             const appendStatus = (text, status) => `${text ? `${text}\n\n` : ""}${status}`;
+            const startedAt = performance.now();
             try {
                 let exitCode;
                 try {
@@ -266,10 +281,26 @@ export function createShellToolDefinition(cwd, config, options) {
                 if (exitCode === null) {
                     throw new Error(appendStatus(outputText, "Command terminated without an exit code"));
                 }
+                const wallTimeSeconds = Math.round((performance.now() - startedAt) / 100) / 10;
+                const fullOutput = await output.readFullOutput(STRUCTURED_OUTPUT_MAX_BYTES);
+                const structuredContent = {
+                    output: fullOutput.content,
+                    truncated: fullOutput.truncated,
+                    ...(fullOutput.truncated && snapshot.fullOutputPath
+                        ? { full_output_path: snapshot.fullOutputPath }
+                        : {}),
+                    exit_code: exitCode,
+                    wall_time_seconds: wallTimeSeconds,
+                };
                 if (exitCode !== 0) {
-                    throw new Error(appendStatus(outputText, `Command exited with code ${exitCode}`));
+                    return {
+                        content: [{ type: "text", text: appendStatus(outputText, `Command exited with code ${exitCode}`) }],
+                        details,
+                        structuredContent,
+                        isError: true,
+                    };
                 }
-                return { content: [{ type: "text", text: outputText }], details };
+                return { content: [{ type: "text", text: outputText }], details, structuredContent };
             }
             finally {
                 clearUpdateTimer();

package/dist/core/tools/edit-diff.d.ts

@@ -60,11 +60,6 @@ export interface AppliedEditsResult {
  * Unicode quotes/dashes normalized to ASCII).
  */
 export declare function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult;
-/** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
-export declare function stripBom(content: string): {
-    bom: string;
-    text: string;
-};
 /**
  * Apply one or more exact-text replacements to LF-normalized content.
  *

package/dist/core/tools/edit-diff.js

@@ -4,6 +4,7 @@
 import * as Diff from "diff";
 import { constants } from "fs";
 import { access, readFile } from "fs/promises";
+import { splitBom } from "../../utils/text.js";
 import { resolveToCwd } from "./path-utils.js";
 export function detectLineEnding(content) {
     const crlfIdx = content.indexOf("\r\n");
@@ -173,10 +174,6 @@ export function fuzzyFindText(content, oldText) {
         contentForReplacement: fuzzyContent,
     };
 }
-/** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
-export function stripBom(content) {
-    return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
-}
 function countOccurrences(content, oldText) {
     const fuzzyContent = normalizeForFuzzyMatch(content);
     const fuzzyOldText = normalizeForFuzzyMatch(oldText);
@@ -404,7 +401,7 @@ export async function computeEditsDiff(path, edits, cwd) {
         // Read the file
         const rawContent = await readFile(absolutePath, "utf-8");
         // Strip BOM before matching (LLM won't include invisible BOM in oldText)
-        const { text: content } = stripBom(rawContent);
+        const { text: content } = splitBom(rawContent);
         const normalizedContent = normalizeToLF(content);
         const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
         // Generate the diff

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

@@ -9,6 +9,10 @@ declare const editSchema: Type.TObject<{
         newText: Type.TString;
     }>>;
 }>;
+export declare const editToolSystemPromptContribution: {
+    readonly snippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call";
+    readonly guidelines: readonly ["Use edit for precise changes (edits[].oldText must match exactly)", "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls", "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.", "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions."];
+};
 export type EditToolInput = Static<typeof editSchema>;
 export interface EditToolDetails {
     /** Display-oriented diff of the changes made */

package/dist/core/tools/edit.js

@@ -1,7 +1,8 @@
 import { constants } from "fs";
 import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
 import { Type } from "typebox";
-import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+import { splitBom } from "../../utils/text.js";
+import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, } from "./edit-diff.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
 import { editRenderers } from "./renderers/edit.js";
@@ -18,6 +19,22 @@ const editSchema = Type.Object({
         description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
     }),
 }, {});
+export const editToolSystemPromptContribution = {
+    snippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
+    guidelines: [
+        "Use edit for precise changes (edits[].oldText must match exactly)",
+        "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
+        "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+        "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
+    ],
+};
+function isSingleEditInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const edit = value;
+    return typeof edit.oldText === "string" && typeof edit.newText === "string";
+}
 const defaultEditOperations = {
     readFile: (path) => fsReadFile(path),
     writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
@@ -28,15 +45,23 @@ function prepareEditArguments(input) {
         return input;
     }
     const args = input;
-    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array
+    // Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array.
+    // Others send a single edit object instead of a one-element edits array.
     if (typeof args.edits === "string") {
         try {
             const parsed = JSON.parse(args.edits);
-            if (Array.isArray(parsed))
+            if (Array.isArray(parsed)) {
                 args.edits = parsed;
+            }
+            else if (isSingleEditInput(parsed)) {
+                args.edits = [parsed];
+            }
         }
         catch { }
     }
+    else if (isSingleEditInput(args.edits)) {
+        args.edits = [args.edits];
+    }
     const legacy = args;
     if (typeof legacy.oldText !== "string" || typeof legacy.newText !== "string") {
         return args;
@@ -58,13 +83,8 @@ export function createEditToolDefinition(cwd, options) {
         name: "edit",
         label: "edit",
         description: "Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
-        promptSnippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
-        promptGuidelines: [
-            "Use edit for precise changes (edits[].oldText must match exactly)",
-            "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
-            "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
-            "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
-        ],
+        promptSnippet: editToolSystemPromptContribution.snippet,
+        promptGuidelines: [...editToolSystemPromptContribution.guidelines],
         parameters: editSchema,
         constrainedSampling: { type: "json_schema", strict: "prefer" },
         renderShell: "self",
@@ -97,7 +117,7 @@ export function createEditToolDefinition(cwd, options) {
                 const rawContent = buffer.toString("utf-8");
                 throwIfAborted();
                 // Strip BOM before matching. The model will not include an invisible BOM in oldText.
-                const { bom, text: content } = stripBom(rawContent);
+                const { bom, text: content } = splitBom(rawContent);
                 const originalEnding = detectLineEnding(content);
                 const normalizedContent = normalizeToLF(content);
                 const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);

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

@@ -1,12 +1,19 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
+import path from "path";
 import { type Static, Type } from "typebox";
 import type { ToolDefinition } from "../extensions/types.ts";
 import { type TruncationResult } from "./truncate.ts";
+/** Relativize a find result against the search root and normalize it to posix separators. */
+export declare function relativizeFindResultPath(resultPath: string, searchPath: string, pathModule?: path.PlatformPath): string;
 declare const findSchema: Type.TObject<{
     pattern: Type.TString;
     path: Type.TOptional<Type.TString>;
     limit: Type.TOptional<Type.TNumber>;
 }>;
+export declare const findToolSystemPromptContribution: {
+    readonly snippet: "Find files by glob pattern (respects .gitignore)";
+    readonly guidelines: readonly [];
+};
 export type FindToolInput = Static<typeof findSchema>;
 export interface FindToolDetails {
     truncation?: TruncationResult;

package/dist/core/tools/find.js

@@ -7,8 +7,12 @@ import { pathExists, resolveToCwd } from "./path-utils.js";
 import { findRenderers } from "./renderers/find.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
-function toPosixPath(value) {
-    return value.split(path.sep).join("/");
+/** Relativize a find result against the search root and normalize it to posix separators. */
+export function relativizeFindResultPath(resultPath, searchPath, pathModule = path) {
+    const hadTrailingSeparator = resultPath.endsWith(pathModule.sep) || (pathModule.sep === "\\" && resultPath.endsWith("/"));
+    const relativePath = pathModule.isAbsolute(resultPath) ? pathModule.relative(searchPath, resultPath) : resultPath;
+    const posixPath = relativePath.split(pathModule.sep).join("/");
+    return hadTrailingSeparator && !posixPath.endsWith("/") ? `${posixPath}/` : posixPath;
 }
 const findSchema = Type.Object({
     pattern: Type.String({
@@ -17,6 +21,10 @@ const findSchema = Type.Object({
     path: Type.Optional(Type.String({ description: "Directory to search in (default: current directory)" })),
     limit: Type.Optional(Type.Number({ description: "Maximum number of results (default: 1000)" })),
 });
+export const findToolSystemPromptContribution = {
+    snippet: "Find files by glob pattern (respects .gitignore)",
+    guidelines: [],
+};
 const DEFAULT_LIMIT = 1000;
 const defaultFindOperations = {
     exists: pathExists,
@@ -29,7 +37,7 @@ export function createFindToolDefinition(cwd, options) {
         name: "find",
         label: "find",
         description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} results or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first).`,
-        promptSnippet: "Find files by glob pattern (respects .gitignore)",
+        promptSnippet: findToolSystemPromptContribution.snippet,
         parameters: findSchema,
         async execute(_toolCallId, { pattern, path: searchDir, limit }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {
@@ -83,11 +91,7 @@ export function createFindToolDefinition(cwd, options) {
                                 return;
                             }
                             // Relativize paths against the search root for stable output.
-                            const relativized = results.map((p) => {
-                                if (p.startsWith(searchPath))
-                                    return toPosixPath(p.slice(searchPath.length + 1));
-                                return toPosixPath(path.relative(searchPath, p));
-                            });
+                            const relativized = results.map((p) => relativizeFindResultPath(p, searchPath));
                             const resultLimitReached = relativized.length >= effectiveLimit;
                             const rawOutput = relativized.join("\n");
                             const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
@@ -149,6 +153,9 @@ export function createFindToolDefinition(cwd, options) {
                             if (!pattern.startsWith("/") && !pattern.startsWith("**/") && pattern !== "**") {
                                 effectivePattern = `**/${pattern}`;
                             }
+                            // fd matches full paths using native separators on Windows.
+                            if (process.platform === "win32")
+                                effectivePattern = effectivePattern.replaceAll("/", String.raw `[/\\]`);
                         }
                         args.push("--", effectivePattern, searchPath);
                         const child = spawn(fdPath, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -199,17 +206,7 @@ export function createFindToolDefinition(cwd, options) {
                                 const line = rawLine.replace(/\r$/, "").trim();
                                 if (!line)
                                     continue;
-                                const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
-                                let relativePath = line;
-                                if (line.startsWith(searchPath)) {
-                                    relativePath = line.slice(searchPath.length + 1);
-                                }
-                                else {
-                                    relativePath = path.relative(searchPath, line);
-                                }
-                                if (hadTrailingSlash && !relativePath.endsWith("/"))
-                                    relativePath += "/";
-                                relativized.push(toPosixPath(relativePath));
+                                relativized.push(relativizeFindResultPath(line, searchPath));
                             }
                             const resultLimitReached = relativized.length >= effectiveLimit;
                             const rawOutput = relativized.join("\n");

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

@@ -11,6 +11,10 @@ declare const grepSchema: Type.TObject<{
     context: Type.TOptional<Type.TNumber>;
     limit: Type.TOptional<Type.TNumber>;
 }>;
+export declare const grepToolSystemPromptContribution: {
+    readonly snippet: "Search file contents for patterns (respects .gitignore)";
+    readonly guidelines: readonly [];
+};
 export type GrepToolInput = Static<typeof grepSchema>;
 export interface GrepToolDetails {
     truncation?: TruncationResult;