@selesai/code 0.9.9 → 0.9.11

package/dist/core/extensions/loader.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "vitest";
+import { createEventBus } from "../event-bus.js";
+import { createExtensionRuntime, loadExtensionFromFactory } from "./loader.js";
+describe("extension factory failure", () => {
+    test("discards pending provider and flag state and disables the failed API", async () => {
+        const runtime = createExtensionRuntime();
+        let capturedApi;
+        let calls = 0;
+        await expect(loadExtensionFromFactory((pi) => {
+            capturedApi = pi;
+            pi.events.on("failed-load", () => calls++);
+            pi.registerFlag("failed-flag", { type: "boolean", default: true });
+            pi.registerProvider("failed-provider", { baseUrl: "https://provider.test", apiKey: "key" });
+            throw new Error("factory failed");
+        }, process.cwd(), createEventBus(), runtime, "<failing>")).rejects.toThrow("factory failed");
+        expect(runtime.flagValues.has("failed-flag")).toBe(false);
+        expect(runtime.pendingProviderRegistrations).toEqual([]);
+        expect(calls).toBe(0);
+        expect(() => capturedApi?.registerFlag("late", { type: "boolean", default: true })).toThrow('Extension "<failing>" failed to load and its API is no longer active.');
+    });
+});

package/dist/core/extensions/types.d.ts

@@ -454,7 +454,7 @@ export interface SessionBeforeCompactEvent {
     willRetry: boolean;
     signal: AbortSignal;
 }
