@cjhyy/code-shell-core 0.6.0-rc.6 → 0.6.0-rc.7

package/dist/engine/model-connections-pool.js

@@ -51,6 +51,7 @@ export function modelEntriesFromConnections(connections, credentials, catalog) {
         const e = {
             key: inst.id,
             provider: clientProvider(entry),
+            providerKind: entry.adapterKind,
             model: resolved.model,
             baseUrl: resolved.baseUrl,
             needsKey: resolved.needsKey,

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export declare const VERSION = "0.6.0-rc.6";
+export declare const VERSION = "0.6.0-rc.7";
 export type { Message, ContentBlock, ToolDefinition, ToolCall, ToolResult, RegisteredTool, TranscriptEvent, TranscriptEventType, SessionState, SessionStatus, TokenUsage, CompiledInput, PermissionDecision, PermissionMode, PermissionRule, TurnPhase, TurnResult, TerminalReason, StreamEvent, StreamCallback, LLMConfig, ClientDefaults, LLMResponse, Settings, MCPServerConfig, } from "./types.js";
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, SandboxUnavailableError, } from "./exceptions.js";
 export { Engine, loadAgentDefinitionsForCwd } from "./engine/engine.js";

package/dist/index.js

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export const VERSION = "0.6.0-rc.6";
+export const VERSION = "0.6.0-rc.7";
 // ─── Exceptions ──────────────────────────────────────────────────
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, SandboxUnavailableError, } from "./exceptions.js";
 // ─── Engine (primary API) ────────────────────────────────────────

package/dist/llm/capabilities/rules.js

