@selesai/code 0.13.39 → 0.14.0

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/subagent-rpc.d.ts

@@ -0,0 +1,110 @@
+/** Read-only stdio observability DTOs. No extension runtime or filesystem dependencies. */
+export declare const SUBAGENT_OBSERVE_EVENT = "subagent:observe:v1";
+export declare const SUBAGENT_RPC_MAX_BYTES = 65536;
+export interface RpcObservationScope {
+    version: 1;
+    sessionId: string | null;
+    epoch: string;
+}
+export type SubagentRpcCommand = {
+    type: "subagent_status";
+    id?: string;
+    version: 1;
+};
+export interface SubagentRpcTokens {
+    input: number;
+    output: number;
+    total: number;
+    window?: number;
+    windowPeak?: number;
+}
+export interface SubagentRpcFleet {
+    version: 1;
+    entries: Array<{
+        key: string;
+        agent: string;
+        role?: string;
+        model?: string;
+        effort?: string;
+        startedAt: number;
+        tokens: SubagentRpcTokens;
+        goal?: string;
+    }>;
+    totalActive: number;
+    topLevelAsyncCapacity: {
+        used: number;
+        limit: number;
+    };
+    omitted: number;
+}
+export type SubagentRpcLifecycle = "queued" | "pending" | "running" | "complete" | "completed" | "failed" | "partial" | "paused" | "stopped" | "rejected" | "detached";
+export interface SubagentRpcNode {
+    key: string;
+    runId?: string;
+    workflowId?: string;
+    agent?: string;
+    status: SubagentRpcLifecycle;
+    activity?: "waiting_supervisor" | "needs_attention";
+    startedAt?: number;
+    updatedAt?: number;
+    endedAt?: number;
+    progress?: string;
+    currentTool?: string;
+    tokens?: SubagentRpcTokens;
+    error?: string;
+    reason?: string;
+    /** Only explicit runtime execution projections; lifecycle is not a task verdict. */
+    outcome?: {
+        status: SubagentRpcLifecycle;
+        success?: boolean;
+        exitCode?: number;
+    };
+    /** Independent point-in-time runner proof, never inferred from outcome. */
+    processTerminal?: {
+        state: "pending" | "observed" | "unknown" | "not-started";
+        observedAt?: number;
+        reason?: string;
+    };
+    children: SubagentRpcNode[];
+    omittedChildren: number;
+}
+export interface SubagentRpcProjection {
+    fleet: SubagentRpcFleet;
+    runs: SubagentRpcNode[];
+    omitted: {
+        runs: number;
+        children: number;
+    };
+}
+export interface SubagentRpcSnapshot extends RpcObservationScope, SubagentRpcProjection {
+    available: boolean;
+    capabilities: {
+        snapshot: true;
+        events: boolean;
+    };
+    revision: number;
+}
+export interface SubagentRpcEvent extends RpcObservationScope {
+    type: "subagent_event";
+    revision: number;
+    snapshot: SubagentRpcSnapshot;
+}
+export type SubagentRpcResponse = {
+    id?: string;
+    type: "response";
+    command: "subagent_status";
+    success: true;
+    data: SubagentRpcSnapshot;
+};
+/** Synchronous, dedicated internal registration. Only native projections, never generic bus invocation. */
+export interface SubagentObserveRequest {
+    version: 1;
+    sessionId: string;
+    accept(source: SubagentObservationSource): void;
+}
+export interface SubagentObservationSource {
+    snapshot(): SubagentRpcProjection;
+    subscribe(listener: (projection: SubagentRpcProjection | null) => void): () => void;
+}
+/** Reject malformed or oversized trusted-extension payloads before JSONL publication. */
+export declare function isSubagentRpcProjection(v: unknown): v is SubagentRpcProjection;

package/dist/core/subagent-rpc.js

@@ -0,0 +1,60 @@
+/** Read-only stdio observability DTOs. No extension runtime or filesystem dependencies. */
+export const SUBAGENT_OBSERVE_EVENT = "subagent:observe:v1";
+export const SUBAGENT_RPC_MAX_BYTES = 65_536;
+const statuses = new Set(["queued", "pending", "running", "complete", "completed", "failed", "partial", "paused", "stopped", "rejected", "detached"]);
+const record = (v) => Boolean(v && typeof v === "object" && !Array.isArray(v));
+const count = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+const text = (v, max) => typeof v === "string" && v.length > 0 && v.length <= max;
+const optionalText = (v, max) => v === undefined || text(v, max);
+const identity = (v) => text(v, 128) && !/[\\/\r\n]/.test(v);
+const onlyKeys = (v, keys) => Object.keys(v).every(key => keys.includes(key));
+function tokens(v) {
+    return record(v) && onlyKeys(v, ["input", "output", "total", "window", "windowPeak"]) && [v.input, v.output, v.total].every(count) && [v.window, v.windowPeak].every(n => n === undefined || count(n));
+}
+/** Reject malformed or oversized trusted-extension payloads before JSONL publication. */
+export function isSubagentRpcProjection(v) {
+    if (!record(v) || !onlyKeys(v, ["fleet", "runs", "omitted"]) || !record(v.fleet) || !record(v.omitted) || !Array.isArray(v.runs) || v.runs.length > 32)
+        return false;
+    const fleet = v.fleet;
+    if (!onlyKeys(fleet, ["version", "entries", "totalActive", "topLevelAsyncCapacity", "omitted"]) || !onlyKeys(v.omitted, ["runs", "children"])
+        || fleet.version !== 1 || !Array.isArray(fleet.entries) || fleet.entries.length > 16 || !count(fleet.totalActive) || !count(fleet.omitted)
+        || fleet.totalActive !== fleet.entries.length + fleet.omitted || !record(fleet.topLevelAsyncCapacity)
+        || !onlyKeys(fleet.topLevelAsyncCapacity, ["used", "limit"]) || !count(fleet.topLevelAsyncCapacity.used) || !count(fleet.topLevelAsyncCapacity.limit) || !count(v.omitted.runs) || !count(v.omitted.children))
+        return false;
+    if (!fleet.entries.every(e => record(e) && onlyKeys(e, ["key", "agent", "role", "model", "effort", "startedAt", "tokens", "goal"]) && identity(e.key) && text(e.agent, 96) && count(e.startedAt) && tokens(e.tokens)
+        && optionalText(e.role, 96) && optionalText(e.model, 128) && optionalText(e.effort, 128) && optionalText(e.goal, 512)))
+        return false;
+    let nodes = 0;
+    let omittedChildren = 0;
+    const keys = new Set();
+    function node(n, depth) {
+        if (!record(n) || !onlyKeys(n, ["key", "runId", "workflowId", "agent", "status", "activity", "startedAt", "updatedAt", "endedAt", "progress", "currentTool", "tokens", "error", "reason", "outcome", "processTerminal", "children", "omittedChildren"]) || depth > 4 || ++nodes > 64 || !identity(n.key) || keys.has(n.key) || !statuses.has(n.status)
+            || !Array.isArray(n.children) || n.children.length > 16 || !count(n.omittedChildren))
+            return false;
+        keys.add(n.key);
+        omittedChildren += n.omittedChildren;
+        if ([n.runId, n.workflowId].some(id => id !== undefined && !identity(id))
+            || !optionalText(n.agent, 96) || !optionalText(n.progress, 256) || !optionalText(n.currentTool, 96)
+            || !optionalText(n.error, 256) || !optionalText(n.reason, 128)
+            || [n.startedAt, n.updatedAt, n.endedAt].some(t => t !== undefined && !count(t))
+            || n.activity !== undefined && n.activity !== "waiting_supervisor" && n.activity !== "needs_attention"
+            || n.tokens !== undefined && !tokens(n.tokens))
+            return false;
+        if (n.outcome !== undefined && (!record(n.outcome) || !onlyKeys(n.outcome, ["status", "success", "exitCode"]) || !statuses.has(n.outcome.status)
+            || n.outcome.success !== undefined && typeof n.outcome.success !== "boolean"
+            || n.outcome.exitCode !== undefined && (typeof n.outcome.exitCode !== "number" || !Number.isSafeInteger(n.outcome.exitCode))))
+            return false;
+        if (n.processTerminal !== undefined && (!record(n.processTerminal) || !onlyKeys(n.processTerminal, ["state", "observedAt", "reason"]) || !["pending", "observed", "unknown", "not-started"].includes(n.processTerminal.state)
+            || !optionalText(n.processTerminal.reason, 128) || n.processTerminal.observedAt !== undefined && !count(n.processTerminal.observedAt)))
+            return false;
+        return n.children.every(child => node(child, depth + 1));
+    }
+    if (!v.runs.every(n => node(n, 0)) || omittedChildren !== v.omitted.children)
+        return false;
+    try {
+        return Buffer.byteLength(JSON.stringify(v), "utf8") <= SUBAGENT_RPC_MAX_BYTES - 1024;
+    }
+    catch {
+        return false;
+    }
+}

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 */