-/** Fired after context compaction */
+/** Fired after context compaction succeeds */
 export interface SessionCompactEvent {
     type: "session_compact";
     compactionEntry: CompactionEntry;
@@ -464,6 +464,15 @@ export interface SessionCompactEvent {
     /** True when the aborted turn is retried after this compaction (overflow recovery) */
     willRetry: boolean;
 }
+/** Fired after context compaction fails or is aborted. */
+export interface SessionCompactFailedEvent {
+    type: "session_compact_failed";
+    reason: "manual" | "threshold" | "overflow";
+    errorMessage?: string;
+    aborted: boolean;
+    willRetry: boolean;
+    fromExtension: boolean;
+}
 /** Fired when the session display name changes (e.g. via /name). */
 export interface SessionInfoChangedEvent {
     type: "session_info_changed";
@@ -505,7 +514,7 @@ export interface SessionTreeEvent {
     summaryEntry?: BranchSummaryEntry;
     fromExtension?: boolean;
 }
-export type SessionEvent = SessionStartEvent | SessionInfoChangedEvent | SessionBeforeSwitchEvent | SessionBeforeForkEvent | SessionBeforeCompactEvent | SessionCompactEvent | SessionShutdownEvent | SessionBeforeTreeEvent | SessionTreeEvent | SessionInfoChangedEvent;
+export type SessionEvent = SessionStartEvent | SessionInfoChangedEvent | SessionBeforeSwitchEvent | SessionBeforeForkEvent | SessionBeforeCompactEvent | SessionCompactEvent | SessionCompactFailedEvent | SessionShutdownEvent | SessionBeforeTreeEvent | SessionTreeEvent | SessionInfoChangedEvent;
 /** Fired before each LLM call. Can modify messages. */
 export interface ContextEvent {
     type: "context";
@@ -874,6 +883,7 @@ export interface ExtensionAPI {
     on(event: "session_before_fork", handler: ExtensionHandler<SessionBeforeForkEvent, SessionBeforeForkResult>): void;
     on(event: "session_before_compact", handler: ExtensionHandler<SessionBeforeCompactEvent, SessionBeforeCompactResult>): void;
     on(event: "session_compact", handler: ExtensionHandler<SessionCompactEvent>): void;
+    on(event: "session_compact_failed", handler: ExtensionHandler<SessionCompactFailedEvent>): void;
     on(event: "session_info_changed", handler: ExtensionHandler<SessionInfoChangedEvent>): void;
     on(event: "session_shutdown", handler: ExtensionHandler<SessionShutdownEvent>): void;
     on(event: "session_before_tree", handler: ExtensionHandler<SessionBeforeTreeEvent, SessionBeforeTreeResult>): void;

package/dist/core/keybindings.d.ts

@@ -206,11 +206,11 @@ export declare const KEYBINDINGS: {
         readonly description: "Scroll viewport down one line";
     };
     readonly "tui.altScreen.previousPrompt": {
-        readonly defaultKeys: "ctrl+shift+up";
+        readonly defaultKeys: ["ctrl+shift+up", "ctrl+up"];
         readonly description: "Jump to previous semantic prompt";
     };
     readonly "tui.altScreen.nextPrompt": {
-        readonly defaultKeys: "ctrl+shift+down";
+        readonly defaultKeys: ["ctrl+shift+down", "ctrl+down"];
         readonly description: "Jump to next semantic prompt";
     };
     readonly "tui.altScreen.search": {

package/dist/core/messages.js

@@ -4,15 +4,15 @@
  * Extends the base AgentMessage type with coding-agent specific message types,
  * and provides a transformer to convert them to LLM-compatible messages.
  */
-export const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point was compacted into the following summary:
-
-<summary>
+export const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point was compacted into the following summary:
+
+<summary>
 `;
-export const COMPACTION_SUMMARY_SUFFIX = `
+export const COMPACTION_SUMMARY_SUFFIX = `
 </summary>`;
-export const BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:
-
-<summary>
+export const BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:
+
+<summary>
 `;
 export const BRANCH_SUMMARY_SUFFIX = `</summary>`;
 /**

package/dist/core/model-resolver.d.ts

@@ -110,6 +110,7 @@ export declare function findInitialModel(options: {
     defaultProvider?: string;
     defaultModelId?: string;
     defaultThinkingLevel?: ThinkingLevel;
+    modelThinkingLevels?: Record<string, ThinkingLevel>;
     modelRuntime: ModelRuntime;
 }): Promise<InitialModelResult>;
 /**

package/dist/core/model-resolver.js

@@ -440,7 +440,7 @@ export function resolveCliModel(options) {
  * 5. First available model with valid API key
  */
 export async function findInitialModel(options) {
-    const { cliProvider, cliModel, scopedModels, isContinuing, defaultProvider, defaultModelId, defaultThinkingLevel, modelRuntime, } = options;
+    const { cliProvider, cliModel, scopedModels, isContinuing, defaultProvider, defaultModelId, defaultThinkingLevel, modelThinkingLevels, modelRuntime, } = options;
     let model;
     let thinkingLevel = DEFAULT_THINKING_LEVEL;
     // 1. CLI args take priority
@@ -460,9 +460,11 @@ export async function findInitialModel(options) {
     }
     // 2. Use first model from scoped models (skip if continuing/resuming)
     if (scopedModels.length > 0 && !isContinuing) {
+        const scopedModel = scopedModels[0];
+        const perModel = modelThinkingLevels?.[`${scopedModel.model.provider}/${scopedModel.model.id}`];
         return {
-            model: scopedModels[0].model,
-            thinkingLevel: scopedModels[0].thinkingLevel ?? defaultThinkingLevel ?? DEFAULT_THINKING_LEVEL,
+            model: scopedModel.model,
+            thinkingLevel: scopedModel.thinkingLevel ?? perModel ?? defaultThinkingLevel ?? DEFAULT_THINKING_LEVEL,
             fallbackMessage: undefined,
         };
     }
@@ -471,7 +473,11 @@ export async function findInitialModel(options) {
         const found = modelRuntime.getModel(defaultProvider, defaultModelId);
         if (found && modelRuntime.hasConfiguredAuth(found.provider)) {
             model = found;
-            if (defaultThinkingLevel) {
+            const perModel = modelThinkingLevels?.[`${defaultProvider}/${defaultModelId}`];
+            if (perModel) {
+                thinkingLevel = perModel;
+            }
+            else if (defaultThinkingLevel) {
                 thinkingLevel = defaultThinkingLevel;
             }
             return { model, thinkingLevel, fallbackMessage: undefined };

package/dist/core/package-manager.js

@@ -1973,7 +1973,7 @@ export class DefaultPackageManager {
             // Project extensions from .pi/
             addResources("extensions", collectAutoExtensionEntries(projectDirs.extensions), projectMetadata, projectOverrides.extensions, projectBaseDir);
             // Project skills from .pi/
-            addResources("skills", collectAutoSkillEntries(projectDirs.skills, "pi"), projectMetadata, projectOverrides.skills, projectBaseDir, false);
+            addResources("skills", collectAutoSkillEntries(projectDirs.skills, "pi"), projectMetadata, projectOverrides.skills, projectBaseDir);
         }
         // Project skills from .agents/ (each with its own baseDir)
         for (const agentsSkillsDir of projectAgentsSkillDirs) {
@@ -1982,7 +1982,7 @@ export class DefaultPackageManager {
                 ...projectMetadata,
                 baseDir: agentsBaseDir,
             };
-            addResources("skills", collectAutoSkillEntries(agentsSkillsDir, "agents"), agentsMetadata, projectOverrides.skills, agentsBaseDir, false);
+            addResources("skills", collectAutoSkillEntries(agentsSkillsDir, "agents"), agentsMetadata, projectOverrides.skills, agentsBaseDir);
         }
         if (projectTrusted) {
             addResources("prompts", collectAutoPromptEntries(projectDirs.prompts), projectMetadata, projectOverrides.prompts, projectBaseDir);
@@ -2057,14 +2057,14 @@ export class DefaultPackageManager {
         }
         addResources("extensions", piHostKept, { ...userMetadata, baseDir: piHostBaseDir }, userOverrides.extensions, piHostBaseDir);
         // User skills from ~/.selesai/agent/
-        addResources("skills", collectAutoSkillEntries(userDirs.skills, "pi"), userMetadata, userOverrides.skills, globalBaseDir, false);
+        addResources("skills", collectAutoSkillEntries(userDirs.skills, "pi"), userMetadata, userOverrides.skills, globalBaseDir);
         // User skills from ~/.agents/ (with its own baseDir)
         const userAgentsBaseDir = dirname(userAgentsSkillsDir);
         const userAgentsMetadata = {
             ...userMetadata,
             baseDir: userAgentsBaseDir,
         };
-        addResources("skills", collectAutoSkillEntries(userAgentsSkillsDir, "agents"), userAgentsMetadata, userOverrides.skills, userAgentsBaseDir, false);
+        addResources("skills", collectAutoSkillEntries(userAgentsSkillsDir, "agents"), userAgentsMetadata, userOverrides.skills, userAgentsBaseDir);
         addResources("prompts", collectAutoPromptEntries(userDirs.prompts), userMetadata, userOverrides.prompts, globalBaseDir);
         addResources("themes", collectAutoThemeEntries(userDirs.themes), userMetadata, userOverrides.themes, globalBaseDir);
         return collisions;

package/dist/core/sdk.d.ts

@@ -6,7 +6,7 @@ import { ModelRuntime } from "./model-runtime.ts";
 import type { ResourceLoader } from "./resource-loader.ts";
 import { SessionManager } from "./session-manager.ts";
 import { SettingsManager } from "./settings-manager.ts";
-import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue } from "./tools/index.ts";
+import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createPowerShellTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue } from "./tools/index.ts";
 export interface CreateAgentSessionOptions {
     /** Working directory for project-local discovery. Default: process.cwd() */
     cwd?: string;
@@ -36,9 +36,9 @@ export interface CreateAgentSessionOptions {
      *
      * When omitted, pi uses the `defaultTools` setting for the initial built-in
      * selection when configured. Otherwise it enables the default built-in tools
-     * (read, bash, edit, write). Extension/custom tools remain enabled unless
-     * `noTools` changes that default. When provided, only the listed tool names are
-     * enabled.
+     * (read, bash, edit, write). Extension/custom tools are inactive by default;
+     * `noTools: "builtin"` enables them instead. When provided, only the listed
+     * tool names are enabled.
      */
     tools?: string[];
     /** Optional denylist of tool names to disable. Applies after `tools` when both are provided. */
@@ -68,7 +68,7 @@ export type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, Extension
 export type { PromptTemplate } from "./prompt-templates.ts";
 export type { Skill } from "./skills.ts";
 export type { Tool } from "./tools/index.ts";
-export { withFileMutationQueue, createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
+export { withFileMutationQueue, createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createPowerShellTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
 /**
  * Create an AgentSession with the specified options.
  *

package/dist/core/sdk.js

@@ -14,7 +14,7 @@ import { DefaultResourceLoader } from "./resource-loader.js";
 import { getDefaultSessionDir, SessionManager } from "./session-manager.js";
 import { SettingsManager } from "./settings-manager.js";
 import { time } from "./timings.js";
-import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue, } from "./tools/index.js";
+import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createPowerShellTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue, } from "./tools/index.js";
 // Preserve the pre-0.81 fallback for extensions that construct Agent instances
 // or invoke low-level agent loops without supplying streamFn. Agent core remains
 // provider-agnostic and does not import pi-ai/compat itself.
@@ -23,7 +23,7 @@ setDefaultStreamFn(streamSimple);
 export * from "./agent-session-runtime.js";
 export { withFileMutationQueue, 
 // Tool factories (for custom cwd)
-createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
+createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createPowerShellTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
 // Helper Functions
 function getDefaultAgentDir() {
     return getAgentDir();
@@ -101,6 +101,7 @@ export async function createAgentSession(options = {}) {
             defaultProvider: settingsManager.getDefaultProvider(),
             defaultModelId: settingsManager.getDefaultModel(),
             defaultThinkingLevel: settingsManager.getDefaultThinkingLevel(),
+            modelThinkingLevels: settingsManager.getAllModelThinkingLevels(),
             modelRuntime,
         });
         model = result.model;
@@ -118,7 +119,10 @@ export async function createAgentSession(options = {}) {
             ? existingSession.thinkingLevel
             : (settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL);
     }
-    // Fall back to settings default
+    // Fall back to the selected model's override, then settings default
+    if (thinkingLevel === undefined && model) {
+        thinkingLevel = settingsManager.getModelThinkingLevel(model.provider, model.id);
+    }
     if (thinkingLevel === undefined) {
         thinkingLevel = settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
     }
@@ -134,7 +138,15 @@ export async function createAgentSession(options = {}) {
     const allowedToolNames = options.tools ?? (options.noTools === "all" ? [] : undefined);
     const excludedToolNames = options.excludeTools;
     const excludedToolNameSet = excludedToolNames ? new Set(excludedToolNames) : undefined;
-    const initialActiveToolNames = (options.tools ?? (options.noTools ? [] : (configuredDefaultToolNames ?? defaultActiveToolNames))).filter((name) => !excludedToolNameSet?.has(name));
+    const initialActiveToolNames = (options.tools ??
+        (options.noTools === "builtin"
+            ? [
+                ...resourceLoader.getExtensions().extensions.flatMap((extension) => Array.from(extension.tools.keys())),
+                ...(options.customTools?.map((tool) => tool.name) ?? []),
+            ]
+            : options.noTools
+                ? []
+                : (configuredDefaultToolNames ?? defaultActiveToolNames))).filter((name) => !excludedToolNameSet?.has(name));
     let agent;
     // Create convertToLlm wrapper that filters images if blockImages is enabled (defense-in-depth)
     const convertToLlmWithBlockImages = (messages) => {

package/dist/core/settings-manager.d.ts

@@ -72,6 +72,8 @@ export interface Settings {
     defaultProvider?: string;
     defaultModel?: string;
     defaultThinkingLevel?: ThinkingLevel;
+    /** Per-model default thinking overrides, keyed by "provider/modelId". */
+    modelThinkingLevels?: Record<string, ThinkingLevel>;
     transport?: TransportSetting;
     steeringMode?: "all" | "one-at-a-time";
     followUpMode?: "all" | "one-at-a-time";
@@ -210,6 +212,10 @@ export declare class SettingsManager {
     setTheme(theme: string): void;
     getDefaultThinkingLevel(): ThinkingLevel | undefined;
     setDefaultThinkingLevel(level: ThinkingLevel): void;
+    getModelThinkingLevel(provider: string, modelId: string): ThinkingLevel | undefined;
+    getAllModelThinkingLevels(): Record<string, ThinkingLevel>;
+    setModelThinkingLevel(provider: string, modelId: string, level: ThinkingLevel): void;
+    removeModelThinkingLevel(provider: string, modelId: string): void;
     getTransport(): TransportSetting;
     setTransport(transport: TransportSetting): void;
     getCompactionEnabled(): boolean;

package/dist/core/settings-manager.js

@@ -515,6 +515,28 @@ export class SettingsManager {
         this.markModified("defaultThinkingLevel");
         this.save();
     }
+    getModelThinkingLevel(provider, modelId) {
+        return this.settings.modelThinkingLevels?.[`${provider}/${modelId}`];
+    }
+    getAllModelThinkingLevels() {
+        return { ...(this.settings.modelThinkingLevels ?? {}) };
+    }
+    setModelThinkingLevel(provider, modelId, level) {
+        this.globalSettings.modelThinkingLevels ??= {};
+        this.globalSettings.modelThinkingLevels[`${provider}/${modelId}`] = level;
+        this.markModified("modelThinkingLevels");
+        this.save();
+    }
+    removeModelThinkingLevel(provider, modelId) {
+        if (!this.globalSettings.modelThinkingLevels)
+            return;
+        delete this.globalSettings.modelThinkingLevels[`${provider}/${modelId}`];
+        if (Object.keys(this.globalSettings.modelThinkingLevels).length === 0) {
+            delete this.globalSettings.modelThinkingLevels;
+        }
+        this.markModified("modelThinkingLevels");
+        this.save();
+    }
     getTransport() {
         return this.settings.transport ?? "auto";
     }

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

@@ -1,11 +1,16 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
 import { type Static, Type } from "typebox";
+import { type ShellConfig } from "../../utils/shell.ts";
 import type { ToolDefinition } from "../extensions/types.ts";
 import { type TruncationResult } from "./truncate.ts";
 declare const bashSchema: Type.TObject<{
     command: Type.TString;
     timeout: Type.TOptional<Type.TNumber>;
 }>;
+export declare const bashToolSystemPromptContribution: {
+    readonly snippet: "Execute bash commands (ls, grep, find, etc.)";
+    readonly guidelines: readonly ["You can inspect PI_* environment variables for current model and session details."];
+};
 export type BashToolInput = Static<typeof bashSchema>;
 export interface BashToolDetails {
     truncation?: TruncationResult;
@@ -32,6 +37,8 @@ export interface BashOperations {
         exitCode: number | null;
     }>;
 }
+/** Shared process execution used by the built-in shell tools. */
+export declare function createLocalShellOperations(shellName: string, resolveShellConfig: () => ShellConfig): BashOperations;
 /**
  * Create bash operations using pi's built-in local shell execution backend.
  *
@@ -59,11 +66,21 @@ export interface BashToolOptions {
     /** Hook to adjust command, cwd, or env before execution */
     spawnHook?: BashSpawnHook;
 }
-type BashRenderState = {
+export type BashRenderState = {
     startedAt: number | undefined;
     endedAt: number | undefined;
     interval: NodeJS.Timeout | undefined;
 };
+export interface ShellToolConfig {
+    name: string;
+    label: string;
+    shellName: string;
+    prompt: string;
+    promptSnippet: string;
+    promptGuidelines?: readonly string[];
+    tempFilePrefix: string;
+}
+export declare function createShellToolDefinition(cwd: string, config: ShellToolConfig, options?: BashToolOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined, BashRenderState>;
 export declare function createBashToolDefinition(cwd: string, options?: BashToolOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined, BashRenderState>;
 export declare function createBashTool(cwd: string, options?: BashToolOptions): AgentTool<typeof bashSchema>;
 export {};

package/dist/core/tools/bash.js

@@ -7,8 +7,8 @@ import { keyHint } from "../../modes/interactive/components/keybinding-hints.js"
 import { truncateToVisualLines } from "../../modes/interactive/components/visual-truncate.js";
 import { theme } from "../../modes/interactive/theme/theme.js";
 import { waitForChildProcess } from "../../utils/child-process.js";
-import { getExperimentalToolSampling } from "../experimental.js";
 import { getShellConfig, getShellEnv, killProcessTree, trackDetachedChildPid, untrackDetachedChildPid, } from "../../utils/shell.js";
+import { getExperimentalToolSampling } from "../experimental.js";
 import { OutputAccumulator } from "./output-accumulator.js";
 import { getTextOutput, invalidArgText, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
@@ -28,28 +28,27 @@ function resolveTimeoutMs(timeout) {
     return timeoutMs;
 }
 const bashSchema = Type.Object({
-    command: Type.String({ description: "Bash command to execute" }),
+    command: Type.String({ description: "Shell command to execute" }),
     timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
 });
-/**
- * Create bash operations using pi's built-in local shell execution backend.
- *
- * This is useful for extensions that intercept user_bash and still want pi's
- * standard local shell behavior while wrapping or rewriting commands.
- */
-export function createLocalBashOperations(options) {
+export const bashToolSystemPromptContribution = {
+    snippet: "Execute bash commands (ls, grep, find, etc.)",
+    guidelines: ["You can inspect PI_* environment variables for current model and session details."],
+};
+/** Shared process execution used by the built-in shell tools. */
+export function createLocalShellOperations(shellName, resolveShellConfig) {
     return {
         exec: async (command, cwd, { onData, signal, timeout, env }) => {
             const timeoutMs = resolveTimeoutMs(timeout);
             if (signal?.aborted) {
                 throw new Error("aborted");
             }
-            const shellConfig = getShellConfig(options?.shellPath);
+            const shellConfig = resolveShellConfig();
             try {
                 await fsAccess(cwd, constants.F_OK);
             }
             catch {
-                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
+                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute ${shellName} commands.`);
             }
             const commandFromStdin = shellConfig.commandTransport === "stdin";
             const child = spawn(shellConfig.shell, commandFromStdin ? shellConfig.args : [...shellConfig.args, command], {
@@ -112,6 +111,15 @@ export function createLocalBashOperations(options) {
         },
     };
 }
+/**
+ * Create bash operations using pi's built-in local shell execution backend.
+ *
+ * This is useful for extensions that intercept user_bash and still want pi's
+ * standard local shell behavior while wrapping or rewriting commands.
+ */
+export function createLocalBashOperations(options) {
+    return createLocalShellOperations("bash", () => getShellConfig(options?.shellPath));
+}
 function resolveSpawnContext(command, cwd, spawnHook, exposeSessionEnvironment, ctx) {
     const env = { ...getShellEnv() };
     delete env.PI_SESSION_ID;
@@ -147,12 +155,12 @@ class BashResultRenderComponent extends Container {
 function formatDuration(ms) {
     return `${(ms / 1000).toFixed(1)}s`;
 }
-function formatBashCall(args) {
+function formatShellCall(args, prompt) {
     const command = str(args?.command);
     const timeout = args?.timeout;
     const timeoutSuffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
     const commandDisplay = command === null ? invalidArgText(theme) : command ? command : theme.fg("toolOutput", "...");
-    return theme.fg("toolTitle", theme.bold(`$ ${commandDisplay}`)) + timeoutSuffix;
+    return theme.fg("toolTitle", theme.bold(`${prompt} ${commandDisplay}`)) + timeoutSuffix;
 }
 function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt) {
     const state = component.state;
@@ -219,25 +227,23 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
         component.addChild(new Text(`\n${theme.fg("muted", `${label} ${formatDuration(endTime - startedAt)}`)}`, 0, 0));
     }
 }
-export function createBashToolDefinition(cwd, options) {
+export function createShellToolDefinition(cwd, config, options) {
     const ops = options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath });
     const commandPrefix = options?.commandPrefix;
     const exposeSessionEnvironment = options?.exposeSessionEnvironment ?? true;
     const spawnHook = options?.spawnHook;
     return {
-        name: "bash",
-        label: "bash",
-        description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
-        promptSnippet: "Execute bash commands (ls, grep, find, etc.)",
-        promptGuidelines: exposeSessionEnvironment
-            ? ["Inspect PI_* environment variables for current model and session details."]
-            : undefined,
+        name: config.name,
+        label: config.label,
+        description: `Execute a ${config.shellName} command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+        promptSnippet: config.promptSnippet,
+        promptGuidelines: exposeSessionEnvironment && config.promptGuidelines ? [...config.promptGuidelines] : undefined,
         parameters: bashSchema,
         constrainedSampling: getExperimentalToolSampling(),
         async execute(_toolCallId, { command, timeout }, signal, onUpdate, ctx) {
             const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
             const spawnContext = resolveSpawnContext(resolvedCommand, cwd, spawnHook, exposeSessionEnvironment, ctx);
-            const output = new OutputAccumulator({ tempFilePrefix: "pi-bash" });
+            const output = new OutputAccumulator({ tempFilePrefix: config.tempFilePrefix });
             let acceptingOutput = true;
             let updateTimer;
             let updateDirty = false;
@@ -358,7 +364,7 @@ export function createBashToolDefinition(cwd, options) {
                 state.endedAt = undefined;
             }
             const text = context.lastComponent ?? new Text("", 0, 0);
-            text.setText(formatBashCall(args));
+            text.setText(formatShellCall(args, config.prompt));
             return text;
         },
         renderResult(result, options, _theme, context) {
@@ -380,6 +386,18 @@ export function createBashToolDefinition(cwd, options) {
         },
     };
 }
+const bashToolConfig = {
+    name: "bash",
+    label: "bash",
+    shellName: "bash",
+    prompt: "$",
+    promptSnippet: bashToolSystemPromptContribution.snippet,
+    promptGuidelines: bashToolSystemPromptContribution.guidelines,
+    tempFilePrefix: "selesai-bash",
+};
+export function createBashToolDefinition(cwd, options) {
+    return createShellToolDefinition(cwd, bashToolConfig, options);
+}
 export function createBashTool(cwd, options) {
     const definition = createBashToolDefinition(cwd, options);
     const tool = wrapToolDefinition(definition);

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

@@ -1,4 +1,5 @@
 export { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, createBashTool, createBashToolDefinition, createLocalBashOperations, } from "./bash.ts";
+export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, type PowerShellOperations, type PowerShellSpawnContext, type PowerShellSpawnHook, type PowerShellToolDetails, type PowerShellToolInput, type PowerShellToolOptions, } from "./powershell.ts";
 export { createEditTool, createEditToolDefinition, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, } from "./edit.ts";
 export { withFileMutationQueue } from "./file-mutation-queue.ts";
 export { createFindTool, createFindToolDefinition, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, } from "./find.ts";
@@ -15,15 +16,17 @@ import { type EditToolOptions } from "./edit.ts";
 import { type FindToolOptions } from "./find.ts";
 import { type GrepToolOptions } from "./grep.ts";
 import { type LsToolOptions } from "./ls.ts";
+import { type PowerShellToolOptions } from "./powershell.ts";
 import { type ReadToolOptions } from "./read.ts";
 import { type WriteToolOptions } from "./write.ts";
 export type Tool = AgentTool<any>;
 export type ToolDef = ToolDefinition<any, any>;
-export type ToolName = "read" | "bash" | "edit" | "write" | "grep" | "find" | "ls";
+export type ToolName = "read" | "bash" | "powershell" | "edit" | "write" | "grep" | "find" | "ls";
 export declare const allToolNames: Set<ToolName>;
 export interface ToolsOptions {
     read?: ReadToolOptions;
     bash?: BashToolOptions;
+    powershell?: PowerShellToolOptions;
     write?: WriteToolOptions;
     edit?: EditToolOptions;
     grep?: GrepToolOptions;

package/dist/core/tools/index.js

@@ -1,4 +1,5 @@
 export { createBashTool, createBashToolDefinition, createLocalBashOperations, } from "./bash.js";
+export { createLocalPowerShellOperations, createPowerShellTool, createPowerShellToolDefinition, } from "./powershell.js";
 export { createEditTool, createEditToolDefinition, } from "./edit.js";
 export { withFileMutationQueue } from "./file-mutation-queue.js";
 export { createFindTool, createFindToolDefinition, } from "./find.js";
@@ -13,15 +14,18 @@ import { createEditTool, createEditToolDefinition } from "./edit.js";
 import { createFindTool, createFindToolDefinition } from "./find.js";
 import { createGrepTool, createGrepToolDefinition } from "./grep.js";
 import { createLsTool, createLsToolDefinition } from "./ls.js";
+import { createPowerShellTool, createPowerShellToolDefinition } from "./powershell.js";
 import { createReadTool, createReadToolDefinition } from "./read.js";
 import { createWriteTool, createWriteToolDefinition } from "./write.js";
-export const allToolNames = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
+export const allToolNames = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls"]);
 export function createToolDefinition(toolName, cwd, options) {
     switch (toolName) {
         case "read":
             return createReadToolDefinition(cwd, options?.read);
         case "bash":
             return createBashToolDefinition(cwd, options?.bash);
+        case "powershell":
+            return createPowerShellToolDefinition(cwd, options?.powershell);
         case "edit":
             return createEditToolDefinition(cwd, options?.edit);
         case "write":
@@ -42,6 +46,8 @@ export function createTool(toolName, cwd, options) {
             return createReadTool(cwd, options?.read);
         case "bash":
             return createBashTool(cwd, options?.bash);
+        case "powershell":
+            return createPowerShellTool(cwd, options?.powershell);
         case "edit":
             return createEditTool(cwd, options?.edit);
         case "write":
@@ -76,6 +82,7 @@ export function createAllToolDefinitions(cwd, options) {
     return {
         read: createReadToolDefinition(cwd, options?.read),
         bash: createBashToolDefinition(cwd, options?.bash),
+        powershell: createPowerShellToolDefinition(cwd, options?.powershell),
         edit: createEditToolDefinition(cwd, options?.edit),
         write: createWriteToolDefinition(cwd, options?.write),
         grep: createGrepToolDefinition(cwd, options?.grep),
@@ -103,6 +110,7 @@ export function createAllTools(cwd, options) {
     return {
         read: createReadTool(cwd, options?.read),
         bash: createBashTool(cwd, options?.bash),
+        powershell: createPowerShellTool(cwd, options?.powershell),
         edit: createEditTool(cwd, options?.edit),
         write: createWriteTool(cwd, options?.write),
         grep: createGrepTool(cwd, options?.grep),

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

@@ -0,0 +1,15 @@
+import { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, type createBashTool, createShellToolDefinition } from "./bash.ts";
+export declare const powershellToolSystemPromptContribution: {
+    readonly snippet: "Execute PowerShell commands";
+    readonly guidelines: readonly ["You can inspect PI_* environment variables for current model and session details."];
+};
+export type PowerShellOperations = BashOperations;
+export type PowerShellSpawnContext = BashSpawnContext;
+export type PowerShellSpawnHook = BashSpawnHook;
+export type PowerShellToolDetails = BashToolDetails;
+export type PowerShellToolInput = BashToolInput;
+export interface PowerShellToolOptions extends Pick<BashToolOptions, "operations" | "exposeSessionEnvironment" | "spawnHook"> {
+}
+export declare function createLocalPowerShellOperations(): PowerShellOperations;
+export declare function createPowerShellToolDefinition(cwd: string, options?: PowerShellToolOptions): ReturnType<typeof createShellToolDefinition>;
+export declare function createPowerShellTool(cwd: string, options?: PowerShellToolOptions): ReturnType<typeof createBashTool>;

package/dist/core/tools/powershell.js

@@ -0,0 +1,38 @@
+import { getPowerShellConfig } from "../../utils/shell.js";
+import { createLocalShellOperations, createShellToolDefinition, } from "./bash.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+const UTF8_OUTPUT_PREFIX = "try { [Console]::OutputEncoding=[System.Text.Encoding]::UTF8 } catch {}\n";
+export const powershellToolSystemPromptContribution = {
+    snippet: "Execute PowerShell commands",
+    guidelines: ["You can inspect PI_* environment variables for current model and session details."],
+};
+export function createLocalPowerShellOperations() {
+    const operations = createLocalShellOperations("PowerShell", getPowerShellConfig);
+    return {
+        exec: (command, cwd, options) => operations.exec(`${UTF8_OUTPUT_PREFIX}${command}`, cwd, options),
+    };
+}
+const powershellToolConfig = {
+    name: "powershell",
+    label: "powershell",
+    shellName: "PowerShell",
+    prompt: "PS>",
+    promptSnippet: powershellToolSystemPromptContribution.snippet,
+    promptGuidelines: powershellToolSystemPromptContribution.guidelines,
+    tempFilePrefix: "selesai-powershell",
+};
+export function createPowerShellToolDefinition(cwd, options) {
+    return createShellToolDefinition(cwd, powershellToolConfig, {
+        ...options,
+        operations: options?.operations ?? createLocalPowerShellOperations(),
+    });
+}
+export function createPowerShellTool(cwd, options) {
+    const definition = createPowerShellToolDefinition(cwd, options);
+    const tool = wrapToolDefinition(definition);
+    Object.assign(tool, {
+        promptSnippet: definition.promptSnippet,
+        promptGuidelines: definition.promptGuidelines,
+    });
+    return tool;
+}