@@ -190,7 +190,7 @@ export const RULES = [
         // Most modern frontier models on OpenRouter are multimodal; flag the
         // big families explicitly. The catch-all below stays vision=false so
         // older/text-only routes don't get a green checkmark they don't earn.
-        match: /^(?:openai\/(?:gpt-4o|gpt-5|o[1-9])|anthropic\/claude-(?:3|4|opus|sonnet|haiku)|google\/gemini-[2-9]|x-ai\/grok-[4-9]|qwen\/qwen-?vl|meta\/llama-(?:3\.2|4))/i,
+        match: /^~?(?:openai\/(?:gpt-4o|gpt-5|o[1-9])|anthropic\/claude-(?:3|4|opus|sonnet|haiku|fable)|google\/gemini-(?:[2-9]|pro)|x-ai\/grok-[4-9]|qwen\/qwen-?vl|meta\/llama-(?:3\.2|4))/i,
         capability: {
             supportsVision: true,
             reasoning: { kind: "openrouter-reasoning" },

package/dist/llm/model-pool.d.ts

@@ -21,6 +21,11 @@ export interface ModelEntry {
     provider: string;
     /** Full model path: "anthropic/claude-opus-4-6" */
     model: string;
+    /**
+     * Catalog/provider kind used by capability rules. This can differ from
+     * `provider`, which only selects the client protocol family.
+     */
+    providerKind?: string;
     baseUrl?: string;
     apiKey?: string;
     /** Whether the catalog template requires a key (default true; false = local/

package/dist/llm/model-pool.js

@@ -221,6 +221,7 @@ export class ModelPool {
                 return "anthropic";
             return "openai";
         };
+        const providerKind = entry.providerKind ?? fromCat?.kind;
         return {
             provider: entry.provider ||
                 kindToClientProvider(fromCat?.kind) ||
@@ -250,7 +251,7 @@ export class ModelPool {
             ...(entry.reasoningSummary ? { reasoningSummary: entry.reasoningSummary } : {}),
             // Carry the catalog kind through so the capability layer can pick
             // per-(kind, model) request-shape rules.
-            ...(fromCat?.kind ? { providerKind: fromCat.kind } : {}),
+            ...(providerKind ? { providerKind } : {}),
             ...(entry.extraBody && Object.keys(entry.extraBody).length > 0
                 ? { extraBody: entry.extraBody }
                 : {}),

package/dist/model-catalog/builtin.js

@@ -8,6 +8,7 @@
  * ~/.code-shell/model-catalog.user.json) — no UI / adapter changes, as long as
  * its adapterKind points at an already-wired adapter.
  */
+import { capabilitiesFor } from "../llm/capabilities/index.js";
 import { paramSpecsFromCapability } from "../llm/capabilities/param-specs.js";
 /**
  * Build a text model preset, projecting its params from the capability layer
@@ -15,11 +16,13 @@ import { paramSpecsFromCapability } from "../llm/capabilities/param-specs.js";
  * when the model has none, matching the "absent → no knobs" contract.
  */
 function textPreset(kind, value, label, ctx) {
+    const capability = capabilitiesFor(kind, value);
     const params = paramSpecsFromCapability(kind, value);
     return {
         value,
         ...(label ? { label } : {}),
         ...(ctx !== undefined ? { maxContextTokens: ctx } : {}),
+        supportsVision: capability.supportsVision,
         ...(params.length > 0 ? { params } : {}),
     };
 }
@@ -97,14 +100,16 @@ const ZHIPU_PARAMS = [
 ];
 /** Zhipu GLM preset — shared ZHIPU_PARAMS, with per-model context window. */
 function glmPreset(value, label, ctx) {
-    return { value, label, maxContextTokens: ctx, params: ZHIPU_PARAMS };
+    return { value, label, maxContextTokens: ctx, supportsVision: false, params: ZHIPU_PARAMS };
 }
 /** OpenRouter preset with explicit params (no capability-layer projection). */
 function orPreset(value, label, params, ctx) {
+    const capability = capabilitiesFor("openrouter", value);
     return {
         value,
         label,
         ...(ctx !== undefined ? { maxContextTokens: ctx } : {}),
+        supportsVision: capability.supportsVision,
         ...(params && params.length > 0 ? { params } : {}),
     };
 }

package/dist/preset/index.d.ts

@@ -49,6 +49,10 @@ export declare function registerPreset(preset: AgentPreset): void;
 /** List all available preset names (built-in + custom). */
 export declare function listPresetNames(): string[];
 export declare function resolveAgentPreset(name?: string): AgentPreset;
+export interface BuildPresetSystemPromptOptions {
+    activeToolNames?: readonly string[];
+    platform?: NodeJS.Platform;
+}
 /**
  * Build the full system prompt for a preset by loading and joining its sections.
  *
@@ -58,7 +62,7 @@ export declare function resolveAgentPreset(name?: string): AgentPreset;
  * (tools + usage instructions disappear together). Omit `activeToolNames` to
  * include all sections (e.g. when assembling a generic/preview prompt).
  */
-export declare function buildPresetSystemPrompt(preset: AgentPreset, activeToolNames?: readonly string[]): string;
+export declare function buildPresetSystemPrompt(preset: AgentPreset, optionsOrActiveToolNames?: BuildPresetSystemPromptOptions | readonly string[]): string;
 export declare function resolveBuiltinToolNames(options?: {
     preset?: string;
     enabledBuiltinTools?: string[];

package/dist/preset/index.js

@@ -232,6 +232,19 @@ const BROWSER_SECTION_TOOLS = ["browser_observe", "browser_act", "browser_naviga
 const TOOL_GATED_SECTIONS = {
     browser: BROWSER_SECTION_TOOLS,
 };
+function isActiveToolNamesList(value) {
+    return Array.isArray(value);
+}
+function platformShellGuidance(platform) {
+    if (platform !== "win32")
+        return "";
+    return [
+        "# Windows Shell Guidance",
+        "- On Windows, Bash uses Git Bash when it is available. Prefer Bash for ordinary shell commands, git operations, package-manager commands, tests, and POSIX-style command lines.",
+        "- Do not choose PowerShell merely because the OS is Windows. Use PowerShell only when the user explicitly asks for it or the task requires PowerShell-specific cmdlets, Windows APIs, registry access, or `.ps1` behavior.",
+        "- When writing Bash commands on Windows, use Git Bash paths such as `/d/github/project` instead of PowerShell-only syntax or raw `D:\\...` paths inside `cd` commands.",
+    ].join("\n");
+}
 /**
  * Build the full system prompt for a preset by loading and joining its sections.
  *
@@ -241,8 +254,12 @@ const TOOL_GATED_SECTIONS = {
  * (tools + usage instructions disappear together). Omit `activeToolNames` to
  * include all sections (e.g. when assembling a generic/preview prompt).
  */
-export function buildPresetSystemPrompt(preset, activeToolNames) {
+export function buildPresetSystemPrompt(preset, optionsOrActiveToolNames) {
     let sections = preset.promptSections;
+    const options = isActiveToolNamesList(optionsOrActiveToolNames)
+        ? { activeToolNames: optionsOrActiveToolNames }
+        : (optionsOrActiveToolNames ?? {});
+    const activeToolNames = options.activeToolNames;
     if (activeToolNames) {
         const active = new Set(activeToolNames);
         sections = sections.filter((s) => {
@@ -250,7 +267,9 @@ export function buildPresetSystemPrompt(preset, activeToolNames) {
             return !gate || gate.some((t) => active.has(t));
         });
     }
-    return loadSections(sections);
+    return [loadSections(sections), platformShellGuidance(options.platform ?? process.platform)]
+        .filter(Boolean)
+        .join("\n\n");
 }
 export function resolveBuiltinToolNames(options) {
     const preset = resolveAgentPreset(options?.preset);

package/dist/prompt/composer.js

@@ -187,7 +187,7 @@ export class PromptComposer {
             cacheBreak: true,
             compute: () => {
                 const preset = this.options.preset ?? resolveAgentPreset();
-                return buildPresetSystemPrompt(preset, activeToolNames);
+                return buildPresetSystemPrompt(preset, { activeToolNames, platform: process.platform });
             },
         });
         // Skills listing is intentionally NOT a system section: it changes when a

package/dist/prompt/sections/base.md

@@ -31,7 +31,7 @@ When you encounter an obstacle, do not use destructive actions as a shortcut to
   - To search for files use Glob instead of find or ls
   - To search the content of files, use Grep instead of grep or rg
   - Reserve using the Bash exclusively for system commands and terminal operations that require shell execution.
- - Shell choice: when Bash is available, use it for ordinary shell commands, git operations, package-manager commands, test/build scripts, and POSIX-style command lines. On Windows, Bash uses Git Bash when it is available, so do not choose PowerShell merely because the OS is Windows. Use PowerShell only when the user explicitly asks for it or the task requires PowerShell-specific cmdlets, Windows APIs, registry access, or `.ps1` behavior.
+ - Shell choice: use Bash for ordinary shell commands, git operations, package-manager commands, test/build scripts, and POSIX-style command lines. Use PowerShell only when the user explicitly asks for it or the task requires PowerShell-specific cmdlets, Windows APIs, registry access, or `.ps1` behavior.
  - For long-lived processes that don't exit on their own — a dev server (`npm run dev`, `vite`), a watcher, a tunnel — call Bash with `run_in_background: true`. It returns a `shell_id` immediately instead of blocking until a timeout. Then use `BashOutput(shell_id)` to read its logs (e.g. to confirm it started or to see an error), `ListShells()` to see what's running, and `KillShell(shell_id)` to stop it. Never run such a command in the foreground — it will just block until it's killed. Plain one-shot commands (build, test, git) stay foreground.
  - Break down and manage multi-step work with the TodoWrite tool. Pass the complete todo list each call; rewrite it as items move pending → in_progress → completed.
  - You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel.

package/dist/protocol/server.js

@@ -997,12 +997,17 @@ export class AgentServer {
                 break;
             }
             case "compact": {
-                if (!engine) {
-                    this.transport.send(createErrorResponse(req.id, ErrorCodes.InternalError, "No engine available for compact query"));
+                const compactEngine = this.chatManager && typeof params.sessionId === "string"
+                    ? this.chatManager.get(params.sessionId)?.engine
+                    : engine;
+                if (!compactEngine) {
+                    this.transport.send(createErrorResponse(req.id, this.chatManager && params.sessionId ? ErrorCodes.SessionClosed : ErrorCodes.InternalError, this.chatManager && params.sessionId
+                        ? `No such live session: ${params.sessionId}`
+                        : "No engine available for compact query"));
                     return;
                 }
                 try {
-                    const result = engine.forceCompact();
+                    const result = compactEngine.forceCompact();
                     this.transport.send(createResponse(req.id, {
                         type: "compact",
                         data: result,

package/dist/runtime/background-shell.js

@@ -89,6 +89,7 @@ export class BackgroundShellManager {
                 error: `Too many background shells for this session (max ${MAX_SHELLS_PER_SESSION}). KillShell some first.`,
             };
         }
+        const profileStartedAt = backgroundSpawnProfileEnabled() ? performance.now() : 0;
         const shell = opts.shell ?? defaultShellBinary();
         const { file, args } = resolveSpawnTarget(opts.command, {
             cwd: opts.cwd,
@@ -113,8 +114,10 @@ export class BackgroundShellManager {
             });
         }
         catch (err) {
+            logBackgroundSpawnProfile(file, args, elapsedProfileMs(profileStartedAt), "spawn_failed");
             return { ok: false, error: `Failed to spawn background shell: ${err.message}` };
         }
+        logBackgroundSpawnProfile(file, args, elapsedProfileMs(profileStartedAt), "started");
         if (child.pid === undefined) {
             return { ok: false, error: "Failed to spawn background shell: no pid" };
         }
@@ -493,3 +496,14 @@ export class BackgroundShellManager {
 }
 /** Process-local singleton, mirroring asyncAgentRegistry's lifetime contract. */
 export const backgroundShellManager = new BackgroundShellManager();
+function backgroundSpawnProfileEnabled() {
+    return process.env.CODESHELL_SPAWN_PROFILE === "1";
+}
+function elapsedProfileMs(startedAt) {
+    return startedAt > 0 ? Math.round(performance.now() - startedAt) : undefined;
+}
+function logBackgroundSpawnProfile(file, args, elapsedMs, status) {
+    if (!backgroundSpawnProfileEnabled())
+        return;
+    console.error(`[spawn-profile] background shell=${JSON.stringify(file)} flag=${JSON.stringify(args[0] ?? "")} elapsedMs=${elapsedMs ?? "n/a"} status=${status}`);
+}

package/dist/runtime/safe-spawn.js

@@ -50,6 +50,7 @@ export function safeSpawn(file, args, opts) {
         args,
         opts,
         cleanup: undefined,
+        resolveMs: undefined,
     });
 }
 /**
@@ -60,6 +61,7 @@ export function safeSpawn(file, args, opts) {
  * abort, timeout, pre-spawn-abort. Used by the Bash tool.
  */
 export function safeSpawnShell(command, opts) {
+    const resolveStartedAt = spawnProfileEnabled() ? performance.now() : 0;
     // Don't hardcode a POSIX default here — resolveSpawnTarget →
     // resolveShellInvocation picks the platform shell (cmd.exe on Windows,
     // $SHELL/bin/bash on POSIX) when opts.shell is omitted.
@@ -69,11 +71,12 @@ export function safeSpawnShell(command, opts) {
         shell,
         sandbox: opts.sandbox,
     });
-    return runLifecycle({ file, args, opts, cleanup });
+    return runLifecycle({ file, args, opts, cleanup, resolveMs: elapsedMs(resolveStartedAt) });
 }
-function runLifecycle({ file, args, opts, cleanup }) {
+function runLifecycle({ file, args, opts, cleanup, resolveMs }) {
     const maxBytes = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
     const abortGrace = opts.ioDrainGraceMs ?? DEFAULT_IO_DRAIN_GRACE_MS;
+    const lifecycleStartedAt = spawnProfileEnabled() ? performance.now() : 0;
     // Pre-spawn abort: don't pay spawn cost.
     if (opts.signal?.aborted) {
         safeCleanup(cleanup);
@@ -85,6 +88,7 @@ function runLifecycle({ file, args, opts, cleanup }) {
             if (settled)
                 return;
             settled = true;
+            logSpawnProfile(file, args, resolveMs, elapsedMs(lifecycleStartedAt), result.reason);
             // Always release backend-allocated resources, regardless of exit path.
             // cleanup is best-effort — see seatbelt backend for rationale.
             safeCleanup(cleanup);
@@ -221,6 +225,17 @@ function runLifecycle({ file, args, opts, cleanup }) {
         });
     });
 }
+function spawnProfileEnabled() {
+    return process.env.CODESHELL_SPAWN_PROFILE === "1";
+}
+function elapsedMs(startedAt) {
+    return startedAt > 0 ? Math.round(performance.now() - startedAt) : undefined;
+}
+function logSpawnProfile(file, args, resolveMs, lifecycleMs, reason) {
+    if (!spawnProfileEnabled())
+        return;
+    console.error(`[spawn-profile] shell=${JSON.stringify(file)} flag=${JSON.stringify(args[0] ?? "")} resolveMs=${resolveMs ?? "n/a"} lifecycleMs=${lifecycleMs ?? "n/a"} reason=${reason}`);
+}
 function safeCleanup(cleanup) {
     if (!cleanup)
         return;

package/dist/runtime/spawn-common.d.ts

@@ -72,9 +72,11 @@ export interface SpawnTarget {
  * in five places (bash.ts, safe-spawn.ts, background-shell.ts, worktree.ts):
  *
  *   - POSIX: `<explicit ?? $SHELL ?? /bin/bash> -c "<command>"`
- *   - Windows: `cmd.exe /c "<command>"` (the `-c` flag does not exist on cmd;
- *     a bare `-c` would be taken as a filename and fail). PowerShell uses
- *     `-Command`, but cmd.exe is the safe default present on every Windows.
+ *   - Windows: `<explicit shell ?? Git Bash ?? PowerShell ?? ComSpec ?? cmd.exe>` with the
+ *     shell-appropriate flag: Git Bash/POSIX shells use `-c`, PowerShell uses
+ *     `-Command`, and cmd.exe uses `/c` (`-c` would be taken as a filename and
+ *     fail/hang). Git Bash is preferred because the Bash tool receives POSIX
+ *     syntax from the model.
  *
  * `$SHELL` is ignored on Windows — it is virtually never set there, and when
  * it is (e.g. a stray value from a Unix-y env) it points at a POSIX path that
@@ -88,8 +90,12 @@ export declare function resolveShellInvocation(command: string, shell?: string):
 export declare function resolveGitBash(): string | undefined;
 /** Reset the Git Bash probe cache. Test-only (platform is stubbed per test). */
 export declare function _resetGitBashCache(): void;
+export declare function resolvePowerShell(): string | undefined;
+/** Reset the PowerShell probe cache. Test-only (platform is stubbed per test). */
+export declare function _resetPowerShellCache(): void;
 /** The platform's default interactive shell binary, for spawning a bare shell
- *  (no `-c`/`/c` command). Windows → Git Bash if present, else ComSpec/cmd.exe;
+ *  (no `-c`/`/c` command). Windows → Git Bash if present, else PowerShell,
+ *  else ComSpec/cmd.exe;
  *  POSIX → $SHELL/bin/bash. Windows prefers Git Bash so the model's bash-syntax
  *  commands actually run (cmd.exe can't). */
 export declare function defaultShellBinary(shell?: string): string;

package/dist/runtime/spawn-common.js

@@ -105,9 +105,11 @@ export function mergeShellEnv(base, projectEnv) {
  * in five places (bash.ts, safe-spawn.ts, background-shell.ts, worktree.ts):
  *
  *   - POSIX: `<explicit ?? $SHELL ?? /bin/bash> -c "<command>"`
- *   - Windows: `cmd.exe /c "<command>"` (the `-c` flag does not exist on cmd;
- *     a bare `-c` would be taken as a filename and fail). PowerShell uses
- *     `-Command`, but cmd.exe is the safe default present on every Windows.
+ *   - Windows: `<explicit shell ?? Git Bash ?? PowerShell ?? ComSpec ?? cmd.exe>` with the
+ *     shell-appropriate flag: Git Bash/POSIX shells use `-c`, PowerShell uses
+ *     `-Command`, and cmd.exe uses `/c` (`-c` would be taken as a filename and
+ *     fail/hang). Git Bash is preferred because the Bash tool receives POSIX
+ *     syntax from the model.
  *
  * `$SHELL` is ignored on Windows — it is virtually never set there, and when
  * it is (e.g. a stray value from a Unix-y env) it points at a POSIX path that
@@ -116,7 +118,7 @@ export function mergeShellEnv(base, projectEnv) {
  */
 export function resolveShellInvocation(command, shell) {
     if (process.platform === "win32") {
-        const file = shell ?? process.env.ComSpec ?? "cmd.exe";
+        const file = shell ?? defaultShellBinary();
         // Flag form depends on the shell: PowerShell → -Command; a POSIX shell such
         // as Git Bash's bash.exe / sh → -c (it does NOT understand cmd's /c); cmd.exe
         // (and cmd-like) → /c. Detecting bash/sh matters now that defaultShellBinary
@@ -139,7 +141,7 @@ export function resolveShellInvocation(command, shell) {
  * default is `cmd.exe`, which can't run any of that — so "Bash" was effectively
  * broken on Windows. Git for Windows (which most devs already have — we detect
  * it for repo ops anyway) ships a full bash at `<git>\bin\bash.exe`, so prefer
- * it. Only falls back to cmd.exe when Git Bash truly isn't present.
+ * it. Falls back to PowerShell before cmd.exe when Git Bash truly isn't present.
  *
  * Resolution order:
  *   1. CODE_SHELL_GIT_BASH_PATH env override (explicit user config wins).
@@ -183,15 +185,49 @@ export function resolveGitBash() {
 export function _resetGitBashCache() {
     gitBashCache = undefined;
 }
+let powerShellCache;
+export function resolvePowerShell() {
+    if (process.platform !== "win32")
+        return undefined;
+    if (powerShellCache !== undefined)
+        return powerShellCache ?? undefined;
+    const override = process.env.CODE_SHELL_POWERSHELL_PATH;
+    if (override && existsSync(override))
+        return (powerShellCache = override);
+    const candidates = [];
+    for (const exe of ["pwsh", "powershell"]) {
+        try {
+            const out = execFileSync("where", [exe], { encoding: "utf-8", timeout: 3000 });
+            const found = out.split(/\r?\n/).find((l) => l.trim().toLowerCase().endsWith(`${exe}.exe`));
+            if (found)
+                candidates.push(found.trim());
+        }
+        catch {
+            // Not on PATH; try the next shell / well-known locations.
+        }
+    }
+    const pf = process.env["ProgramFiles"] ?? "C:\\Program Files";
+    const systemRoot = process.env.SystemRoot ?? "C:\\Windows";
+    candidates.push(join(pf, "PowerShell", "7", "pwsh.exe"));
+    candidates.push(join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"));
+    const found = candidates.find((p) => existsSync(p));
+    return (powerShellCache = found ?? null) ?? undefined;
+}
+/** Reset the PowerShell probe cache. Test-only (platform is stubbed per test). */
+export function _resetPowerShellCache() {
+    powerShellCache = undefined;
+}
 /** The platform's default interactive shell binary, for spawning a bare shell
- *  (no `-c`/`/c` command). Windows → Git Bash if present, else ComSpec/cmd.exe;
+ *  (no `-c`/`/c` command). Windows → Git Bash if present, else PowerShell,
+ *  else ComSpec/cmd.exe;
  *  POSIX → $SHELL/bin/bash. Windows prefers Git Bash so the model's bash-syntax
  *  commands actually run (cmd.exe can't). */
 export function defaultShellBinary(shell) {
     if (shell)
         return shell;
-    if (process.platform === "win32")
-        return resolveGitBash() ?? process.env.ComSpec ?? "cmd.exe";
+    if (process.platform === "win32") {
+        return resolveGitBash() ?? resolvePowerShell() ?? process.env.ComSpec ?? "cmd.exe";
+    }
     return process.env.SHELL ?? "/bin/bash";
 }
 /**

package/dist/tool-system/builtin/bash.js

@@ -30,9 +30,8 @@ export const bashToolDef = {
     name: "Bash",
     description: "Execute a shell command and return its output. " +
         "Use for ordinary shell commands, system operations, git commands, " +
-        "package-manager commands, running tests, installing packages, etc. " +
-        "On Windows this tool prefers Git Bash when available, so prefer Bash over " +
-        "PowerShell unless the task needs PowerShell-specific syntax or APIs.",
+        "package-manager commands, running tests, installing packages, etc. Prefer Bash " +
+        "over PowerShell unless the task needs PowerShell-specific syntax or APIs.",
     inputSchema: {
         type: "object",
         properties: {

package/dist/tool-system/builtin/edit-model-catalog.js

@@ -10,11 +10,13 @@
 import { randomBytes } from "node:crypto";
 import { userCatalogPath } from "../../model-catalog/index.js";
 import { saveCatalogEntry } from "../../model-catalog/save-entry.js";
+import { catalogEntrySchema } from "../../model-catalog/types.js";
 export const editModelCatalogToolDef = {
     name: "EditModelCatalog",
     description: "Add or update a provider/model template in the user model catalog so it " +
-        "appears in the connection page (text/image/video). Keyed by `id` — a new id " +
-        "adds, an existing id updates (in place). Backs up the file before writing and " +
+        "appears in the connection page (text/image/video). Keyed by `id`: a new id " +
+        "adds a provider, an existing id replaces that user-catalog entry. Backs up " +
+        "the file before writing and " +
         "validates the entry. Use after researching a model's real facts (id, context " +
         "window, supported params, modalities) — do NOT guess; verify against the " +
         "provider's official docs first (see the model-fact-finder skill). Does NOT set " +
@@ -31,7 +33,8 @@ export const editModelCatalogToolDef = {
                     "maxContextTokens?, maxOutputTokens?, supportsVision?, params?[]}). Each param: " +
                     "{name, label?, control (enum|number|toggle|text), options?[], min?, max?, default?, " +
                     "doc?, wire?{field}}. Fill maxContextTokens with the model's REAL window; declare " +
-                    "params per-model (only what that model supports).",
+                    "params per-model (only what that model supports). To keep a custom provider " +
+                    "beside a built-in one, use a distinct id.",
             },
         },
         required: ["entry"],
@@ -42,11 +45,18 @@ export async function editModelCatalogTool(args) {
     if (!entry || typeof entry !== "object") {
         return "Error: `entry` (a CatalogEntry object) is required.";
     }
+    const parsed = catalogEntrySchema.safeParse(entry);
+    if (!parsed.success) {
+        return `Error: invalid catalog entry: ${parsed.error.issues.map((i) => i.message).join("; ")}`;
+    }
     const stamp = `${Date.now()}-${randomBytes(3).toString("hex")}`;
-    const r = saveCatalogEntry(entry, { path: userCatalogPath(), stamp });
+    const r = saveCatalogEntry(parsed.data, {
+        path: userCatalogPath(),
+        stamp,
+    });
     if (!r.ok)
         return `Error: ${r.error}`;
-    return summarizeWrite(entry, r.action ?? "added", r.backup);
+    return summarizeWrite(parsed.data, r.action ?? "added", r.backup);
 }
 /**
  * Build a structured completion summary so the user can SEE exactly what was

package/dist/tool-system/builtin/generate-video.js

@@ -86,6 +86,7 @@ export const generateVideoToolDef = {
 let injectedProvider = null;
 export function __setVideoProviderForTests(p) {
     injectedProvider = p;
+    availCache.clear();
 }
 /**
  * Tool-visibility guard: GenerateVideo is hidden until a video provider is
@@ -97,6 +98,8 @@ export function __setVideoProviderForTests(p) {
 const availCache = new Map();
 const AVAIL_TTL_MS = 1000;
 export function isGenerateVideoAvailable(cwd = process.cwd(), nowMs = Date.now()) {
+    if (injectedProvider)
+        return true;
     const hit = availCache.get(cwd);
     if (hit && nowMs - hit.at < AVAIL_TTL_MS)
         return hit.value;

package/dist/tool-system/builtin/grep.d.ts

@@ -3,5 +3,14 @@
  */
 import type { ToolDefinition } from "../../types.js";
 import type { ToolContext } from "../context.js";
+type ExecFileForGrep = (file: string, args: readonly string[], options: {
+    maxBuffer: number;
+    timeout: number;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function _setGrepExecFileForTest(fn?: ExecFileForGrep): void;
 export declare const grepToolDef: ToolDefinition;
 export declare function grepTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
+export {};

package/dist/tool-system/builtin/grep.js

@@ -2,9 +2,14 @@
  * Built-in Grep content search tool.
  */
 import { execFile } from "node:child_process";
+import { readdir, readFile, stat } from "node:fs/promises";
 import { promisify } from "node:util";
-import { resolve, sep, isAbsolute } from "node:path";
+import { basename, join, relative, resolve, sep, isAbsolute } from "node:path";
 const execFileAsync = promisify(execFile);
+let execFileForTest = execFileAsync;
+export function _setGrepExecFileForTest(fn) {
+    execFileForTest = fn ?? execFileAsync;
+}
 /**
  * Strip the cwd prefix from each line so results display as relative
  * paths (e.g. "src/ui/App.tsx" instead of an absolute path). Lines that
@@ -76,10 +81,16 @@ export async function grepTool(args, ctx) {
         catch (grepErr) {
             if (isNoMatchExit(grepErr))
                 return "No matches found.";
+            if (isCommandNotFound(rgErr) || isCommandNotFound(grepErr)) {
+                return await runNodeGrep(pattern, searchPath, fileGlob, context, maxResults, outputMode, caseInsensitive);
+            }
             return `Error in search: ${grepErr.message}`;
         }
     }
 }
+function isCommandNotFound(err) {
+    return err?.code === "ENOENT";
+}
 async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
     const args = ["--color=never"];
     if (caseInsensitive)
@@ -102,7 +113,7 @@ async function runRipgrep(pattern, path, fileGlob, context, maxResults, outputMo
     // Ignore common non-source dirs
     args.push("--glob", "!node_modules", "--glob", "!.git", "--glob", "!dist", "--glob", "!coverage");
     args.push("--", pattern, path);
-    const { stdout } = await execFileAsync("rg", args, {
+    const { stdout } = await execFileForTest("rg", args, {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 30_000,
     });
@@ -139,7 +150,7 @@ async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode,
     args.push("-E", pattern);
     args.push("--exclude-dir=node_modules", "--exclude-dir=.git", "--exclude-dir=dist");
     args.push(path);
-    const { stdout } = await execFileAsync("grep", args, {
+    const { stdout } = await execFileForTest("grep", args, {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 30_000,
     });
@@ -152,3 +163,89 @@ async function runGrep(pattern, path, fileGlob, context, maxResults, outputMode,
     }
     return result;
 }
+const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "coverage"]);
+async function runNodeGrep(pattern, path, fileGlob, context, maxResults, outputMode, caseInsensitive) {
+    let regex;
+    try {
+        regex = new RegExp(pattern, caseInsensitive ? "i" : "");
+    }
+    catch (err) {
+        return `Error in search: ${err.message}`;
+    }
+    const matches = [];
+    await walkTextFiles(path, fileGlob, async (file) => {
+        if (matches.length >= maxResults)
+            return;
+        let text;
+        try {
+            text = await readFile(file, "utf8");
+        }
+        catch {
+            return;
+        }
+        const lines = text.split(/\r?\n/);
+        const matchingLines = [];
+        for (let i = 0; i < lines.length; i++) {
+            regex.lastIndex = 0;
+            if (regex.test(lines[i]))
+                matchingLines.push(i);
+        }
+        if (matchingLines.length === 0)
+            return;
+        const rel = relative(path, file) || basename(file);
+        if (outputMode === "files_with_matches") {
+            matches.push(rel);
+        }
+        else if (outputMode === "count") {
+            matches.push(`${rel}:${matchingLines.length}`);
+        }
+        else {
+            const emitted = new Set();
+            for (const lineIndex of matchingLines) {
+                const start = Math.max(0, lineIndex - context);
+                const end = Math.min(lines.length - 1, lineIndex + context);
+                for (let i = start; i <= end; i++) {
+                    if (emitted.has(i))
+                        continue;
+                    emitted.add(i);
+                    matches.push(`${rel}:${i + 1}:${lines[i]}`);
+                    if (matches.length >= maxResults)
+                        return;
+                }
+            }
+        }
+    });
+    if (matches.length === 0)
+        return "No matches found.";
+    if (matches.length > 200)
+        return matches.slice(0, 200).join("\n") + `\n\n... ${matches.length - 200} more results`;
+    return matches.join("\n");
+}
+async function walkTextFiles(root, fileGlob, visit) {
+    const info = await stat(root).catch(() => null);
+    if (!info)
+        return;
+    if (info.isFile()) {
+        if (!fileGlob || matchesSimpleGlob(basename(root), fileGlob))
+            await visit(root);
+        return;
+    }
+    if (!info.isDirectory())
+        return;
+    const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            await walkTextFiles(join(root, entry.name), fileGlob, visit);
+        }
+        else if (entry.isFile()) {
+            if (!fileGlob || matchesSimpleGlob(entry.name, fileGlob))
+                await visit(join(root, entry.name));
+        }
+    }
+}
+function matchesSimpleGlob(name, glob) {
+    const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`).test(name);
+}

package/dist/tool-system/builtin/powershell.js

@@ -10,8 +10,8 @@ export const powershellToolDef = {
     name: "PowerShell",
     description: "Execute PowerShell commands. Use only when the user explicitly asks for PowerShell " +
         "or the task requires PowerShell-specific cmdlets, Windows APIs, registry access, " +
-        "or .ps1 behavior. For ordinary shell/git/package/test commands, prefer Bash " +
-        "(Git Bash on Windows when available).",
+        "or .ps1 behavior. Do NOT use for ordinary file, git, package-manager, test, " +
+        "or POSIX-style shell commands; use Bash for those.",
     inputSchema: {
         type: "object",
         properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-core",
-  "version": "0.6.0-rc.6",
+  "version": "0.6.0-rc.7",
   "description": "Core engine for code-shell — agent orchestration, tool execution, hooks, protocol. UI-agnostic.",
   "type": "module",
   "main": "./dist/index.js",