@oh-my-pi/pi-coding-agent 9.1.1 → 9.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "9.1.1",
+	"version": "9.2.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -74,17 +74,17 @@
 	"scripts": {
 		"check": "tsgo -p tsconfig.json",
 		"format-prompts": "bun scripts/format-prompts.ts",
-		"build:binary": "bun build --compile ./src/cli.ts --outfile dist/omp",
+		"build:binary": "cd ../.. && bun build --compile --define OMP_COMPILED=true --root . ./packages/coding-agent/src/cli.ts ./packages/natives/src/grep/worker.ts ./packages/natives/src/html/worker.ts ./packages/natives/src/image/worker.ts --outfile packages/coding-agent/dist/omp",
 		"generate-template": "bun scripts/generate-template.ts",
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "9.1.1",
-		"@oh-my-pi/pi-agent-core": "9.1.1",
-		"@oh-my-pi/pi-ai": "9.1.1",
-		"@oh-my-pi/pi-natives": "9.1.1",
-		"@oh-my-pi/pi-tui": "9.1.1",
-		"@oh-my-pi/pi-utils": "9.1.1",
+		"@oh-my-pi/omp-stats": "9.2.1",
+		"@oh-my-pi/pi-agent-core": "9.2.1",
+		"@oh-my-pi/pi-ai": "9.2.1",
+		"@oh-my-pi/pi-natives": "9.2.1",
+		"@oh-my-pi/pi-tui": "9.2.1",
+		"@oh-my-pi/pi-utils": "9.2.1",
 		"@openai/agents": "^0.4.4",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",
@@ -97,7 +97,6 @@
 		"nanoid": "^5.1.6",
 		"node-html-parser": "^7.0.2",
 		"smol-toml": "^1.6.0",
-		"strip-ansi": "^7.1.2",
 		"zod": "^4.3.6"
 	},
 	"devDependencies": {

package/src/cli/grep-cli.ts

@@ -0,0 +1,152 @@
+/**
+ * Grep CLI command handlers.
+ *
+ * Handles `omp grep` subcommand for testing grep tool on Windows.
+ */
+import * as path from "node:path";
+import { grep } from "@oh-my-pi/pi-natives";
+import chalk from "chalk";
+import { APP_NAME } from "../config";
+
+export interface GrepCommandArgs {
+	pattern: string;
+	path: string;
+	glob?: string;
+	limit: number;
+	context: number;
+	mode: "content" | "filesWithMatches" | "count";
+}
+
+/**
+ * Parse grep subcommand arguments.
+ * Returns undefined if not a grep command.
+ */
+export function parseGrepArgs(args: string[]): GrepCommandArgs | undefined {
+	if (args.length === 0 || args[0] !== "grep") {
+		return undefined;
+	}
+
+	const result: GrepCommandArgs = {
+		pattern: "",
+		path: ".",
+		limit: 20,
+		context: 2,
+		mode: "content",
+	};
+
+	const positional: string[] = [];
+
+	for (let i = 1; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--glob" || arg === "-g") {
+			result.glob = args[++i];
+		} else if (arg === "--limit" || arg === "-l") {
+			result.limit = parseInt(args[++i], 10);
+		} else if (arg === "--context" || arg === "-C") {
+			result.context = parseInt(args[++i], 10);
+		} else if (arg === "--files" || arg === "-f") {
+			result.mode = "filesWithMatches";
+		} else if (arg === "--count" || arg === "-c") {
+			result.mode = "count";
+		} else if (!arg.startsWith("-")) {
+			positional.push(arg);
+		}
+	}
+
+	if (positional.length >= 1) {
+		result.pattern = positional[0];
+	}
+	if (positional.length >= 2) {
+		result.path = positional[1];
+	}
+
+	return result;
+}
+
+export async function runGrepCommand(cmd: GrepCommandArgs): Promise<void> {
+	if (!cmd.pattern) {
+		console.error(chalk.red("Error: Pattern is required"));
+		process.exit(1);
+	}
+
+	const searchPath = path.resolve(cmd.path);
+	console.log(chalk.dim(`Searching in: ${searchPath}`));
+	console.log(chalk.dim(`Pattern: ${cmd.pattern}`));
+	console.log(chalk.dim(`Mode: ${cmd.mode}, Limit: ${cmd.limit}, Context: ${cmd.context}`));
+
+	console.log("");
+
+	try {
+		const result = await grep({
+			pattern: cmd.pattern,
+			path: searchPath,
+			glob: cmd.glob,
+			mode: cmd.mode,
+			maxCount: cmd.limit,
+			context: cmd.mode === "content" ? cmd.context : undefined,
+			hidden: true,
+		});
+
+		console.log(chalk.green(`Total matches: ${result.totalMatches}`));
+		console.log(chalk.green(`Files with matches: ${result.filesWithMatches}`));
+		console.log(chalk.green(`Files searched: ${result.filesSearched}`));
+		if (result.limitReached) {
+			console.log(chalk.yellow(`Limit reached: true`));
+		}
+		console.log("");
+
+		for (const match of result.matches) {
+			const displayPath = match.path.replace(/\\/g, "/");
+
+			if (cmd.mode === "content") {
+				if (match.contextBefore) {
+					for (const ctx of match.contextBefore) {
+						console.log(chalk.dim(`${displayPath}-${ctx.lineNumber}- ${ctx.line}`));
+					}
+				}
+				console.log(`${chalk.cyan(displayPath)}:${chalk.yellow(String(match.lineNumber))}: ${match.line}`);
+				if (match.contextAfter) {
+					for (const ctx of match.contextAfter) {
+						console.log(chalk.dim(`${displayPath}-${ctx.lineNumber}- ${ctx.line}`));
+					}
+				}
+				console.log("");
+			} else if (cmd.mode === "count") {
+				console.log(`${chalk.cyan(displayPath)}: ${match.matchCount ?? 0} matches`);
+			} else {
+				console.log(chalk.cyan(displayPath));
+			}
+		}
+	} catch (err) {
+		console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+		process.exit(1);
+	}
+}
+
+export function printGrepHelp(): void {
+	console.log(`${chalk.bold(`${APP_NAME} grep`)} - Test grep tool
+
+${chalk.bold("Usage:")}
+  ${APP_NAME} grep <pattern> [path] [options]
+
+${chalk.bold("Arguments:")}
+  pattern   Regex pattern to search for
+  path      Directory or file to search (default: .)
+
+${chalk.bold("Options:")}
+  -g, --glob <pattern>  Filter files by glob pattern
+  -l, --limit <n>       Max matches (default: 20)
+  -C, --context <n>     Context lines (default: 2)
+  -f, --files           Output file names only
+  -c, --count           Output match counts per file
+  -h, --help            Show this help
+
+${chalk.bold("Environment:")}
+  OMP_GREP_WORKERS=0    Disable worker pool (use single-threaded mode)
+
+${chalk.bold("Examples:")}
+  ${APP_NAME} grep "import" src/
+  ${APP_NAME} grep "TODO" . --glob "*.ts"
+  ${APP_NAME} grep "function" --files
+`);
+}

