blun-king-cli 9.1.228 → 9.1.230

package/bin/bash-search-scope-policy.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+function normalizePath(value) {
+  return String(value || '').trim().replaceAll('\\', '/').replace(/\/+$/u, '').toLowerCase();
+}
+
+function windowsBashPath(value) {
+  const normalized = normalizePath(value);
+  const match = normalized.match(/^([a-z]):(\/.*)$/u);
+  return match ? `/${match[1]}${match[2]}` : normalized;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+
+function findTargetsWholeHome(command, homeDir, isWindowsBash) {
+  const normalizedHome = normalizePath(homeDir);
+  if (!normalizedHome) return false;
+  const homes = new Set([normalizedHome, '~', '$home']);
+  if (isWindowsBash) homes.add(windowsBashPath(normalizedHome));
+  return [...homes].some((home) => {
+    const target = escapeRegExp(home);
+    return new RegExp(`(?:^|[;&|]\\s*)find\\s+(?:["']?)${target}(?=["'\\s;|&]|$)`, 'iu').test(command);
+  });
+}
+
+function recursiveGrepTargetsDot(command) {
+  const segments = String(command || '').split(/(?:&&|\|\||[;\n])/u);
+  return segments.some((segment) => {
+    const match = segment.match(/^\s*grep\s+(.+)$/iu);
+    if (!match) return false;
+    const args = match[1];
+    if (!/(?:^|\s)-[^\s]*[rR][^\s]*(?=\s|$)/u.test(args)) return false;
+    return /(?:^|\s)["']?\.["']?(?=\s|$)/u.test(args);
+  });
+}
+
+function broadRecursiveSearchRefusal({ command, homeDir, isWindowsBash = false }) {
+  if (findTargetsWholeHome(String(command || ''), homeDir, isWindowsBash)) {
+    return 'Refused broad recursive search over the whole user home before execution. Use Glob with an anchored filename pattern, or narrow Bash find to a known project directory.';
+  }
+  if (recursiveGrepTargetsDot(command)) {
+    return 'Refused broad recursive grep against dot before execution. Use Grep with a path/glob filter, or narrow Bash grep to explicit project subdirectories.';
+  }
+  return undefined;
+}
+
+module.exports = { broadRecursiveSearchRefusal };

package/bin/write-continuation-policy.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+function resolveWriteContinuationContract({ continuation, current, mode }) {
+  const expectedPart = current === undefined ? 1 : current.chunks.length + 1;
+  const expectedStartLine = (current?.completedLines ?? 0) + 1;
+
+  return {
+    expectedPart,
+    expectedStartLine,
+    part: continuation.part ?? expectedPart,
+    startLine: continuation.start_line ?? expectedStartLine,
+    mode: mode ?? (expectedPart === 1 ? 'overwrite' : 'append'),
+    final: continuation.final === true,
+    expectedLines: continuation.expected_lines ?? current?.expectedLines,
+  };
+}
+
+module.exports = {
+  resolveWriteContinuationContract,
+};

package/blun.mjs

@@ -259581,7 +259581,7 @@ var init_write$1 = __esmMin((() => {
 }));
 //#endregion
 write_default = "Create, append to, or completely replace a file. Missing parent directories are created automatically. Overwrite is the default; append adds content at EOF without adding a newline.\n\nUse Write for a new file or a complete replacement. For every incremental change to an existing file, Use Edit instead, even when it is small. Read before overwriting an existing file. Do not create unsolicited documentation, README, summary, or report files unless the user or project instructions require them.\n\nContent is written literally. Never include Read/Edit line prefixes. Supplied LF and CRLF endings are preserved. Source files may contain at most 500 lines; split larger implementations into focused files. Set `single_file_override=true` only when the latest direct user message explicitly requires one source file.\n\nFor a new or completely replaced file too large for one call, use `continuation`. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Set exact `expected_lines` and, when available, `expected_sha256`. Part 1 uses overwrite, `part=1`, and `start_line=1`; every later part uses append, the next consecutive part, and the exact `next_start_line` returned by Write. Set `final=true` only on the complete final part. The Target file remains unchanged until final line-count and optional SHA-256 checks pass. Restart an unfinished sequence only with part 1, overwrite, `start_line=1`, and `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
-write_default = "Create, append to, or replace a whole file. Missing parent directories are created automatically. Overwrite is default; append adds content at EOF without a newline.\n\nUse Write only for new files or complete replacements. Use Edit for every incremental change, even a small one. Read before overwriting an existing file. Do not create unsolicited documentation unless the user or project instructions require it.\n\nContent is literal. Never include line prefixes. Supplied LF and CRLF endings are preserved. Source files may contain at most 500 lines; split larger implementations into focused files. Set `single_file_override=true` only when the latest direct user message explicitly requires one source file.\n\nFor a new or completely replaced file too large for one call, use `continuation`. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Set exact `expected_lines` and, when available, `expected_sha256`. Part 1 uses overwrite, `part=1`, and `start_line=1`; every later part uses append, the next consecutive part, and the exact `next_start_line` returned by Write. Set `final=true` only on the complete final part. The Target file remains unchanged until final line-count and optional SHA-256 checks pass. Restart an unfinished sequence only with part 1, overwrite, `start_line=1`, and `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
+write_default = "Create, append to, or replace a whole file. Missing parent directories are created automatically. Overwrite is default; append adds content at EOF without a newline.\n\nUse Write only for new files or complete replacements. Use Edit for every incremental change, even a small one. Read before overwriting an existing file. Do not create unsolicited documentation unless the user or project instructions require it.\n\nContent is literal. Never include line prefixes. Supplied LF and CRLF endings are preserved. Source files may contain at most 500 lines; split larger implementations into focused files. Set `single_file_override=true` only when the latest direct user message explicitly requires one source file.\n\nFor a new or completely replaced file too large for one call, use `continuation`. Keep each chunk within the configured UTF-8 bytes limit and end it on a complete line with `\\n`. Optionally set exact `expected_lines` and, when available, `expected_sha256`. Part number, start line, and mode are derived from actually staged content when omitted. Set `final=true` only on the complete final part. The Target file remains unchanged until final line-count and optional SHA-256 checks pass. Restart an unfinished sequence with `reset=true`. Never use continuation for incremental edits.\n\nRunaway generated JavaScript or TypeScript identifiers are rejected before disk I/O; regenerate only the affected section as a smaller chunk.";
 //#region ../../packages/agent-core/src/tools/builtin/file/generated-source-health.ts
 /**
 * Find runaway generated identifiers while ignoring comments and strings.
@@ -259704,7 +259704,7 @@ function countCompletedLines(content) {
 	for (const character of content) if (character === "\n") count += 1;
 	return count;
 }
-var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool;
+var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool, resolveWriteContinuationContract;
 var init_write = __esmMin((() => {
 	init_dist$6();
 	init_zod$1();
@@ -259716,6 +259716,7 @@ var init_write = __esmMin((() => {
 	init_write$1();
 	init_generated_source_health();
 	init_lsp_diagnostics();
+	({ resolveWriteContinuationContract } = createRequire(import.meta.url)("./bin/write-continuation-policy.cjs"));
 	S_IFMT = 61440;
 	S_IFDIR = 16384;
 	DEFAULT_CONTINUATION_CHUNK_BYTES = 2048;
@@ -259723,17 +259724,17 @@ var init_write = __esmMin((() => {
 	MAX_CONTINUATION_CHUNK_BYTES = 16384;
 	CONTINUATION_CHUNK_BYTES_ENV = "BLUN_WRITE_CONTINUATION_MAX_BYTES";
 	WriteContinuationSchema = object({
-		part: number$1().int().positive().describe("One-based chunk number. Start with 1 and increment by exactly one."),
-		start_line: number$1().int().positive().describe("One-based line where this chunk starts. Use 1 for part 1; for every later part, copy next_start_line from the preceding tool result instead of using a planned boundary."),
-		expected_lines: number$1().int().positive().describe("Exact completed-line count expected in the final file."),
-		final: boolean$1().describe("Set true only for the last chunk, when the complete file is present."),
+		part: number$1().int().positive().optional().describe("Optional one-based chunk number. When omitted, the runtime derives the next part from actually staged content."),
+		start_line: number$1().int().positive().optional().describe("Optional one-based start line. When omitted, the runtime derives it from actually staged content."),
+		expected_lines: number$1().int().positive().optional().describe("Optional exact completed-line count for final verification. It may first be supplied on the final part."),
+		final: boolean$1().optional().describe("Set true only for the last chunk, when the complete file is present. Omitted means false."),
 		expected_sha256: string().regex(/^[0-9a-f]{64}$/i).optional().describe("Optional SHA-256 of the complete expected file for byte-for-byte verification."),
 		reset: boolean$1().optional().describe("Set true only with part 1 and overwrite to discard an unfinished staged write.")
 	});
 	WriteInputSchema = object({
 		path: string().describe("Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Missing parent directories are created automatically."),
 		content: string().describe("Raw full file content to write exactly as provided. This does not use the Read/Edit text view."),
-		mode: _enum(["overwrite", "append"]).optional().describe("Write mode. Defaults to overwrite. append adds content to the end exactly as provided and does not add a newline."),
+		mode: _enum(["overwrite", "append"]).optional().describe("Write mode. Outside continuation it defaults to overwrite; continuation derives overwrite for part 1 and append for later parts when omitted."),
 		single_file_override: boolean$1().optional().describe("Set true only when the latest direct user message explicitly requires one single source file. The tool verifies that request and reports the override visibly."),
 		continuation: WriteContinuationSchema.optional().describe("Safe long-write protocol. Split generated files into complete-line chunks within the configured limit (2,048 UTF-8 bytes by default; operator override BLUN_WRITE_CONTINUATION_MAX_BYTES). Part 1 uses overwrite and start_line=1; later parts use append and the exact next_start_line returned by the previous call. The target file is changed only after the final line-count and optional SHA-256 checks pass.")
 	});
@@ -259792,89 +259793,94 @@ bytesWritten: number$1().int().nonnegative() });
 		async continueWrite(args, safePath, ctx) {
 			const continuation = args.continuation;
 			if (continuation === void 0) throw new Error("continuation is required");
-			const mode = args.mode ?? "overwrite";
+			const initialPart = continuation.part ?? (this.pendingContinuations.get(safePath)?.chunks.length ?? 0) + 1;
 			const chunkBytes = Buffer.byteLength(args.content, "utf8");
 			if (chunkBytes > this.maxContinuationChunkBytes) return {
 				isError: true,
-				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: chunks may contain at most ${this.maxContinuationChunkBytes.toLocaleString("en-US")} UTF-8 bytes (${String(chunkBytes)} received). No content was staged and no file was written.`
+				output: `Refused continuation part ${String(initialPart)} for ${args.path}: chunks may contain at most ${this.maxContinuationChunkBytes.toLocaleString("en-US")} UTF-8 bytes (${String(chunkBytes)} received). No content was staged and no file was written.`
 			};
 			if (args.content.length === 0 || !args.content.endsWith("\n")) return {
 				isError: true,
-				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: every chunk must end on a complete line with a newline. No content was staged and no file was written.`
+				output: `Refused continuation part ${String(initialPart)} for ${args.path}: every chunk must end on a complete line with a newline. No content was staged and no file was written.`
 			};
-			if (continuation.reset === true && (continuation.part !== 1 || mode !== "overwrite")) return {
+			if (continuation.reset === true && (continuation.part !== void 0 && continuation.part !== 1 || args.mode !== void 0 && args.mode !== "overwrite")) return {
 				isError: true,
 				output: `Refused continuation reset for ${args.path}: reset requires part 1 with mode=overwrite. No content was staged and no file was written.`
 			};
 			if (continuation.reset === true) this.pendingContinuations.delete(safePath);
 			const current = this.pendingContinuations.get(safePath);
-			const expectedPart = current === void 0 ? 1 : current.chunks.length + 1;
-			if (continuation.part !== expectedPart) return {
+			const contract = resolveWriteContinuationContract({
+				continuation,
+				current,
+				mode: args.mode
+			});
+			const { expectedPart, expectedStartLine, part, startLine, mode, final, expectedLines } = contract;
+			if (part !== expectedPart) return {
 				isError: true,
-				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected part ${String(expectedPart)}. No content was staged and no file was written.`
+				output: `Refused continuation part ${String(part)} for ${args.path}: expected part ${String(expectedPart)}. No content was staged and no file was written.`
 			};
-			const expectedStartLine = (current?.completedLines ?? 0) + 1;
-			if (continuation.start_line !== expectedStartLine) return {
+			if (startLine !== expectedStartLine) return {
 				isError: true,
-				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected start_line ${String(expectedStartLine)} from the actually staged content, received ${String(continuation.start_line)}. No content was staged and no file was written.`
+				output: `Refused continuation part ${String(part)} for ${args.path}: expected start_line ${String(expectedStartLine)} from the actually staged content, received ${String(startLine)}. No content was staged and no file was written.`
 			};
-			if (continuation.part === 1 && mode !== "overwrite" || continuation.part > 1 && mode !== "append") return {
+			if (part === 1 && mode !== "overwrite" || part > 1 && mode !== "append") return {
 				isError: true,
-				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: part 1 must use overwrite and later parts must use append. No content was staged and no file was written.`
+				output: `Refused continuation part ${String(part)} for ${args.path}: part 1 must use overwrite and later parts must use append. No content was staged and no file was written.`
 			};
-			if (current !== void 0 && continuation.expected_lines !== current.expectedLines) return {
+			if (current?.expectedLines !== void 0 && continuation.expected_lines !== void 0 && continuation.expected_lines !== current.expectedLines) return {
 				isError: true,
-				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected_lines changed from ${String(current.expectedLines)} to ${String(continuation.expected_lines)}. No content was staged and no file was written.`
+				output: `Refused continuation part ${String(part)} for ${args.path}: expected_lines changed from ${String(current.expectedLines)} to ${String(continuation.expected_lines)}. No content was staged and no file was written.`
 			};
 			const expectedSha256 = continuation.expected_sha256?.toLowerCase();
 			if (current?.expectedSha256 !== void 0 && expectedSha256 !== void 0 && expectedSha256 !== current.expectedSha256) return {
 				isError: true,
-				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected_sha256 changed between parts. No content was staged and no file was written.`
+				output: `Refused continuation part ${String(part)} for ${args.path}: expected_sha256 changed between parts. No content was staged and no file was written.`
 			};
 			const chunkLines = countCompletedLines(args.content);
 			const completedBefore = current?.completedLines ?? 0;
 			const completedLines = completedBefore + chunkLines;
-			if (completedLines > continuation.expected_lines) return {
+			if (expectedLines !== void 0 && completedLines > expectedLines) return {
 				isError: true,
-				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: it would stage ${String(completedLines)} lines, exceeding the expected ${String(continuation.expected_lines)}. No content was staged and no file was written.`
+				output: `Refused continuation part ${String(part)} for ${args.path}: it would stage ${String(completedLines)} lines, exceeding the expected ${String(expectedLines)}. No content was staged and no file was written.`
 			};
-			if (!continuation.final && completedLines === continuation.expected_lines) return {
+			if (!final && expectedLines !== void 0 && completedLines === expectedLines) return {
 				isError: true,
-				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: all ${String(completedLines)} expected lines are present but final is false. Retry this part with final=true. No content was staged and no file was written.`
+				output: `Refused continuation part ${String(part)} for ${args.path}: all ${String(completedLines)} expected lines are present but final is false. Retry this part with final=true. No content was staged and no file was written.`
 			};
-			if (continuation.final && completedLines !== continuation.expected_lines) return {
+			if (final && expectedLines !== void 0 && completedLines !== expectedLines) return {
 				isError: true,
-				output: `Refused final continuation part ${String(continuation.part)} for ${args.path}: expected ${String(continuation.expected_lines)} lines but would have ${String(completedLines)}. No content was staged and no file was written.`
+				output: `Refused final continuation part ${String(part)} for ${args.path}: expected ${String(expectedLines)} lines but would have ${String(completedLines)}. No content was staged and no file was written.`
 			};
-			const startLine = completedBefore + 1;
-			const boundary = `${String(startLine)}-${String(completedLines)}`;
+			const actualStartLine = completedBefore + 1;
+			const boundary = `${String(actualStartLine)}-${String(completedLines)}`;
 			const chunks = [...current?.chunks ?? [], args.content];
 			const boundaries = [...current?.boundaries ?? [], boundary];
 			const totalBytes = (current?.bytes ?? 0) + chunkBytes;
 			const stableExpectedSha256 = current?.expectedSha256 ?? expectedSha256;
 			const staged = {
-				expectedLines: continuation.expected_lines,
+				expectedLines,
 				expectedSha256: stableExpectedSha256,
 				chunks,
 				boundaries,
 				completedLines,
 				bytes: totalBytes
 			};
-			const percent = Math.floor(completedLines / continuation.expected_lines * 100);
+			const percent = expectedLines === void 0 ? void 0 : Math.floor(completedLines / expectedLines * 100);
 			ctx?.onUpdate?.({
 				kind: "progress",
-				text: `Write continuation ${String(continuation.part)}: lines ${boundary}`,
-				percent
+				text: `Write continuation ${String(part)}: lines ${boundary}`,
+				...percent === void 0 ? {} : { percent }
 			});
-			if (!continuation.final) {
+			if (!final) {
 				this.pendingContinuations.set(safePath, staged);
-				return { output: `Write continuation part ${String(continuation.part)} staged lines ${boundary} of ${String(continuation.expected_lines)} (${String(percent)}%, ${String(chunkBytes)} bytes). Target unchanged. Continue with mode=append, part=${String(continuation.part + 1)}, next_start_line=${String(completedLines + 1)}.` };
+				const progress = expectedLines === void 0 ? `${String(completedLines)} lines staged; final count not predeclared` : `${String(completedLines)} of ${String(expectedLines)} lines (${String(percent)}%)`;
+				return { output: `Write continuation part ${String(part)} staged lines ${boundary} (${progress}, ${String(chunkBytes)} bytes). Target unchanged. Continue with the next chunk; mode=append, part=${String(part + 1)}, and start_line=${String(completedLines + 1)} are inferred when omitted.` };
 			}
 			const content = chunks.join("");
 			const actualSha256 = createHash("sha256").update(content).digest("hex");
 			if (stableExpectedSha256 !== void 0 && actualSha256 !== stableExpectedSha256) return {
 				isError: true,
-				output: `Refused final continuation part ${String(continuation.part)} for ${args.path}: SHA-256 mismatch (expected ${stableExpectedSha256}, got ${actualSha256}). No file was written; the first ${String(current?.completedLines ?? 0)} staged lines remain available for retry.`
+				output: `Refused final continuation part ${String(part)} for ${args.path}: SHA-256 mismatch (expected ${stableExpectedSha256}, got ${actualSha256}). No file was written; the first ${String(current?.completedLines ?? 0)} staged lines remain available for retry.`
 			};
 			const result = await this.writeContent({
 				...args,
@@ -262713,7 +262719,7 @@ function windowsPathToPosixPath(path) {
 function rewriteWindowsNullRedirect(command) {
 	return command.replace(WINDOWS_NUL_REDIRECT, "$1/dev/null");
 }
-var MS_PER_SECOND, DEFAULT_TIMEOUT_S, MAX_TIMEOUT_S, DEFAULT_BACKGROUND_TIMEOUT_S, MAX_BACKGROUND_TIMEOUT_S, USER_INTERRUPT_REASON, BashInputSchema, SHELL_TIMEOUT_VARS, BashTool, WINDOWS_NUL_REDIRECT;
+var MS_PER_SECOND, DEFAULT_TIMEOUT_S, MAX_TIMEOUT_S, DEFAULT_BACKGROUND_TIMEOUT_S, MAX_BACKGROUND_TIMEOUT_S, USER_INTERRUPT_REASON, BashInputSchema, SHELL_TIMEOUT_VARS, BashTool, WINDOWS_NUL_REDIRECT, broadRecursiveSearchRefusal;
 var init_bash = __esmMin((() => {
 	init_zod$1();
 	init_background();
@@ -262722,6 +262728,7 @@ var init_bash = __esmMin((() => {
 	init_rule_match();
 	init_result_builder();
 	init_bash$1();
+	({ broadRecursiveSearchRefusal } = createRequire(import.meta.url)("./bin/bash-search-scope-policy.cjs"));
 	MS_PER_SECOND = 1e3;
 	DEFAULT_TIMEOUT_S = 60;
 	MAX_TIMEOUT_S = 300;
@@ -262758,7 +262765,7 @@ var init_bash = __esmMin((() => {
 		MAX_TIMEOUT_S,
 		MAX_BACKGROUND_TIMEOUT_S
 	};
-	bash_default = "Execute a `{{ SHELL_NAME }}` command for pipes, environment variables, processes, git, package managers, build or test runners, and other genuine shell semantics.\n\nPrefer the dedicated tools when they fit: `Read` for a known file, `Write` to create or replace a file, `Edit` for exact changes, `Glob` to locate files, and `Grep` to search contents. Their output is bounded and their permissions are clearer.\n\nStdout and stderr are combined. Long foreground output is streamed to a private file; capture stops at a safe size while the command continues to its real exit code. A non-zero command ends with its exit code; timeouts and user interrupts are reported separately.\n\nEach call runs in a fresh shell environment. Variables, `cd`, and shell history do not carry into later calls; pass `cwd` or use absolute paths. Foreground commands default to {{ DEFAULT_TIMEOUT_S }}s and allow up to {{ MAX_TIMEOUT_S }}s through `timeout`. Do not run interactive commands or commands that may run forever in the foreground.\n\nWith `run_in_background=true`, provide a short `description`; the tool returns a task ID and notifies you on completion. Background tasks default to {{ DEFAULT_BACKGROUND_TIMEOUT_S }}s and allow up to {{ MAX_BACKGROUND_TIMEOUT_S }}s. Use `disable_timeout=true` only when no deadline is appropriate. Use `TaskOutput` for a status or output snapshot and `TaskStop` only to cancel. After launch, normally return control instead of immediately waiting.\n\nQuote paths containing spaces. Chain dependent commands with `&&`; issue independent read-only checks as parallel tool calls. Use `;`, `||`, pipes, redirects, and shell control flow when their semantics are required.\n\nStay inside the working directory unless the user explicitly requests otherwise. Avoid `..`, and never require superuser privileges without explicit instruction. Command availability depends on the host; verify unfamiliar commands before relying on them.";
+	bash_default = "Execute a `{{ SHELL_NAME }}` command for pipes, environment variables, processes, git, package managers, builds, tests, and other shell semantics.\n\nPrefer dedicated tools: `Read` for a known file, `Write` to create or replace it, `Edit` for exact changes, `Glob` to locate files, and `Grep` to search contents. Whole-home `find` and recursive `grep` against `.` are refused; narrow the path or use those search tools.\n\nStdout and stderr are combined. Long foreground output is streamed to a private file; capture stops at a safe size while the command continues to its real exit code. A non-zero command ends with its exit code; timeouts and user interrupts are reported separately.\n\nEach call runs in a fresh shell environment. Variables, `cd`, and shell history do not carry into later calls; pass `cwd` or use absolute paths. Foreground commands default to {{ DEFAULT_TIMEOUT_S }}s and allow up to {{ MAX_TIMEOUT_S }}s through `timeout`. Do not run interactive commands or commands that may run forever in the foreground.\n\nWith `run_in_background=true`, provide a short `description`; the tool returns a task ID and notifies you on completion. Background tasks default to {{ DEFAULT_BACKGROUND_TIMEOUT_S }}s and allow up to {{ MAX_BACKGROUND_TIMEOUT_S }}s. Use `disable_timeout=true` only when no deadline is appropriate. Use `TaskOutput` for a status or output snapshot and `TaskStop` only to cancel. After launch, normally return control instead of immediately waiting.\n\nQuote paths containing spaces. Chain dependent commands with `&&`; issue independent read-only checks as parallel tool calls. Use `;`, `||`, pipes, redirects, and shell control flow when their semantics are required.\n\nStay inside the working directory unless the user explicitly requests otherwise. Avoid `..`, and never require superuser privileges without explicit instruction. Command availability depends on the host; verify unfamiliar commands before relying on them.";
 	BashTool = class {
 		kaos;
 		cwd;
@@ -262891,6 +262898,16 @@ var init_bash = __esmMin((() => {
 				isError: true,
 				output: "Command cannot be empty."
 			};
+			const searchRefusal = broadRecursiveSearchRefusal({
+				command: args.command,
+				cwd: args.cwd ?? this.cwd,
+				homeDir: process.env["USERPROFILE"] ?? process.env["HOME"],
+				isWindowsBash: this.isWindowsBash
+			});
+			if (searchRefusal !== void 0) return {
+				isError: true,
+				output: searchRefusal
+			};
 			if (args.run_in_background !== true) return void 0;
 			if (!this.allowBackground) return {
 				isError: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.228",
+  "version": "9.1.230",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {