@oh-my-pi/pi-coding-agent 8.4.2 → 8.4.5

package/src/tools/grep.ts

@@ -1,4 +1,4 @@
-import nodePath from "node:path";
+import * as nodePath from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
@@ -23,31 +23,32 @@ import { toolResult } from "./tool-result";
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead, truncateLine } from "./truncate";
 
 const grepSchema = Type.Object({
-	pattern: Type.String({ description: "Search pattern (regex)" }),
-	path: Type.Optional(Type.String({ description: "Directory or file to search (default: cwd)" })),
-	glob: Type.Optional(Type.String({ description: "Glob filter, e.g. '*.ts', '**/*.spec.ts'" })),
-	type: Type.Optional(Type.String({ description: "File type filter, e.g. 'ts', 'py', 'rust'" })),
-	ignore_case: Type.Optional(Type.Boolean({ description: "Force case-insensitive (default: smart-case)" })),
-	case_sensitive: Type.Optional(Type.Boolean({ description: "Force case-sensitive (default: smart-case)" })),
-	literal: Type.Optional(Type.Boolean({ description: "Treat pattern as literal, not regex (default: false)" })),
-	multiline: Type.Optional(Type.Boolean({ description: "Match across line boundaries (default: false)" })),
-	context: Type.Optional(Type.Number({ description: "Lines of context before/after match (default: 0)" })),
-	limit: Type.Optional(Type.Number({ description: "Max matches to return (default: 100)" })),
+	pattern: Type.String({ description: "Regex pattern to search for" }),
+	path: Type.Optional(Type.String({ description: "File or directory to search (default: cwd)" })),
+	glob: Type.Optional(Type.String({ description: "Filter files by glob pattern (e.g., '*.js')" })),
+	type: Type.Optional(Type.String({ description: "Filter by file type (e.g., js, py, rust)" })),
 	output_mode: Type.Optional(
-		StringEnum(["content", "files_with_matches", "count"], {
-			description: "Output format (default: content)",
+		StringEnum(["files_with_matches", "content", "count"], {
+			description: "Output format (default: files_with_matches)",
 		}),
 	),
-	head_limit: Type.Optional(Type.Number({ description: "Truncate output to first N results" })),
-	offset: Type.Optional(Type.Number({ description: "Skip first N results (default: 0)" })),
+	i: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
+	n: Type.Optional(Type.Boolean({ description: "Show line numbers (default: true)" })),
+	a: Type.Optional(Type.Number({ description: "Lines to show after each match (default: 0)" })),
+	b: Type.Optional(Type.Number({ description: "Lines to show before each match (default: 0)" })),
+	c: Type.Optional(Type.Number({ description: "Lines of context (before and after) (default: 0)" })),
+	context: Type.Optional(Type.Number({ description: "Lines of context (alias for c)" })),
+	multiline: Type.Optional(Type.Boolean({ description: "Enable multiline matching (default: false)" })),
+	limit: Type.Optional(Type.Number({ description: "Limit output to first N matches (default: 100 in content mode)" })),
+	offset: Type.Optional(Type.Number({ description: "Skip first N entries before applying limit (default: 0)" })),
 });
 
-const DEFAULT_LIMIT = 100;
+const DEFAULT_MATCH_LIMIT = 100;
 
 export interface GrepToolDetails {
 	truncation?: TruncationResult;
 	matchLimitReached?: number;
-	headLimitReached?: number;
+	resultLimitReached?: number;
 	linesTruncated?: boolean;
 	meta?: OutputMeta;
 	// Fields for TUI rendering
@@ -61,6 +62,49 @@ export interface GrepToolDetails {
 	error?: string;
 }
 
+export interface RgResult {
+	stdout: string;
+	stderr: string;
+	exitCode: number | null;
+}
+
+/**
+ * Run rg command and capture output.
+ *
+ * @throws ToolAbortError if signal is aborted
+ */
+export async function runRg(rgPath: string, args: string[], signal?: AbortSignal): Promise<RgResult> {
+	const child = ptree.cspawn([rgPath, ...args], { signal });
+
+	let stdout: string;
+	try {
+		stdout = await child.nothrow().text();
+	} catch (err) {
+		if (err instanceof ptree.Exception && err.aborted) {
+			throw new ToolAbortError();
+		}
+		throw err;
+	}
+
+	let exitError: unknown;
+	try {
+		await child.exited;
+	} catch (err) {
+		exitError = err;
+		if (err instanceof ptree.Exception && err.aborted) {
+			throw new ToolAbortError();
+		}
+	}
+
+	const exitCode = child.exitCode ?? (exitError instanceof ptree.Exception ? exitError.exitCode : null);
+
+	return {
+		stdout,
+		stderr: child.peekStderr(),
+		exitCode,
+	};
+}
+
 /**
  * Pluggable operations for the grep tool.
  * Override these to delegate search to remote systems (e.g., SSH).
@@ -87,14 +131,15 @@ interface GrepParams {
 	path?: string;
 	glob?: string;
 	type?: string;
-	ignore_case?: boolean;
-	case_sensitive?: boolean;
-	literal?: boolean;
-	multiline?: boolean;
+	output_mode?: "content" | "files_with_matches" | "count";
+	i?: boolean;
+	n?: boolean;
+	a?: number;
+	b?: number;
+	c?: number;
 	context?: number;
+	multiline?: boolean;
 	limit?: number;
-	output_mode?: "content" | "files_with_matches" | "count";
-	head_limit?: number;
 	offset?: number;
 }
 
@@ -149,20 +194,65 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			path: searchDir,
 			glob,
 			type,
-			ignore_case,
-			case_sensitive,
-			literal,
-			multiline,
+			output_mode,
+			i,
+			n,
+			a,
+			b,
+			c,
 			context,
+			multiline,
 			limit,
-			output_mode,
-			head_limit,
 			offset,
 		} = params;
 
 		return untilAborted(signal, async () => {
-			// Auto-detect invalid regex patterns and switch to literal mode
-			// This handles cases like "abort(" which would cause ripgrep regex parse errors
+			const normalizedPattern = pattern.trim();
+			if (!normalizedPattern) {
+				throw new ToolError("Pattern must not be empty");
+			}
+
+			const normalizedOffset = offset === undefined ? 0 : Number.isFinite(offset) ? Math.floor(offset) : Number.NaN;
+			if (normalizedOffset < 0 || !Number.isFinite(normalizedOffset)) {
+				throw new ToolError("Offset must be a non-negative number");
+			}
+
+			const rawLimit = limit === undefined ? undefined : Number.isFinite(limit) ? Math.floor(limit) : Number.NaN;
+			if (rawLimit !== undefined && (!Number.isFinite(rawLimit) || rawLimit < 0)) {
+				throw new ToolError("Limit must be a non-negative number");
+			}
+			const normalizedLimit = rawLimit !== undefined && rawLimit > 0 ? rawLimit : undefined;
+
+			const normalizeContext = (value: number | undefined, label: string): number => {
+				if (value === undefined) return 0;
+				const normalized = Number.isFinite(value) ? Math.floor(value) : Number.NaN;
+				if (!Number.isFinite(normalized) || normalized < 0) {
+					throw new ToolError(`${label} must be a non-negative number`);
+				}
+				return normalized;
+			};
+
+			const normalizedAfter = normalizeContext(a, "After context");
+			const normalizedBefore = normalizeContext(b, "Before context");
+			const hasContextParam = context !== undefined;
+			const hasCParam = c !== undefined;
+			if (hasContextParam && hasCParam) {
+				throw new ToolError("Cannot combine context with c");
+			}
+			const normalizedContext = normalizeContext(hasContextParam ? context : c, "Context");
+			if (normalizedContext > 0 && (normalizedAfter > 0 || normalizedBefore > 0)) {
+				throw new ToolError("Cannot combine context with a or b");
+			}
+			const contextAfterValue = normalizedContext > 0 ? normalizedContext : normalizedAfter;
+			const contextBeforeValue = normalizedContext > 0 ? normalizedContext : normalizedBefore;
+			const showLineNumbers = n ?? true;
+			const ignoreCase = i ?? false;
+			const normalizedGlob = glob?.trim() ?? "";
+			const normalizedType = type?.trim() ?? "";
+			const hasContentHints =
+				limit !== undefined || context !== undefined || c !== undefined || a !== undefined || b !== undefined;
+
+			// Validate regex patterns early to surface parse errors before running rg
 			const rgPath = await ensureTool("rg", {
 				silent: true,
 				notify: message => toolContext?.ui?.notify(message, "info"),
@@ -172,12 +262,9 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				throw new ToolError("rg is not available and could not be downloaded");
 			}
 
-			let useLiteral = literal ?? false;
-			if (!useLiteral) {
-				const validation = await this.validateRegexPattern(pattern, rgPath);
-				if (!validation.valid) {
-					useLiteral = true;
-				}
+			const validation = await this.validateRegexPattern(normalizedPattern, rgPath);
+			if (!validation.valid) {
+				throw new ToolError(validation.error ?? "Invalid regex pattern");
 			}
 
 			// rgPath resolved earlier
@@ -193,10 +280,11 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			} catch {
 				throw new ToolError(`Path not found: ${searchPath}`);
 			}
-			const contextValue = context && context > 0 ? context : 0;
-			const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT);
-			const effectiveOutputMode = output_mode ?? "content";
-			const effectiveOffset = offset && offset > 0 ? offset : 0;
+			const effectiveOutputMode =
+				output_mode ?? (!isDirectory || hasContentHints ? "content" : "files_with_matches");
+			const effectiveOffset = normalizedOffset > 0 ? normalizedOffset : 0;
+			const effectiveLimit =
+				effectiveOutputMode === "content" ? (normalizedLimit ?? DEFAULT_MATCH_LIMIT) : normalizedLimit;
 
 			const formatPath = (filePath: string): string => {
 				if (isDirectory) {
@@ -229,38 +317,46 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 
 			// Base arguments depend on output mode
 			if (effectiveOutputMode === "files_with_matches") {
-				args.push("--files-with-matches", "--color=never", "--hidden");
+				args.push("--files-with-matches", "--color=never");
 			} else if (effectiveOutputMode === "count") {
-				args.push("--count", "--color=never", "--hidden");
+				args.push("--count", "--color=never");
 			} else {
-				args.push("--json", "--line-number", "--color=never", "--hidden");
+				args.push("--json", "--color=never");
+				if (showLineNumbers) {
+					args.push("--line-number");
+				}
 			}
 
-			if (case_sensitive) {
-				args.push("--case-sensitive");
-			} else if (ignore_case) {
+			args.push("--hidden");
+
+			if (ignoreCase) {
 				args.push("--ignore-case");
 			} else {
-				args.push("--smart-case");
+				args.push("--case-sensitive");
 			}
 
 			if (multiline) {
 				args.push("--multiline");
 			}
 
-			if (useLiteral) {
-				args.push("--fixed-strings");
+			if (normalizedGlob) {
+				args.push("--glob", normalizedGlob);
 			}
 
-			if (glob) {
-				args.push("--glob", glob);
+			args.push("--glob", "!**/.git/**");
+			args.push("--glob", "!**/node_modules/**");
+
+			if (normalizedType) {
+				args.push("--type", normalizedType);
 			}
 
-			if (type) {
-				args.push("--type", type);
+			if (effectiveOutputMode === "content") {
+				if (normalizedContext > 0) {
+					args.push("-C", String(normalizedContext));
+				}
 			}
 
-			args.push("--", pattern, searchPath);
+			args.push("--", normalizedPattern, searchPath);
 
 			const child = ptree.cspawn([rgPath, ...args], { signal });
 
@@ -320,8 +416,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 
 				const offsetLines = effectiveOffset > 0 ? lines.slice(effectiveOffset) : lines;
 				const listLimit = applyListLimit(offsetLines, {
-					limit: effectiveLimit,
-					headLimit: head_limit,
+					limit: normalizedLimit,
 					limitType: "result",
 				});
 				const processedLines = listLimit.items;
@@ -348,13 +443,13 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				};
 
 				if (effectiveOutputMode === "files_with_matches") {
-					for (const line of lines) {
+					for (const line of processedLines) {
 						recordSimpleFile(line);
 					}
 					fileCount = simpleFiles.size;
 					simpleMatchCount = fileCount;
 				} else {
-					for (const line of lines) {
+					for (const line of processedLines) {
 						const separatorIndex = line.lastIndexOf(":");
 						const filePart = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
 						const countPart = separatorIndex === -1 ? "" : line.slice(separatorIndex + 1);
@@ -368,7 +463,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					fileCount = simpleFiles.size;
 				}
 
-				const truncatedByLimit = Boolean(limitMeta.resultLimit || limitMeta.headLimit);
+				const truncatedByLimit = Boolean(limitMeta.resultLimit);
 
 				// For count mode, format as "path:count"
 				if (effectiveOutputMode === "count") {
@@ -390,13 +485,12 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						})),
 						mode: effectiveOutputMode,
 						truncated: truncatedByLimit,
-						headLimitReached: limitMeta.headLimit?.reached,
+						resultLimitReached: limitMeta.resultLimit?.reached,
 					};
 					return toolResult(details)
 						.text(output)
 						.limits({
 							resultLimit: limitMeta.resultLimit?.reached,
-							headLimit: limitMeta.headLimit?.reached,
 						})
 						.done();
 				}
@@ -411,13 +505,12 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					files: simpleFileList,
 					mode: effectiveOutputMode,
 					truncated: truncatedByLimit,
-					headLimitReached: limitMeta.headLimit?.reached,
+					resultLimitReached: limitMeta.resultLimit?.reached,
 				};
 				return toolResult(details)
 					.text(output)
 					.limits({
 						resultLimit: limitMeta.resultLimit?.reached,
-						headLimit: limitMeta.headLimit?.reached,
 					})
 					.done();
 			}
@@ -427,12 +520,14 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				const relativePath = formatPath(filePath);
 				const lines = await getFileLines(filePath);
 				if (!lines.length) {
-					return [`${relativePath}:${lineNumber}: (unable to read file)`];
+					return showLineNumbers
+						? [`${relativePath}:${lineNumber}: (unable to read file)`]
+						: [`${relativePath}: (unable to read file)`];
 				}
 
 				const block: string[] = [];
-				const start = contextValue > 0 ? Math.max(1, lineNumber - contextValue) : lineNumber;
-				const end = contextValue > 0 ? Math.min(lines.length, lineNumber + contextValue) : lineNumber;
+				const start = contextBeforeValue > 0 ? Math.max(1, lineNumber - contextBeforeValue) : lineNumber;
+				const end = contextAfterValue > 0 ? Math.min(lines.length, lineNumber + contextAfterValue) : lineNumber;
 
 				for (let current = start; current <= end; current++) {
 					const lineText = lines[current - 1] ?? "";
@@ -445,17 +540,26 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					}
 
 					if (isMatchLine) {
-						block.push(`${relativePath}:${current}: ${truncatedText}`);
+						block.push(
+							showLineNumbers
+								? `${relativePath}:${current}: ${truncatedText}`
+								: `${relativePath}: ${truncatedText}`,
+						);
 					} else {
-						block.push(`${relativePath}-${current}- ${truncatedText}`);
+						block.push(
+							showLineNumbers
+								? `${relativePath}-${current}- ${truncatedText}`
+								: `${relativePath}- ${truncatedText}`,
+						);
 					}
 				}
 
 				return block;
 			};
 
+			const maxMatches = effectiveLimit !== undefined ? effectiveLimit + effectiveOffset : undefined;
 			const processLine = async (line: string): Promise<void> => {
-				if (!line.trim() || matchCount >= effectiveLimit) {
+				if (!line.trim()) {
 					return;
 				}
 
@@ -467,22 +571,27 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				}
 
 				if (event.type === "match") {
-					matchCount++;
+					const nextIndex = matchCount + 1;
+					if (maxMatches !== undefined && nextIndex > maxMatches) {
+						matchLimitReached = true;
+						killedDueToLimit = true;
+						child.kill("SIGKILL");
+						return;
+					}
+
+					matchCount = nextIndex;
 					const filePath = event.data?.path?.text;
 					const lineNumber = event.data?.line_number;
 
 					if (filePath && typeof lineNumber === "number") {
+						if (matchCount <= effectiveOffset) {
+							return;
+						}
 						recordFile(filePath);
 						recordFileMatch(filePath);
 						const block = await formatBlock(filePath, lineNumber);
 						outputLines.push(...block);
 					}
-
-					if (matchCount >= effectiveLimit) {
-						matchLimitReached = true;
-						killedDueToLimit = true;
-						child.kill("SIGKILL");
-					}
 				}
 			};
 
@@ -531,21 +640,20 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				return toolResult(details).text("No matches found").done();
 			}
 
-			// Apply offset and head_limit to output lines
-			let processedLines = effectiveOffset > 0 ? outputLines.slice(effectiveOffset) : outputLines;
-			const listLimit = applyListLimit(processedLines, { headLimit: head_limit });
-			processedLines = listLimit.items;
-			const limitMeta = listLimit.meta;
+			const limitMeta =
+				matchLimitReached && effectiveLimit !== undefined
+					? { matchLimit: { reached: effectiveLimit, suggestion: effectiveLimit * 2 } }
+					: {};
 
 			// Apply byte truncation (no line limit since we already have match limit)
-			const rawOutput = processedLines.join("\n");
+			const rawOutput = outputLines.join("\n");
 			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
 			const output = truncation.content;
-			const truncated = Boolean(matchLimitReached || truncation.truncated || limitMeta.headLimit || linesTruncated);
+			const truncated = Boolean(matchLimitReached || truncation.truncated || limitMeta.matchLimit || linesTruncated);
 			const details: GrepToolDetails = {
 				scopePath,
-				matchCount,
+				matchCount: effectiveOffset > 0 ? Math.max(0, matchCount - effectiveOffset) : matchCount,
 				fileCount: files.size,
 				files: fileList,
 				fileMatches: fileList.map(path => ({
@@ -554,19 +662,20 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				})),
 				mode: effectiveOutputMode,
 				truncated,
-				headLimitReached: limitMeta.headLimit?.reached,
+				matchLimitReached: limitMeta.matchLimit?.reached,
 			};
 
 			// Keep TUI compatibility fields
-			if (matchLimitReached) details.matchLimitReached = effectiveLimit;
+			if (matchLimitReached && effectiveLimit !== undefined) {
+				details.matchLimitReached = effectiveLimit;
+			}
 			if (truncation.truncated) details.truncation = truncation;
 			if (linesTruncated) details.linesTruncated = true;
 
 			const resultBuilder = toolResult(details)
 				.text(output)
 				.limits({
-					matchLimit: matchLimitReached ? effectiveLimit : undefined,
-					headLimit: limitMeta.headLimit?.reached,
+					matchLimit: limitMeta.matchLimit?.reached,
 					columnMax: linesTruncated ? DEFAULT_MAX_COLUMN : undefined,
 				});
 			if (truncation.truncated) {
@@ -587,13 +696,16 @@ interface GrepRenderArgs {
 	path?: string;
 	glob?: string;
 	type?: string;
-	ignore_case?: boolean;
-	case_sensitive?: boolean;
-	literal?: boolean;
-	multiline?: boolean;
+	i?: boolean;
+	n?: boolean;
+	a?: number;
+	b?: number;
+	c?: number;
 	context?: number;
-	limit?: number;
+	multiline?: boolean;
 	output_mode?: string;
+	limit?: number;
+	offset?: number;
 }
 
 const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
@@ -607,15 +719,15 @@ export const grepToolRenderer = {
 		if (args.glob) meta.push(`glob:${args.glob}`);
 		if (args.type) meta.push(`type:${args.type}`);
 		if (args.output_mode && args.output_mode !== "files_with_matches") meta.push(`mode:${args.output_mode}`);
-		if (args.case_sensitive) {
-			meta.push("case:sensitive");
-		} else if (args.ignore_case) {
-			meta.push("case:insensitive");
-		}
-		if (args.literal) meta.push("literal");
+		if (args.i) meta.push("case:insensitive");
+		if (args.n === false) meta.push("no-line-numbers");
+		const contextValue = args.context ?? args.c;
+		if (contextValue !== undefined && contextValue > 0) meta.push(`context:${contextValue}`);
+		if (args.a !== undefined && args.a > 0) meta.push(`after:${args.a}`);
+		if (args.b !== undefined && args.b > 0) meta.push(`before:${args.b}`);
 		if (args.multiline) meta.push("multiline");
-		if (args.context !== undefined) meta.push(`context:${args.context}`);
-		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
+		if (args.limit !== undefined && args.limit > 0) meta.push(`limit:${args.limit}`);
+		if (args.offset !== undefined && args.offset > 0) meta.push(`offset:${args.offset}`);
 
 		const text = renderStatusLine(
 			{ icon: "pending", title: "Grep", description: args.pattern || "?", meta },
@@ -669,12 +781,7 @@ export const grepToolRenderer = {
 		const truncation = details?.meta?.truncation;
 		const limits = details?.meta?.limits;
 		const truncated = Boolean(
-			details?.truncated ||
-				truncation ||
-				limits?.matchLimit ||
-				limits?.resultLimit ||
-				limits?.headLimit ||
-				limits?.columnTruncated,
+			details?.truncated || truncation || limits?.matchLimit || limits?.resultLimit || limits?.columnTruncated,
 		);
 		const files = details?.files ?? [];
 
@@ -734,7 +841,6 @@ export const grepToolRenderer = {
 		const truncationReasons: string[] = [];
 		if (limits?.matchLimit) truncationReasons.push(`limit ${limits.matchLimit.reached} matches`);
 		if (limits?.resultLimit) truncationReasons.push(`limit ${limits.resultLimit.reached} results`);
-		if (limits?.headLimit) truncationReasons.push(`head limit ${limits.headLimit.reached}`);
 		if (truncation) truncationReasons.push(truncation.truncatedBy === "lines" ? "line limit" : "size limit");
 		if (limits?.columnTruncated) truncationReasons.push(`line length ${limits.columnTruncated.maxColumn}`);
 		if (truncation?.artifactId) truncationReasons.push(`full output: artifact://${truncation.artifactId}`);

package/src/tools/index.ts

@@ -1,8 +1,8 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { PromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import type { Skill } from "@oh-my-pi/pi-coding-agent/extensibility/skills";
 import { logger } from "@oh-my-pi/pi-utils";
+import type { PromptTemplate } from "../config/prompt-templates";
 import type { BashInterceptorRule } from "../config/settings-manager";
+import type { Skill } from "../extensibility/skills";
 import type { InternalUrlRouter } from "../internal-urls";
 import { getPreludeDocs, warmPythonEnvironment } from "../ipy/executor";
 import { checkPythonKernelAvailability } from "../ipy/kernel";
@@ -144,9 +144,9 @@ export interface ToolSession {
 	/** Get the current session model string, regardless of how it was chosen */
 	getActiveModelString?: () => string | undefined;
 	/** Auth storage for passing to subagents (avoids re-discovery) */
-	authStorage?: import("@oh-my-pi/pi-coding-agent/session/auth-storage").AuthStorage;
+	authStorage?: import("../session/auth-storage").AuthStorage;
 	/** Model registry for passing to subagents (avoids re-discovery) */
-	modelRegistry?: import("@oh-my-pi/pi-coding-agent/config/model-registry").ModelRegistry;
+	modelRegistry?: import("../config/model-registry").ModelRegistry;
 	/** MCP manager for proxying MCP calls through parent */
 	mcpManager?: import("../mcp/manager").MCPManager;
 	/** Internal URL router for agent:// and skill:// URLs */
@@ -155,7 +155,7 @@ export interface ToolSession {
 	agentOutputManager?: AgentOutputManager;
 	/** Settings manager for passing to subagents (avoids SQLite access in workers) */
 	settingsManager?: {
-		serialize: () => import("@oh-my-pi/pi-coding-agent/config/settings-manager").Settings;
+		serialize: () => import("../config/settings-manager").Settings;
 		getPlansDirectory: (cwd?: string) => string;
 	};
 	/** Settings manager (optional) */

package/src/tools/output-meta.ts

@@ -250,7 +250,7 @@ export class OutputMetaBuilder {
 		return this;
 	}
 
-	/** Add head_limit notice. No-op if reached <= 0. */
+	/** Add limit notice for head truncation. No-op if reached <= 0. */
 	headLimit(reached: number, suggestion = reached * 2): this {
 		if (reached <= 0) return this;
 		this.#meta.limits = { ...this.#meta.limits, headLimit: { reached, suggestion } };
@@ -349,7 +349,7 @@ export function formatOutputNotice(meta: OutputMeta | undefined): string {
 	}
 	if (meta.limits?.headLimit) {
 		const l = meta.limits.headLimit;
-		parts.push(`${l.reached} results limit reached. Use head_limit=${l.suggestion} for more`);
+		parts.push(`${l.reached} results limit reached. Use limit=${l.suggestion} for more`);
 	}
 	if (meta.limits?.columnTruncated) {
 		parts.push(`Some lines truncated to ${meta.limits.columnTruncated.maxColumn} chars`);

package/src/tools/plan-mode-guard.ts

@@ -1,4 +1,4 @@
-import { resolvePlanUrlToPath } from "@oh-my-pi/pi-coding-agent/internal-urls";
+import { resolvePlanUrlToPath } from "../internal-urls";
 import type { ToolSession } from ".";
 import { resolveToCwd } from "./path-utils";
 import { ToolError } from "./tool-errors";

package/src/tools/python.ts

@@ -172,10 +172,8 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 		}
 
 		const { cells, timeout: rawTimeout = 30, cwd, reset } = params;
-		// Auto-convert milliseconds to seconds if value > 1000 (16+ min is unreasonable)
-		let timeoutSec = rawTimeout > 1000 ? rawTimeout / 1000 : rawTimeout;
 		// Clamp to reasonable range: 1s - 600s (10 min)
-		timeoutSec = Math.max(1, Math.min(600, timeoutSec));
+		const timeoutSec = Math.max(1, Math.min(600, rawTimeout));
 		const timeoutMs = timeoutSec * 1000;
 		const timeoutSignal = AbortSignal.timeout(timeoutMs);
 		const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;