package/src/cli/stats-cli.ts

@@ -114,6 +114,7 @@ export async function runStatsCommand(cmd: StatsCommandArgs): Promise<void> {
 	Bun.spawn(openCommand === "cmd" ? ["cmd", "/c", "start", url] : [openCommand, url], {
 		stdout: "ignore",
 		stderr: "ignore",
+		windowsHide: true,
 	}).unref();
 
 	console.log("Press Ctrl+C to stop\n");

package/src/commit/git/operations.ts

@@ -37,6 +37,7 @@ export async function commit(cwd: string, message: string): Promise<GitResult> {
 		stdin: Buffer.from(message),
 		stdout: "pipe",
 		stderr: "pipe",
+		windowsHide: true,
 	});
 
 	const [stdout, stderr, exitCode] = await Promise.all([

package/src/config/settings-manager.ts

@@ -90,10 +90,12 @@ export interface ExaSettings {
 
 export type WebSearchProviderOption = "auto" | "exa" | "perplexity" | "anthropic";
 export type ImageProviderOption = "auto" | "gemini" | "openrouter";
+export type KimiApiFormatOption = "openai" | "anthropic";
 
 export interface ProviderSettings {
 	webSearch?: WebSearchProviderOption; // default: "auto" (exa > perplexity > anthropic)
 	image?: ImageProviderOption; // default: "auto" (openrouter > gemini)
+	kimiApiFormat?: KimiApiFormatOption; // default: "anthropic" (use Anthropic-compatible API for Kimi, more stable)
 }
 
 export interface BashInterceptorRule {
@@ -1349,6 +1351,19 @@ export class SettingsManager {
 		await this.save();
 	}
 
+	getKimiApiFormat(): KimiApiFormatOption {
+		return this.settings.providers?.kimiApiFormat ?? "anthropic";
+	}
+
+	async setKimiApiFormat(format: KimiApiFormatOption): Promise<void> {
+		if (!this.globalSettings.providers) {
+			this.globalSettings.providers = {};
+		}
+		this.globalSettings.providers.kimiApiFormat = format;
+		this.markModified("providers", "kimiApiFormat");
+		await this.save();
+	}
+
 	getBashInterceptorEnabled(): boolean {
 		return this.settings.bashInterceptor?.enabled ?? DEFAULT_BASH_INTERCEPTOR_SETTINGS.enabled;
 	}

package/src/debug/index.ts

@@ -310,7 +310,7 @@ export class DebugSelectorComponent extends Container {
 		const [cmd, ...args] = openArgs;
 
 		try {
-			Bun.spawn([cmd, ...args], { stdout: "ignore", stderr: "ignore" }).unref();
+			Bun.spawn([cmd, ...args], { stdout: "ignore", stderr: "ignore", windowsHide: true }).unref();
 			this.ctx.showStatus(`Opened: ${artifactsDir}`);
 		} catch (err) {
 			this.ctx.showError(`Failed to open artifact folder: ${err instanceof Error ? err.message : String(err)}`);

package/src/extensibility/plugins/installer.ts

@@ -50,6 +50,7 @@ export async function installPlugin(packageName: string): Promise<InstalledPlugi
 		stdin: "ignore",
 		stdout: "pipe",
 		stderr: "pipe",
+		windowsHide: true,
 	});
 
 	const exitCode = await proc.exited;
@@ -91,6 +92,7 @@ export async function uninstallPlugin(name: string): Promise<void> {
 		stdin: "ignore",
 		stdout: "pipe",
 		stderr: "pipe",
+		windowsHide: true,
 	});
 
 	const exitCode = await proc.exited;

package/src/extensibility/plugins/manager.ts

@@ -159,6 +159,7 @@ export class PluginManager {
 			stdin: "ignore",
 			stdout: "pipe",
 			stderr: "pipe",
+			windowsHide: true,
 		});
 
 		const exitCode = await proc.exited;
@@ -239,6 +240,7 @@ export class PluginManager {
 			stdin: "ignore",
 			stdout: "pipe",
 			stderr: "pipe",
+			windowsHide: true,
 		});
 
 		const exitCode = await proc.exited;
@@ -621,6 +623,7 @@ export class PluginManager {
 				stdin: "ignore",
 				stdout: "pipe",
 				stderr: "pipe",
+				windowsHide: true,
 			});
 			return (await proc.exited) === 0;
 		} catch {

package/src/ipy/gateway-coordinator.ts

@@ -420,6 +420,7 @@ async function startGatewayProcess(
 			stdout: "pipe",
 			stderr: "pipe",
 			detached: true,
+			windowsHide: true,
 			env: kernelEnv,
 		},
 	);

