@selesai/code 0.13.26 → 0.13.27

package/dist/core/system-prompt.js

@@ -1,6 +1,7 @@
 /**
  * System prompt construction and project context loading
  */
+import { getSystemMessageText } from "@earendil-works/pi-ai";
 import { getDocsPath, getExamplesPath, getReadmePath } from "../config.js";
 import { formatAgentsForPrompt } from "./agents.js";
 import { formatSkillsForPrompt } from "./skills.js";
@@ -10,120 +11,172 @@ import { formatSkillsForPrompt } from "./skills.js";
  * 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.";
-/** Build the system prompt with tools, guidelines, and context */
-export function buildSystemPrompt(options) {
-    const { customPrompt, selectedTools, toolSnippets, promptGuidelines, appendSystemPrompt, cwd, contextFiles: providedContextFiles, skills: providedSkills, } = options;
-    const promptCwd = cwd.replace(/\\/g, "/");
-    const appendSection = appendSystemPrompt ? `\n\n${appendSystemPrompt}` : "";
-    const contextFiles = providedContextFiles ?? [];
-    const skills = providedSkills ?? [];
-    const agents = options.agents ?? [];
-    const tools = selectedTools || ["read", "bash", "edit", "write"];
-    const hasRead = tools.includes("read");
-    const skillFileReadTool = ["read", "bash"].find((tool) => tools.includes(tool));
-    if (customPrompt) {
-        let prompt = customPrompt;
-        if (appendSection) {
-            prompt += appendSection;
-        }
-        // Append project context files
-        if (contextFiles.length > 0) {
-            prompt += "\n\n<project_context>\n\n";
-            prompt += "Project-specific instructions and guidelines:\n\n";
-            for (const { path: filePath, content } of contextFiles) {
-                prompt += `<project_instructions path="${filePath}">\n${content}\n</project_instructions>\n\n`;
-            }
-            prompt += "</project_context>\n";
-        }
-        // Append skills when a tool capable of reading their files is available.
-        if (skillFileReadTool && skills.length > 0) {
-            prompt += formatSkillsForPrompt(skills, skillFileReadTool);
+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) {
+    return {
+        customPrompt: input.customPrompt,
+        forceSystemPrompt: input.forceSystemPrompt,
+        selectedTools: [...(input.selectedTools ?? ["read", "bash", "edit", "write"])],
+        toolSnippets: { ...(input.toolSnippets ?? {}) },
+        toolGuidelines: Object.fromEntries(Object.entries(input.toolGuidelines ?? {}).map(([name, guidelines]) => [name, [...guidelines]])),
+        promptGuidelines: [...(input.promptGuidelines ?? [])],
+        appendSystemPrompt: input.appendSystemPrompt ?? "",
+        sections: { ...(input.sections ?? {}) },
+        cwd: input.cwd,
+        contextFiles: (input.contextFiles ?? []).map((file) => ({ ...file })),
+        skills: (input.skills ?? []).map((skill) => ({ ...skill })),
+        agents: (input.agents ?? []).map((agent) => ({ ...agent })),
+    };
+}
+function renderProjectContext(contextFiles) {
+    return [
+        "Project-specific instructions and guidelines:",
+        ...contextFiles.map(({ path, content }) => `<project_instructions path="${path}">\n${content}\n</project_instructions>`),
+    ].join("\n\n");
+}
+export function buildRules(selectedTools, toolGuidelines, promptGuidelines) {
+    const rules = [];
+    const seen = new Set();
+    const addRule = (rule) => {
+        const normalized = rule.trim();
+        if (!normalized || seen.has(normalized))
+            return;
+        seen.add(normalized);
+        rules.push(normalized);
+    };
+    const hasBash = selectedTools.includes("bash");
+    const hasPowerShell = selectedTools.includes("powershell");
+    const hasGrep = selectedTools.includes("grep");
+    const hasFind = selectedTools.includes("find");
+    const hasLs = selectedTools.includes("ls");
+    if ((hasBash || hasPowerShell) && !hasGrep && !hasFind && !hasLs) {
+        if (hasBash && hasPowerShell) {
+            addRule("Use bash or PowerShell for file operations like listing, searching, and finding files");
         }
-        if (hasRead && agents.length > 0) {
-            prompt += formatAgentsForPrompt(agents);
+        else if (hasPowerShell) {
+            addRule("Use PowerShell for file operations like listing, searching, and finding files");
         }
-        // Render active-tool guidelines (e.g., mandatory delegation contracts) in
-        // custom-prompt sessions too, without requiring the read tool. The caller's
-        // custom prompt text stays unchanged; a clearly delimited section is appended
-        // only when non-empty guidelines exist.
-        const activeGuidelines = (promptGuidelines ?? [])
-            .map((guideline) => guideline.trim())
-            .filter((guideline) => guideline.length > 0)
-            .filter((guideline, index, all) => all.indexOf(guideline) === index);
-        if (activeGuidelines.length > 0) {
-            prompt += `\n\nActive tool guidelines:\n${activeGuidelines.map((guideline) => `- ${guideline}`).join("\n")}`;
+        else {
+            addRule("Use bash for file operations like ls, rg, find");
         }
-        prompt += `\nCurrent working directory: ${promptCwd}\n`;
-        return prompt;
     }
-    // Get absolute paths to documentation and examples
+    for (const name of selectedTools) {
+        for (const rule of toolGuidelines[name] ?? [])
+            addRule(rule);
+    }
+    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");
+}
+/** Selesai fork: the fork names itself rather than upstream, and keeps its own docs pointers. */
+function buildForkPreamble() {
+    return "You are an expert coding assistant operating inside SelesaiCode fork of Pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.";
+}
+function buildForkDocsSection() {
     const readmePath = getReadmePath();
     const docsPath = getDocsPath();
     const examplesPath = getExamplesPath();
-    // Build tools list based on selected tools.
-    // A tool appears in Available tools only when the caller provides a one-line snippet.
-    const visibleTools = tools.filter((name) => !!toolSnippets?.[name]);
-    const toolsList = visibleTools.length > 0 ? visibleTools.map((name) => `- ${name}: ${toolSnippets[name]}`).join("\n") : "(none)";
-    // Build guidelines based on which tools are actually available
-    const guidelinesList = [];
-    const guidelinesSet = new Set();
-    const addGuideline = (guideline) => {
-        if (guidelinesSet.has(guideline)) {
-            return;
-        }
-        guidelinesSet.add(guideline);
-        guidelinesList.push(guideline);
-    };
-    const hasBash = tools.includes("bash");
-    const hasGrep = tools.includes("grep");
-    const hasFind = tools.includes("find");
-    const hasLs = tools.includes("ls");
-    // File exploration guidelines
-    if (hasBash && !hasGrep && !hasFind && !hasLs) {
-        addGuideline("Use bash for file operations like ls, rg, find");
-    }
-    for (const guideline of promptGuidelines ?? []) {
-        const normalized = guideline.trim();
-        if (normalized.length > 0) {
-            addGuideline(normalized);
+    return `Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI): main docs ${readmePath}, additional docs ${docsPath}, examples ${examplesPath}.
+When working on pi topics, resolve docs/... and examples/... under those paths (not cwd), read the relevant .md files completely, and follow cross-references before implementing.`;
+}
+/**
+ * Active-tool guidelines for a custom-prompt session: the caller's custom prompt text stays
+ * unchanged and a clearly delimited section is appended only when non-empty guidelines exist.
+ */
+function buildActiveToolGuidelines(promptGuidelines) {
+    const activeGuidelines = promptGuidelines
+        .map((guideline) => guideline.trim())
+        .filter((guideline) => guideline.length > 0)
+        .filter((guideline, index, all) => all.indexOf(guideline) === index);
+    if (activeGuidelines.length === 0)
+        return undefined;
+    return `Active tool guidelines:\n${activeGuidelines.map((guideline) => `- ${guideline}`).join("\n")}`;
+}
+/** 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;
+    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}`);
         }
     }
-    // Always include these
-    addGuideline(DELEGATION_ROUTING_GUIDELINE);
-    addGuideline("Be concise in your responses");
-    addGuideline("Show file paths clearly when working with files");
-    const guidelines = guidelinesList.map((g) => `- ${g}`).join("\n");
-    let prompt = `You are an expert coding assistant operating inside SelesaiCode fork of Pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
-
-Available tools:
-${toolsList}
-
-In addition to the tools above, you may have access to other custom tools depending on the project.
-
-Guidelines:
-${guidelines}
-
-Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI): main docs ${readmePath}, additional docs ${docsPath}, examples ${examplesPath}.
-When working on pi topics, resolve docs/... and examples/... under those paths (not cwd), read the relevant .md files completely, and follow cross-references before implementing.`;
-    if (appendSection) {
-        prompt += appendSection;
+    const promptSections = {};
+    if (customPrompt) {
+        promptSections.preamble = customPrompt;
+        // Selesai fork: custom-prompt sessions still render active-tool guidelines.
+        const activeGuidelines = buildActiveToolGuidelines(promptGuidelines);
+        if (activeGuidelines)
+            promptSections.active_tool_guidelines = activeGuidelines;
     }
-    // Append project context files
-    if (contextFiles.length > 0) {
-        prompt += "\n\n<project_context>\n\n";
-        prompt += "Project-specific instructions and guidelines:\n\n";
-        for (const { path: filePath, content } of contextFiles) {
-            prompt += `<project_instructions path="${filePath}">\n${content}\n</project_instructions>\n\n`;
-        }
-        prompt += "</project_context>\n";
+    else {
+        promptSections.preamble = buildForkPreamble();
+        const visibleTools = selectedTools.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.docs = buildForkDocsSection();
     }
-    // Append skills when a tool capable of reading their files is available.
+    if (appendSystemPrompt)
+        promptSections.addendum = appendSystemPrompt;
+    if (contextFiles.length > 0)
+        promptSections.project_context = renderProjectContext(contextFiles);
+    const skillFileReadTool = ["read", "bash"].find((tool) => selectedTools.includes(tool));
     if (skillFileReadTool && skills.length > 0) {
-        prompt += formatSkillsForPrompt(skills, skillFileReadTool);
+        const skillsPrompt = formatSkillsForPrompt(skills, skillFileReadTool).trim();
+        if (skillsPrompt)
+            promptSections.skills = skillsPrompt;
+    }
+    // Selesai fork: the available-agents section belongs to the fork's delegation story.
+    if (selectedTools.includes("read") && agents.length > 0) {
+        const agentsPrompt = formatAgentsForPrompt(agents).trim();
+        if (agentsPrompt)
+            promptSections.agents = agentsPrompt;
+    }
+    promptSections.cwd = cwd.replace(/\\/g, "/");
+    for (const [name, content] of Object.entries(customSections)) {
+        if (content)
+            promptSections[name] = content;
+    }
+    const sections = { preamble: promptSections.preamble };
+    for (const [name, content] of Object.entries(promptSections)) {
+        if (name !== "preamble")
+            sections[name] = `<${name}>\n${content}\n</${name}>`;
+    }
+    return sections;
+}
+/**
+ * The complete prompt state for `input`. A forced prompt is opaque and lives in `content`
+ * with no sections; otherwise `content` is empty and the structured sections carry the prompt.
+ */
+export function buildSystemPromptState(input) {
+    if (input.forceSystemPrompt !== undefined)
+        return { content: input.forceSystemPrompt };
+    return { content: "", sections: buildSystemPromptSections(input) };
+}
+/** Build the system prompt text, rendered exactly as the transcript's system message replays it. */
+export function buildSystemPrompt(input) {
+    return getSystemMessageText({ role: "system", ...buildSystemPromptState(input), timestamp: 0 });
+}
+/**
+ * Diff the sections the model currently has (replayed from the transcript, so never null)
+ * against the desired ones. Returns a `SystemMessage.sections` patch, or undefined when
+ * nothing changed.
+ */
+export function diffSystemPromptSections(previous, current) {
+    const patch = {};
+    for (const [name, text] of Object.entries(current)) {
+        if (previous[name] !== text)
+            patch[name] = text;
     }
-    if (hasRead && agents.length > 0) {
-        prompt += formatAgentsForPrompt(agents);
+    for (const name of Object.keys(previous)) {
+        if (current[name] === undefined)
+            patch[name] = null;
     }
-    prompt += `\nCurrent working directory: ${promptCwd}`;
-    return prompt;
+    return Object.keys(patch).length > 0 ? patch : undefined;
 }

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

@@ -1,5 +1,21 @@
 import { describe, expect, it } from "vitest";
-import { buildSystemPrompt } from "./system-prompt.js";
+import { buildSystemPrompt, buildSystemPromptSections, buildSystemPromptState } from "./system-prompt.js";
+const skill = {
+    name: "test-skill",
+    description: "Test skill description",
+    filePath: "/tmp/skills/test-skill/SKILL.md",
+    baseDir: "/tmp/skills/test-skill",
+    sourceInfo: { type: "file", path: "/tmp/skills/test-skill/SKILL.md" },
+    disableModelInvocation: false,
+};
+const agent = {
+    name: "test-agent",
+    description: "Test agent description",
+    filePath: "/tmp/agents/test-agent.md",
+    baseDir: "/tmp/agents",
+    sourceInfo: { type: "file", path: "/tmp/agents/test-agent.md" },
+    frontmatter: {},
+};
 describe("buildSystemPrompt", () => {
     it("includes the generic delegation-routing threshold in the default prompt", () => {
         const prompt = buildSystemPrompt({ cwd: "/tmp/project" });
@@ -9,8 +25,9 @@ describe("buildSystemPrompt", () => {
         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).toMatch(/Guidelines:/);
-        expect(prompt).toContain("Current working directory: /tmp/project");
+        expect(prompt).toContain("<rules>");
+        expect(prompt).toContain("- Be concise in your responses");
+        expect(prompt).toContain("<cwd>\n/tmp/project\n</cwd>");
     });
     it("keeps the collapsed Pi-docs block without the per-topic filename map", () => {
         const prompt = buildSystemPrompt({ cwd: "/tmp/project" });
@@ -19,31 +36,23 @@ describe("buildSystemPrompt", () => {
         expect(prompt).not.toContain("(docs/extensions.md");
     });
     it("keeps the default tool snippets, skills, and agents XML read-gated", () => {
-        const skill = {
-            name: "test-skill",
-            description: "Test skill description",
-            filePath: "/tmp/skills/test-skill/SKILL.md",
-            baseDir: "/tmp/skills/test-skill",
-            sourceInfo: { type: "file", path: "/tmp/skills/test-skill/SKILL.md" },
-            disableModelInvocation: false,
-        };
-        const agent = {
-            name: "test-agent",
-            description: "Test agent description",
-            filePath: "/tmp/agents/test-agent.md",
-            baseDir: "/tmp/agents",
-            sourceInfo: { type: "file", path: "/tmp/agents/test-agent.md" },
-            frontmatter: {},
-        };
         const withoutRead = buildSystemPrompt({
             cwd: "/tmp/project",
-            selectedTools: ["bash"],
+            selectedTools: ["edit"],
             skills: [skill],
             agents: [agent],
         });
         expect(withoutRead).not.toContain("<available_skills>");
         expect(withoutRead).not.toContain("<available_agents>");
-        expect(withoutRead).toContain("Current working directory: /tmp/project");
+        expect(withoutRead).toContain("<cwd>\n/tmp/project\n</cwd>");
+        const withBash = buildSystemPrompt({
+            cwd: "/tmp/project",
+            selectedTools: ["bash"],
+            skills: [skill],
+            agents: [agent],
+        });
+        expect(withBash).toContain("<available_skills>");
+        expect(withBash).not.toContain("<available_agents>");
         const withRead = buildSystemPrompt({
             cwd: "/tmp/project",
             selectedTools: ["read", "bash"],
@@ -64,7 +73,7 @@ describe("buildSystemPrompt", () => {
         expect(prompt).toContain("You are my custom assistant.");
         expect(prompt).toContain("Active tool guidelines:");
         expect(prompt).toContain('- Before executing, call { action: "list" }.');
-        expect(prompt).toContain("Current working directory: /tmp/project");
+        expect(prompt).toContain("<cwd>\n/tmp/project\n</cwd>");
     });
     it("deduplicates and trims active promptGuidelines in custom prompts", () => {
         const prompt = buildSystemPrompt({
@@ -79,7 +88,7 @@ describe("buildSystemPrompt", () => {
         const prompt = buildSystemPrompt({ cwd: "/tmp/project", customPrompt: "Custom text." });
         expect(prompt).toContain("Custom text.");
         expect(prompt).not.toContain("Active tool guidelines:");
-        expect(prompt).toContain("Current working directory: /tmp/project");
+        expect(prompt).toContain("<cwd>\n/tmp/project\n</cwd>");
     });
     it("renders active promptGuidelines in custom prompts without requiring read", () => {
         const prompt = buildSystemPrompt({
@@ -92,3 +101,32 @@ describe("buildSystemPrompt", () => {
         expect(prompt).not.toContain("<available_agents>");
     });
 });
+describe("system prompt sections", () => {
+    it("tags every non-preamble section with its own name so a later update can address it", () => {
+        const sections = buildSystemPromptSections({
+            cwd: "/tmp/project",
+            selectedTools: ["read", "bash"],
+            skills: [skill],
+        });
+        expect(sections.preamble).toContain("SelesaiCode fork of Pi");
+        expect(sections.preamble.startsWith("<")).toBe(false);
+        for (const [name, content] of Object.entries(sections)) {
+            if (name === "preamble")
+                continue;
+            expect(content).toBe(`<${name}>\n${content.slice(name.length + 3, -1 * (name.length + 4))}\n</${name}>`);
+        }
+        expect(Object.keys(sections)).toContain("tools");
+        expect(Object.keys(sections)).toContain("rules");
+        expect(Object.keys(sections)).toContain("docs");
+        expect(Object.keys(sections)).toContain("skills");
+        expect(Object.keys(sections)).toContain("cwd");
+    });
+    it("carries a forced prompt as opaque content with no sections", () => {
+        expect(buildSystemPromptState({ forceSystemPrompt: "exact", cwd: "/tmp" })).toEqual({ content: "exact" });
+        expect(buildSystemPrompt({ forceSystemPrompt: "exact", cwd: "/tmp" })).toBe("exact");
+    });
+    it("rejects an invalid section name rather than producing a malformed prompt", () => {
+        expect(() => buildSystemPromptSections({ cwd: "/tmp", sections: { "Bad Name": "x" } })).toThrow(/Invalid system prompt section name/);
+        expect(() => buildSystemPromptSections({ cwd: "/tmp", sections: { preamble: "x" } })).toThrow(/Invalid system prompt section name/);
+    });
+});

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

@@ -26,7 +26,8 @@ export interface BashOperations {
      * @param command The command to execute
      * @param cwd Working directory
      * @param options Execution options
-     * @returns Promise resolving to exit code (null if killed)
+     * @returns Promise resolving to the exit code. Report signal terminations as 128 + signal number;
+     * a null exit code is treated as a failed command.
      */
     exec: (command: string, cwd: string, options: {
         onData: (data: Buffer) => void;

package/dist/core/tools/bash.js

@@ -1,10 +1,10 @@
 import { constants } from "node:fs";
 import { access as fsAccess } from "node:fs/promises";
+import { constants as osConstants } from "node:os";
 import { spawn } from "child_process";
 import { Type } from "typebox";
 import { waitForChildProcess } from "../../utils/child-process.js";
 import { getShellConfig, getShellEnv, killProcessTree, trackDetachedChildPid, untrackDetachedChildPid, } from "../../utils/shell.js";
-import { getExperimentalToolSampling } from "../experimental.js";
 import { OutputAccumulator } from "./output-accumulator.js";
 import { BASH_UPDATE_THROTTLE_MS, createShellRenderers } from "./renderers/bash.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
@@ -94,7 +94,10 @@ export function createLocalShellOperations(shellName, resolveShellConfig) {
                 if (timedOut) {
                     throw new Error(`timeout:${timeout}`);
                 }
-                return { exitCode };
+                // A signal-killed shell has no exit code. Use the standard shell convention so
+                // callers do not mistake the termination for a successful command.
+                const signalCode = child.signalCode;
+                return { exitCode: exitCode ?? (signalCode ? 128 + (osConstants.signals[signalCode] ?? 0) : 1) };
             }
             finally {
                 if (child.pid)
@@ -151,7 +154,7 @@ export function createShellToolDefinition(cwd, config, options) {
         promptSnippet: config.promptSnippet,
         promptGuidelines: exposeSessionEnvironment && config.promptGuidelines ? [...config.promptGuidelines] : undefined,
         parameters: bashSchema,
-        constrainedSampling: getExperimentalToolSampling(),
+        constrainedSampling: { type: "json_schema", strict: "prefer" },
         async execute(_toolCallId, { command, timeout }, signal, onUpdate, ctx) {
             const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
             const spawnContext = resolveSpawnContext(resolvedCommand, ctx?.cwd || cwd, spawnHook, exposeSessionEnvironment, ctx);
@@ -260,7 +263,10 @@ export function createShellToolDefinition(cwd, config, options) {
                 }
                 const snapshot = await finishOutput();
                 const { text: outputText, details } = formatOutput(snapshot);
-                if (exitCode !== 0 && exitCode !== null) {
+                if (exitCode === null) {
+                    throw new Error(appendStatus(outputText, "Command terminated without an exit code"));
+                }
+                if (exitCode !== 0) {
                     throw new Error(appendStatus(outputText, `Command exited with code ${exitCode}`));
                 }
                 return { content: [{ type: "text", text: outputText }], details };

package/dist/core/tools/edit.js

@@ -1,7 +1,6 @@
 import { constants } from "fs";
 import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
 import { Type } from "typebox";
-import { getExperimentalToolSampling } from "../experimental.js";
 import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
@@ -67,7 +66,7 @@ export function createEditToolDefinition(cwd, options) {
             "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
         ],
         parameters: editSchema,
-        constrainedSampling: getExperimentalToolSampling(),
+        constrainedSampling: { type: "json_schema", strict: "prefer" },
         renderShell: "self",
         prepareArguments: prepareEditArguments,
         async execute(_toolCallId, input, signal, _onUpdate, ctx) {

package/dist/core/tools/read.js

@@ -3,7 +3,6 @@ import { access as fsAccess, readFile as fsReadFile } from "fs/promises";
 import { Type } from "typebox";
 import { processImage } from "../../utils/image-process.js";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
-import { getExperimentalToolSampling } from "../experimental.js";
 import { captionImageWithModel } from "../vision-caption.js";
 import { resolveReadPathAsync } from "./path-utils.js";
 import { readRenderers } from "./renderers/read.js";
@@ -70,7 +69,7 @@ export function createReadToolDefinition(cwd, options) {
         promptSnippet: readToolSystemPromptContribution.snippet,
         promptGuidelines: [...readToolSystemPromptContribution.guidelines],
         parameters: readSchema,
-        constrainedSampling: getExperimentalToolSampling(),
+        constrainedSampling: { type: "json_schema", strict: "prefer" },
         async execute(_toolCallId, { path, offset, limit }, signal, _onUpdate, ctx) {
             return new Promise((resolve, reject) => {
                 if (signal?.aborted) {

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

@@ -21,7 +21,15 @@ class BashResultRenderComponent extends Container {
     };
 }
 function formatDuration(ms) {
-    return `${(ms / 1000).toFixed(1)}s`;
+    const seconds = ms / 1000;
+    if (seconds < 60)
+        return `${seconds.toFixed(1)}s`;
+    const totalSeconds = Math.floor(seconds);
+    const minutes = Math.floor(totalSeconds / 60);
+    const remainder = totalSeconds % 60;
+    if (minutes < 60)
+        return `${minutes}m ${remainder}s`;
+    return `${Math.floor(minutes / 60)}h ${minutes % 60}m ${remainder}s`;
 }
 function formatShellCall(args, prompt) {
     const command = str(args?.command);

package/dist/core/tools/write.js

@@ -1,7 +1,6 @@
 import { mkdir as fsMkdir, writeFile as fsWriteFile } from "fs/promises";
 import { dirname } from "path";
 import { Type } from "typebox";
-import { getExperimentalToolSampling } from "../experimental.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
 import { writeRenderers } from "./renderers/write.js";
@@ -23,7 +22,7 @@ export function createWriteToolDefinition(cwd, options) {
         promptSnippet: "Create or overwrite files",
         promptGuidelines: ["Use write only for new files or complete rewrites."],
         parameters: writeSchema,
-        constrainedSampling: getExperimentalToolSampling(),
+        constrainedSampling: { type: "json_schema", strict: "prefer" },
         async execute(_toolCallId, { path, content }, signal, _onUpdate, ctx) {
             const absolutePath = resolveToCwd(path, ctx?.cwd || cwd);
             const dir = dirname(absolutePath);

package/dist/core/usage-totals.d.ts

@@ -16,5 +16,5 @@ export interface UsageCostBreakdownEntry {
     cost: number;
     tokens: number;
 }
-/** Group attributable assistant usage by model and all other usage into a separate bucket. */
+/** Group model-attributed usage by model and all other usage into a separate bucket. */
 export declare function getUsageCostBreakdown(entries: SessionEntry[]): UsageCostBreakdownEntry[];

package/dist/core/usage-totals.js

@@ -24,7 +24,7 @@ export function addUsageToTotals(totals, usage) {
     totals.cacheWrite += usage.cacheWrite;
     totals.cost += usage.cost.total;
 }
-/** Group attributable assistant usage by model and all other usage into a separate bucket. */
+/** Group model-attributed usage by model and all other usage into a separate bucket. */
 export function getUsageCostBreakdown(entries) {
     const totalsByKey = new Map();
     for (const entry of entries) {
@@ -34,6 +34,10 @@ export function getUsageCostBreakdown(entries) {
             key = `${entry.message.provider}/${entry.message.responseModel ?? entry.message.model}`;
             usage = entry.message.usage;
         }
+        else if (entry.type === "usage") {
+            key = `${entry.provider}/${entry.model}`;
+            usage = entry.usage;
+        }
         else if (entry.type === "message" && entry.message.role === "toolResult" && entry.message.usage) {
             key = "Tools/summaries";
             usage = entry.message.usage;

package/dist/extensions/pi-web-agent/src/backends/factory.ts

@@ -213,13 +213,21 @@ export function createBackendSet(
     });
   }
 
-  // Keep the keyless Tavily safety net for the no-key DuckDuckGo default, even under fanout —
-  // it wraps whatever search ended up being (plain DDG or the fanout set) so a total failure
-  // still has somewhere to go. Opt out with PI_WEB_AGENT_DISABLE_KEYLESS_FALLBACK=1.
+  // The keyless Tavily safety net, kept even under fanout — it wraps whatever search ended up
+  // being so a total failure still has somewhere to go. It used to arm only for the bare
+  // no-account DuckDuckGo default, which skipped every hosted provider configured with
+  // `fallback: duckduckgo`: when that fallback then hit a DNS-blocked or bot-walled DuckDuckGo
+  // the whole search died even though keyless Tavily was sitting right there. Arm it whenever
+  // DuckDuckGo is reachable in the chain. Opt out with PI_WEB_AGENT_DISABLE_KEYLESS_FALLBACK=1.
   const keylessFallbackDisabled = process.env.PI_WEB_AGENT_DISABLE_KEYLESS_FALLBACK === '1';
-  const usingDuckDuckGoDefault =
-    config.search.provider === 'duckduckgo' || !config.search.provider;
-  if (usingDuckDuckGoDefault && !keylessFallbackDisabled) {
+  // Fanout with no explicit provider list means "all usable", which always includes DuckDuckGo.
+  const fanoutActive = config.search.fanout?.mode !== undefined && config.search.fanout.mode !== 'off';
+  const duckDuckGoInChain =
+    !config.search.provider ||
+    config.search.provider === 'duckduckgo' ||
+    config.search.fallback === 'duckduckgo' ||
+    (fanoutActive && (config.search.fanout?.providers?.includes('duckduckgo') ?? true));
+  if (duckDuckGoInChain && !keylessFallbackDisabled) {
     search = withSearchFallback(search, createTavilySearch({ keyless: true }), 'duckduckgo');
   }
 

package/dist/extensions/pi-web-agent/src/extension.ts

@@ -23,7 +23,9 @@ function serializeForModel(result: WebExploreResponse): string {
     return `Research failed: ${result.error?.message ?? 'Unknown research failure.'}`;
   }
   if (result.findings.length === 0 && result.sources.length === 0) {
-    return 'No usable evidence found.';
+    return result.metadata?.failureReason
+      ? `No usable evidence found: ${result.metadata.failureReason}`
+      : 'No usable evidence found.';
   }
   return [
     result.findings.join('\n\n'),