package/src/lsp/clients/biome-client.ts

@@ -86,6 +86,7 @@ async function runBiome(
 			cwd,
 			stdout: "pipe",
 			stderr: "pipe",
+			windowsHide: true,
 		});
 
 		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);

package/src/lsp/index.ts

@@ -437,6 +437,7 @@ async function runWorkspaceDiagnostics(
 			cwd,
 			stdout: "pipe",
 			stderr: "pipe",
+			windowsHide: true,
 		});
 
 		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);

package/src/lsp/lspmux.ts

@@ -104,6 +104,7 @@ async function checkServerRunning(binaryPath: string): Promise<boolean> {
 		const proc = Bun.spawn([binaryPath, "status"], {
 			stdout: "pipe",
 			stderr: "pipe",
+			windowsHide: true,
 		});
 
 		const exited = await Promise.race([

package/src/lsp/render.ts

@@ -306,6 +306,8 @@ function highlightCode(codeText: string, language: string, theme: Theme): string
 			type: theme.getFgAnsi("syntaxType"),
 			operator: theme.getFgAnsi("syntaxOperator"),
 			punctuation: theme.getFgAnsi("syntaxPunctuation"),
+			inserted: theme.getFgAnsi("toolDiffAdded"),
+			deleted: theme.getFgAnsi("toolDiffRemoved"),
 		};
 		return nativeHighlightCode(codeText, validLang, colors).split("\n");
 	} catch {

package/src/main.ts

@@ -14,6 +14,7 @@ import chalk from "chalk";
 import { type Args, parseArgs, printHelp } from "./cli/args";
 import { parseConfigArgs, printConfigHelp, runConfigCommand } from "./cli/config-cli";
 import { processFileArguments } from "./cli/file-processor";
+import { parseGrepArgs, printGrepHelp, runGrepCommand } from "./cli/grep-cli";
 import { parseJupyterArgs, printJupyterHelp, runJupyterCommand } from "./cli/jupyter-cli";
 import { listModels } from "./cli/list-models";
 import { parsePluginArgs, printPluginHelp, runPluginCommand } from "./cli/plugin-cli";
@@ -553,6 +554,17 @@ export async function main(args: string[]) {
 		return;
 	}
 
+	// Handle grep subcommand (for testing grep tool)
+	const grepCmd = parseGrepArgs(args);
+	if (grepCmd) {
+		if (args.includes("--help") || args.includes("-h")) {
+			printGrepHelp();
+			return;
+		}
+		await runGrepCommand(grepCmd);
+		return;
+	}
+
 	// Handle commit subcommand
 	const commitCmd = parseCommitArgs(args);
 	if (commitCmd) {

package/src/modes/components/bash-execution.ts

@@ -2,7 +2,6 @@
  * Component for displaying bash command execution with streaming output.
  */
 import { Container, Loader, Spacer, Text, type TUI } from "@oh-my-pi/pi-tui";
-import stripAnsi from "strip-ansi";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import type { TruncationMeta } from "../../tools/output-meta";
 import { formatSize } from "../../tools/truncate";
@@ -188,7 +187,7 @@ export class BashExecutionComponent extends Container {
 	private normalizeOutput(text: string): string {
 		// Strip ANSI codes and normalize line endings
 		// Note: binary data is already sanitized in tui-renderer.ts executeBashCommand
-		return stripAnsi(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+		return Bun.stripANSI(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 	}
 
 	private setOutput(output: string): void {

package/src/modes/components/python-execution.ts

@@ -3,7 +3,6 @@
  * Shares the same kernel session as the agent's Python tool.
  */
 import { Container, Loader, Spacer, Text, type TUI } from "@oh-my-pi/pi-tui";
-import stripAnsi from "strip-ansi";
 import { getSymbolTheme, highlightCode, theme } from "../../modes/theme/theme";
 import type { TruncationMeta } from "../../tools/output-meta";
 import { formatSize } from "../../tools/truncate";
@@ -172,7 +171,7 @@ export class PythonExecutionComponent extends Container {
 	}
 
 	private normalizeOutput(text: string): string {
-		return stripAnsi(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+		return Bun.stripANSI(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 	}
 
 	private setOutput(output: string): void {

package/src/modes/components/settings-defs.ts

@@ -11,6 +11,7 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { TERMINAL_INFO } from "@oh-my-pi/pi-tui";
 import type {
 	ImageProviderOption,
+	KimiApiFormatOption,
 	NotificationMethod,
 	PythonKernelMode,
 	PythonToolMode,
@@ -416,6 +417,19 @@ export const SETTINGS_DEFS: SettingDef[] = [
 			{ value: "openrouter", label: "OpenRouter", description: "Use OpenRouter (requires OPENROUTER_API_KEY)" },
 		],
 	},
+	{
+		id: "kimiApiFormat",
+		tab: "tools",
+		type: "submenu",
+		label: "Kimi API format",
+		description: "API format for Kimi Code provider",
+		get: sm => sm.getKimiApiFormat(),
+		set: (sm, v) => sm.setKimiApiFormat(v as KimiApiFormatOption),
+		getOptions: () => [
+			{ value: "openai", label: "OpenAI", description: "Use OpenAI-compatible API (api.kimi.com)" },
+			{ value: "anthropic", label: "Anthropic", description: "Use Anthropic-compatible API (api.moonshot.ai)" },
+		],
+	},
 
 	// ═══════════════════════════════════════════════════════════════════════════
 	// Display tab - Visual/UI settings

package/src/modes/theme/theme.ts

@@ -2049,6 +2049,8 @@ function getHighlightColors(t: Theme): NativeHighlightColors {
 			type: t.getFgAnsi("syntaxType"),
 			operator: t.getFgAnsi("syntaxOperator"),
 			punctuation: t.getFgAnsi("syntaxPunctuation"),
+			inserted: t.getFgAnsi("toolDiffAdded"),
+			deleted: t.getFgAnsi("toolDiffRemoved"),
 		};
 	}
 	return cachedHighlightColors;

package/src/prompts/tools/find.md

@@ -3,7 +3,8 @@
 Fast file pattern matching that works with any codebase size.
 
 <instruction>
-- Supports glob patterns like `**/*.js` or `src/**/*.ts`
+- Pattern includes the search path: `src/**/*.ts`, `lib/*.json`, `**/*.md`
+- Simple patterns like `*.ts` automatically search recursively from cwd
 - Includes hidden files by default (use `hidden: false` to exclude)
 - Speculatively perform multiple searches in parallel when potentially useful
 </instruction>

package/src/sdk.ts

@@ -1115,6 +1115,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		followUpMode: settingsManager.getFollowUpMode(),
 		interruptMode: settingsManager.getInterruptMode(),
 		thinkingBudgets: settingsManager.getThinkingBudgets(),
+		kimiApiFormat: settingsManager.getKimiApiFormat(),
 		getToolContext: tc => toolContextStore.getContext(tc),
 		getApiKey: async () => {
 			const currentModel = agent.state.model;

package/src/tools/find.ts

@@ -22,8 +22,7 @@ import { toolResult } from "./tool-result";
 import { type TruncationResult, truncateHead } from "./truncate";
 
 const findSchema = Type.Object({
-	pattern: Type.String({ description: "Glob pattern, e.g. '*.ts', '**/*.json'" }),
-	path: Type.Optional(Type.String({ description: "Directory to search (default: cwd)" })),
+	pattern: Type.String({ description: "Glob pattern, e.g. '*.ts', 'src/**/*.json', 'lib/*.tsx'" }),
 	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files and directories (default: true)" })),
 	limit: Type.Optional(Type.Number({ description: "Max results (default: 1000)" })),
 });
@@ -31,6 +30,51 @@ const findSchema = Type.Object({
 const DEFAULT_LIMIT = 1000;
 const GLOB_TIMEOUT_MS = 5000;
 
+/**
+ * Parse a pattern to extract the base directory path and glob pattern.
+ * Examples:
+ *   "src/app/**\/*.tsx" → { basePath: "src/app", globPattern: "**\/*.tsx" }
+ *   "src/app/*.tsx" → { basePath: "src/app", globPattern: "*.tsx" }
+ *   "*.ts" → { basePath: ".", globPattern: "**\/*.ts" }
+ *   "**\/*.json" → { basePath: ".", globPattern: "**\/*.json" }
+ *   "/abs/path/**\/*.ts" → { basePath: "/abs/path", globPattern: "**\/*.ts" }
+ */
+function parsePatternPath(pattern: string): { basePath: string; globPattern: string } {
+	// Find the first segment containing glob characters
+	const segments = pattern.split("/");
+	const globChars = ["*", "?", "[", "{"];
+
+	let firstGlobIndex = -1;
+	for (let i = 0; i < segments.length; i++) {
+		if (globChars.some(c => segments[i].includes(c))) {
+			firstGlobIndex = i;
+			break;
+		}
+	}
+
+	// No glob characters found - treat as literal path with implicit **/*
+	if (firstGlobIndex === -1) {
+		// Pattern is a directory path like "src/app" - search recursively in it
+		return { basePath: pattern, globPattern: "**/*" };
+	}
+
+	// Glob starts at first segment - no base path
+	if (firstGlobIndex === 0) {
+		// Simple pattern like "*.ts" needs **/ prefix for recursive search
+		const needsRecursive = !pattern.startsWith("**/");
+		return {
+			basePath: ".",
+			globPattern: needsRecursive ? `**/${pattern}` : pattern,
+		};
+	}
+
+	// Split at the glob boundary
+	const basePath = segments.slice(0, firstGlobIndex).join("/");
+	const globPattern = segments.slice(firstGlobIndex).join("/");
+
+	return { basePath, globPattern };
+}
+
 export interface FindToolDetails {
 	truncation?: TruncationResult;
 	resultLimitReached?: number;
@@ -81,10 +125,19 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 		_onUpdate?: AgentToolUpdateCallback<FindToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<FindToolDetails>> {
-		const { pattern, path: searchDir, limit, hidden } = params;
+		const { pattern, limit, hidden } = params;
 
 		return untilAborted(signal, async () => {
-			const searchPath = resolveToCwd(searchDir || ".", this.session.cwd);
+			// Parse pattern to extract base directory and glob pattern
+			// e.g., "src/app/**/*.tsx" → basePath: "src/app", globPattern: "**/*.tsx"
+			// e.g., "*.ts" → basePath: ".", globPattern: "**/*.ts"
+			const normalizedPattern = pattern.trim().replace(/\\/g, "/");
+			if (!normalizedPattern) {
+				throw new ToolError("Pattern must not be empty");
+			}
+
+			const { basePath, globPattern } = parsePatternPath(normalizedPattern);
+			const searchPath = resolveToCwd(basePath, this.session.cwd);
 
 			if (searchPath === "/") {
 				throw new ToolError("Searching from root directory '/' is not allowed");
@@ -94,10 +147,6 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				const relative = path.relative(this.session.cwd, searchPath).replace(/\\/g, "/");
 				return relative.length === 0 ? "." : relative;
 			})();
-			const normalizedPattern = pattern.trim();
-			if (!normalizedPattern) {
-				throw new ToolError("Pattern must not be empty");
-			}
 
 			const rawLimit = limit ?? DEFAULT_LIMIT;
 			const effectiveLimit = Number.isFinite(rawLimit) ? Math.floor(rawLimit) : Number.NaN;
@@ -105,7 +154,6 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				throw new ToolError("Limit must be a positive number");
 			}
 			const includeHidden = hidden ?? true;
-			const globPattern = normalizedPattern.replace(/\\/g, "/");
 
 			// If custom operations provided with glob, use that instead of fd
 			if (this.customOps?.glob) {
@@ -113,7 +161,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					throw new ToolError(`Path not found: ${searchPath}`);
 				}
 
-				const results = await this.customOps.glob(normalizedPattern, searchPath, {
+				const results = await this.customOps.glob(globPattern, searchPath, {
 					ignore: ["**/node_modules/**", "**/.git/**"],
 					limit: effectiveLimit,
 				});
@@ -279,8 +327,6 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 
 interface FindRenderArgs {
 	pattern: string;
-	path?: string;
-	sortByMtime?: boolean;
 	limit?: number;
 }
 
@@ -290,8 +336,6 @@ export const findToolRenderer = {
 	inline: true,
 	renderCall(args: FindRenderArgs, uiTheme: Theme): Component {
 		const meta: string[] = [];
-		if (args.path) meta.push(`in ${args.path}`);
-		if (args.sortByMtime) meta.push("sort:mtime");
 		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
 
 		const text = renderStatusLine(

package/src/utils/clipboard.ts

@@ -37,25 +37,33 @@ export async function copyToClipboard(text: string): Promise<void> {
 
 	try {
 		if (p === "darwin") {
-			await Bun.spawn(["pbcopy"], { stdin: Buffer.from(text), timeout }).exited;
+			await Bun.spawn(["pbcopy"], { stdin: Buffer.from(text), timeout, windowsHide: true }).exited;
 		} else if (p === "win32") {
-			await Bun.spawn(["clip"], { stdin: Buffer.from(text), timeout }).exited;
+			await Bun.spawn(["clip"], { stdin: Buffer.from(text), timeout, windowsHide: true }).exited;
 		} else {
 			const wayland = isWaylandSession();
 			if (wayland) {
 				const wlCopyPath = Bun.which("wl-copy");
 				if (wlCopyPath) {
 					// Fire-and-forget: wl-copy may not exit promptly, so we unref to avoid blocking
-					void Bun.spawn([wlCopyPath], { stdin: Buffer.from(text), timeout }).unref();
+					void Bun.spawn([wlCopyPath], { stdin: Buffer.from(text), timeout, windowsHide: true }).unref();
 					return;
 				}
 			}
 
 			// Linux - try xclip first, fall back to xsel
 			try {
-				await Bun.spawn(["xclip", "-selection", "clipboard"], { stdin: Buffer.from(text), timeout }).exited;
+				await Bun.spawn(["xclip", "-selection", "clipboard"], {
+					stdin: Buffer.from(text),
+					timeout,
+					windowsHide: true,
+				}).exited;
 			} catch {
-				await Bun.spawn(["xsel", "--clipboard", "--input"], { stdin: Buffer.from(text), timeout }).exited;
+				await Bun.spawn(["xsel", "--clipboard", "--input"], {
+					stdin: Buffer.from(text),
+					timeout,
+					windowsHide: true,
+				}).exited;
 			}
 		}
 	} catch (error) {