@ottocode/sdk 0.1.301 → 0.1.303

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.301",
+	"version": "0.1.303",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",
@@ -61,9 +61,9 @@
 			"import": "./src/core/src/tools/builtin/progress.ts",
 			"types": "./src/core/src/tools/builtin/progress.ts"
 		},
-		"./tools/builtin/ripgrep": {
-			"import": "./src/core/src/tools/builtin/ripgrep.ts",
-			"types": "./src/core/src/tools/builtin/ripgrep.ts"
+		"./tools/builtin/search": {
+			"import": "./src/core/src/tools/builtin/search.ts",
+			"types": "./src/core/src/tools/builtin/search.ts"
 		},
 		"./tools/builtin/websearch": {
 			"import": "./src/core/src/tools/builtin/websearch.ts",
@@ -81,6 +81,10 @@
 			"import": "./src/core/src/tools/bin-manager.ts",
 			"types": "./src/core/src/tools/bin-manager.ts"
 		},
+		"./search/fff": {
+			"import": "./src/core/src/search/fff.ts",
+			"types": "./src/core/src/search/fff.ts"
+		},
 		"./prompts/*": "./src/prompts/src/*"
 	},
 	"files": [
@@ -94,33 +98,36 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ai-sdk/anthropic": "^3.0.72",
-		"@ai-sdk/google": "^3.0.0",
-		"@ai-sdk/openai": "^3.0.0",
-		"@ai-sdk/openai-compatible": "^2.0.0",
-		"@ai-sdk/xai": "^3.0.0",
-		"@modelcontextprotocol/sdk": "^1.12",
-		"@openauthjs/openauth": "^0.4.3",
-		"@openrouter/ai-sdk-provider": "^1.2.0",
+		"@ai-sdk/anthropic": "3.0.82",
+		"@ai-sdk/google": "3.0.80",
+		"@ai-sdk/openai": "3.0.69",
+		"@ai-sdk/openai-compatible": "2.0.46",
+		"@ai-sdk/provider": "3.0.10",
+		"@ai-sdk/provider-utils": "4.0.27",
+		"@ai-sdk/xai": "3.0.93",
+		"@ff-labs/fff-bun": "0.9.3",
+		"@modelcontextprotocol/sdk": "1.27.1",
+		"@openauthjs/openauth": "0.4.3",
+		"@openrouter/ai-sdk-provider": "1.5.4",
 		"@ottorouter/ai-sdk": "0.2.6",
-		"@solana/web3.js": "^1.98.0",
-		"ai": "^6.0.170",
-		"ai-sdk-ollama": "^3.8.3",
-		"bs58": "^6.0.0",
-		"bun-pty": "^0.3.2",
-		"diff": "^8.0.2",
-		"fast-glob": "^3.3.2",
-		"hono": "^4.9.9",
-		"opencode-anthropic-auth": "^0.0.2",
-		"qrcode": "^1.5.4",
-		"qrcode-terminal": "^0.12.0",
-		"tweetnacl": "^1.0.3",
-		"x402": "^1.1.0",
-		"zod": "^4.3.6"
+		"@solana/web3.js": "1.98.4",
+		"ai": "6.0.199",
+		"ai-sdk-ollama": "3.8.3",
+		"bs58": "6.0.0",
+		"bun-pty": "0.3.2",
+		"diff": "8.0.3",
+		"fast-glob": "3.3.3",
+		"hono": "4.12.0",
+		"opencode-anthropic-auth": "0.0.2",
+		"qrcode": "1.5.4",
+		"qrcode-terminal": "0.12.0",
+		"tweetnacl": "1.0.3",
+		"x402": "1.1.0",
+		"zod": "4.3.6"
 	},
 	"devDependencies": {
-		"@types/bun": "latest",
-		"typescript": "~5.9.3"
+		"@types/bun": "1.3.14",
+		"typescript": "5.9.3"
 	},
 	"keywords": [
 		"ai",

package/src/core/src/search/fff.ts

@@ -0,0 +1,215 @@
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { FileFinder, type FileFinderApi } from '@ff-labs/fff-bun';
+
+export type FffFileSearchResult = {
+	files: string[];
+	truncated: boolean;
+};
+
+type FinderEntry = {
+	finder: FileFinderApi;
+	ready: Promise<void>;
+	lastScanMs: number;
+};
+
+const finderCache = new Map<string, Promise<FinderEntry>>();
+
+function normalizeRoot(path: string): string {
+	return resolve(path);
+}
+
+function isHomeRoot(path: string): boolean {
+	return normalizeRoot(path) === normalizeRoot(homedir());
+}
+
+async function createFinderEntry(basePath: string): Promise<FinderEntry> {
+	const result = FileFinder.create({
+		basePath,
+		aiMode: true,
+		disableWatch: true,
+		enableHomeDirScanning: isHomeRoot(basePath),
+		enableFsRootScanning: false,
+	});
+	if (!result.ok) throw new Error(result.error);
+
+	const finder = result.value;
+	const entry: FinderEntry = {
+		finder,
+		ready: Promise.resolve(),
+		lastScanMs: 0,
+	};
+	const ready = (async () => {
+		const scan = await finder.waitForIndexReady(10_000);
+		if (!scan.ok) throw new Error(scan.error);
+		entry.lastScanMs = Date.now();
+	})();
+	entry.ready = ready;
+
+	return entry;
+}
+
+async function getFffEntry(basePath: string): Promise<FinderEntry> {
+	const root = normalizeRoot(basePath);
+	let entryPromise = finderCache.get(root);
+	if (!entryPromise) {
+		entryPromise = createFinderEntry(root).catch((error) => {
+			finderCache.delete(root);
+			throw error;
+		});
+		finderCache.set(root, entryPromise);
+	}
+
+	const entry = await entryPromise;
+	await entry.ready;
+	return entry;
+}
+
+/**
+ * Return a cached FFF finder for a root directory.
+ */
+export async function getFffFinder(basePath: string): Promise<FileFinderApi> {
+	const entry = await getFffEntry(basePath);
+	return entry.finder;
+}
+
+/**
+ * Force FFF to rescan a root and wait briefly for fresh results.
+ */
+export async function refreshFffIndex(
+	basePath: string,
+	timeoutMs = 3_000,
+	maxAgeMs = 0,
+): Promise<void> {
+	const entry = await getFffEntry(basePath);
+	if (maxAgeMs > 0 && Date.now() - entry.lastScanMs < maxAgeMs) return;
+	const finder = entry.finder;
+	const scan = finder.scanFiles();
+	if (!scan.ok) throw new Error(scan.error);
+	const done = await finder.waitForScan(timeoutMs);
+	if (!done.ok) throw new Error(done.error);
+	entry.lastScanMs = Date.now();
+}
+
+export function clearFffFinderCache(): void {
+	for (const entryPromise of finderCache.values()) {
+		entryPromise.then((entry) => entry.finder.destroy()).catch(() => undefined);
+	}
+	finderCache.clear();
+}
+
+function normalizeRelativePath(root: string, path: string): string {
+	const rel = relative(root, path).replace(/\\/g, '/');
+	return rel === '' ? '.' : rel;
+}
+
+function fileDepth(relativePath: string): number {
+	if (relativePath === '.') return 0;
+	return Math.max(0, relativePath.split(/[\\/]/).length - 1);
+}
+
+function isWithinRoot(root: string, target: string): boolean {
+	const rel = relative(root, target);
+	return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+async function getRootAndConstraint(projectRoot: string, inputPath = '.') {
+	const trimmed = inputPath.trim() || '.';
+	const expanded =
+		trimmed === '~'
+			? homedir()
+			: trimmed.startsWith('~/')
+				? `${homedir()}/${trimmed.slice(2)}`
+				: trimmed;
+	const target = isAbsolute(expanded)
+		? resolve(expanded)
+		: resolve(projectRoot, expanded);
+	const root = normalizeRoot(projectRoot);
+
+	try {
+		const targetStat = await stat(target);
+		if (isWithinRoot(root, target)) {
+			const rel = normalizeRelativePath(root, target);
+			if (rel === '.') return { basePath: root, constraint: '' };
+			return {
+				basePath: root,
+				constraint: targetStat.isDirectory() ? `${rel}/` : rel,
+			};
+		}
+
+		if (targetStat.isDirectory()) return { basePath: target, constraint: '' };
+		return {
+			basePath: dirname(target),
+			constraint: target.split(/[\\/]/).pop() ?? '',
+		};
+	} catch {
+		if (isWithinRoot(root, target)) {
+			const rel = normalizeRelativePath(root, target);
+			return { basePath: root, constraint: rel === '.' ? '' : rel };
+		}
+		return { basePath: target, constraint: '' };
+	}
+}
+
+export async function resolveFffSearchScope(projectRoot: string, path = '.') {
+	return getRootAndConstraint(projectRoot, path);
+}
+
+export async function searchFffFiles(args: {
+	projectRoot: string;
+	query?: string;
+	path?: string;
+	exclude?: string[];
+	maxDepth: number;
+	limit: number;
+}): Promise<FffFileSearchResult> {
+	const { basePath, constraint } = await getRootAndConstraint(
+		args.projectRoot,
+		args.path ?? '.',
+	);
+	await refreshFffIndex(basePath, 3_000, 2_000);
+	const finder = await getFffFinder(basePath);
+	const query = args.query?.trim() ?? '';
+	const constraints = [
+		constraint,
+		...(args.exclude ?? []).map((pattern) => `!${pattern.replace(/^!/, '')}`),
+	]
+		.map((part) => part.trim())
+		.filter(Boolean)
+		.join(' ');
+	const pageSize = Math.min(Math.max(args.limit * 2, 100), 1_000);
+	const files: string[] = [];
+	const seen = new Set<string>();
+	let truncated = false;
+
+	for (
+		let pageIndex = 0;
+		pageIndex < 100 && files.length < args.limit;
+		pageIndex++
+	) {
+		const result =
+			query || constraints
+				? finder.fileSearch(`${constraints ? `${constraints} ` : ''}${query}`, {
+						pageIndex,
+						pageSize,
+					})
+				: finder.glob(constraint || '**/*', { pageIndex, pageSize });
+		if (!result.ok) throw new Error(result.error);
+
+		for (const item of result.value.items) {
+			const relativePath = item.relativePath;
+			if (seen.has(relativePath)) continue;
+			if (fileDepth(relativePath) >= args.maxDepth) continue;
+			seen.add(relativePath);
+			files.push(relativePath);
+			if (files.length >= args.limit) break;
+		}
+
+		const consumed = (pageIndex + 1) * pageSize;
+		if (consumed >= result.value.totalMatched) break;
+		if (files.length >= args.limit) truncated = true;
+	}
+
+	return { files: files.slice(0, args.limit), truncated };
+}

package/src/core/src/tools/builtin/fs/read.txt

@@ -5,6 +5,6 @@
 
 Usage tips:
 - Prefer relative project paths when possible (more portable)
-- For large files or searches, use the Grep or Ripgrep tool
+- For large files or searches, use the `search` tool
 - Use startLine/endLine or startLine/maxLines for targeted reads of large files
 - If startLine is provided without endLine or maxLines, only that one line is read

package/src/core/src/tools/builtin/glob.txt

@@ -8,6 +8,6 @@
 
 ## Usage tips
 
-- Use `glob` for filename patterns; use `ripgrep` for file contents.
+- Use `glob` for filename patterns; use `search` for file contents.
 - Combine with `path` to restrict the search to a subdirectory.
 - Prefer reading a known file directly over globbing to "find" it (check the `<project>` listing in the system prompt first).

package/src/core/src/tools/builtin/search.ts

@@ -0,0 +1,157 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod/v3';
+import DESCRIPTION from './search.txt' with { type: 'text' };
+import { createToolError, type ToolResponse } from '../error.ts';
+import {
+	getFffFinder,
+	refreshFffIndex,
+	resolveFffSearchScope,
+} from '../../search/fff.ts';
+
+const TEXT_MAX = 200;
+
+type SearchMatch = { file: string; line: number; text: string };
+
+type SearchToolResult = {
+	count: number;
+	matches: SearchMatch[];
+	truncated?: boolean;
+	shownMatches?: number;
+	files?: Array<{ file: string; matches: number }>;
+};
+
+function truncateText(text: string): string {
+	return text.length > TEXT_MAX ? `${text.slice(0, TEXT_MAX)}…` : text;
+}
+
+function buildFffQuery(args: {
+	query: string;
+	pathConstraint: string;
+	glob?: string;
+	ignoreCase?: boolean;
+}): string {
+	const constraints = [args.pathConstraint, args.glob]
+		.map((part) => part?.trim() ?? '')
+		.filter(Boolean);
+	const query = args.ignoreCase ? `(?i)${args.query}` : args.query;
+	return [...constraints, query].join(' ');
+}
+
+function summarizeMatches(matches: SearchMatch[]) {
+	const fileCounts = new Map<string, number>();
+	for (const match of matches) {
+		fileCounts.set(match.file, (fileCounts.get(match.file) ?? 0) + 1);
+	}
+	return Array.from(fileCounts.entries()).map(([file, count]) => ({
+		file,
+		matches: count,
+	}));
+}
+
+export function buildSearchTool(projectRoot: string): {
+	name: string;
+	tool: Tool;
+} {
+	const search = tool({
+		description: DESCRIPTION,
+		inputSchema: z.object({
+			query: z.string().min(1).describe('Search pattern (regex by default)'),
+			path: z
+				.string()
+				.optional()
+				.default('.')
+				.describe('Relative path to search in'),
+			ignoreCase: z.boolean().optional().default(false),
+			glob: z
+				.array(z.string())
+				.optional()
+				.describe('One or more glob patterns to include'),
+			maxResults: z.number().int().min(1).max(5000).optional().default(100),
+		}),
+		async execute({
+			query,
+			path = '.',
+			ignoreCase,
+			glob,
+			maxResults = 100,
+		}: {
+			query: string;
+			path?: string;
+			ignoreCase?: boolean;
+			glob?: string[];
+			maxResults?: number;
+		}): Promise<ToolResponse<SearchToolResult>> {
+			try {
+				const { basePath, constraint } = await resolveFffSearchScope(
+					projectRoot,
+					path,
+				);
+				await refreshFffIndex(basePath);
+				const finder = await getFffFinder(basePath);
+				const includeGlobs =
+					Array.isArray(glob) && glob.length > 0 ? glob : [undefined];
+				const matches: SearchMatch[] = [];
+				const seen = new Set<string>();
+				let truncated = false;
+
+				for (const includeGlob of includeGlobs) {
+					if (matches.length >= maxResults) {
+						truncated = true;
+						break;
+					}
+
+					const fffQuery = buildFffQuery({
+						query,
+						pathConstraint: constraint,
+						glob: includeGlob,
+						ignoreCase,
+					});
+					const result = finder.grep(fffQuery, {
+						mode: 'regex',
+						smartCase: false,
+						pageSize: maxResults - matches.length,
+						maxMatchesPerFile: maxResults,
+					});
+
+					if (!result.ok) {
+						return createToolError(result.error, 'execution', {
+							suggestion: 'Check if the search query is valid',
+						});
+					}
+
+					for (const item of result.value.items) {
+						const match = {
+							file: item.relativePath,
+							line: item.lineNumber,
+							text: truncateText(item.lineContent),
+						};
+						const key = `${match.file}:${match.line}:${match.text}`;
+						if (seen.has(key)) continue;
+						seen.add(key);
+						matches.push(match);
+						if (matches.length >= maxResults) break;
+					}
+
+					truncated = truncated || Boolean(result.value.nextCursor);
+				}
+
+				const files = summarizeMatches(matches);
+
+				return {
+					ok: true,
+					count: matches.length,
+					matches,
+					...(truncated
+						? { truncated: true, shownMatches: matches.length }
+						: {}),
+					...(files.length ? { files } : {}),
+				};
+			} catch (err) {
+				return createToolError(String(err), 'execution', {
+					suggestion: 'Check if FFF is available and the query is valid',
+				});
+			}
+		},
+	});
+	return { name: 'search', tool: search };
+}

package/src/core/src/tools/builtin/search.txt

@@ -0,0 +1,14 @@
+- Search file contents using the FFF indexed search engine
+- Returns a flat list of matches with `file`, `line`, and `text`
+- Supports regex patterns, include globs, path constraints, and case-insensitive search
+- Respects `.gitignore` by default
+
+Use this for text/code search across the codebase. It is the primary tool for repository content discovery.
+
+## Usage tips
+
+- Narrow broad searches with `path` and `glob` values.
+- Keep `maxResults` low for broad searches; the tool returns at most that many matches.
+- Batch independent searches (e.g. multiple function names) in a single turn for parallel execution.
+- Use `ignoreCase: true` for case-insensitive matching; pass `glob` patterns (e.g. `["*.ts", "*.tsx"]`) to limit file types.
+- For filename/path discovery, use `glob` first when you already know the file pattern.

package/src/core/src/tools/builtin/shell.ts

@@ -47,6 +47,17 @@ export type ShellOutputMode = 'auto' | 'full' | 'tail';
 const DEFAULT_TAIL_LINES = 100;
 const DEFAULT_MAX_OUTPUT_BYTES = 128_000;
 
+function looksLikeRepositorySearchCommand(cmd: string): boolean {
+	const normalized = cmd.replace(/\s+/g, ' ').trim();
+	return (
+		/(^|[;&|()]\s*)(rg|ripgrep)(\s|$)/.test(normalized) ||
+		/(^|[;&|()]\s*)grep\s+.*\s(-R|-r|--recursive)(\s|$)/.test(normalized) ||
+		/(^|[;&|()]\s*)find\s+(\.|\.\/|\$PWD|\S*\/).*(-name|-iname|-path|-type)/.test(
+			normalized,
+		)
+	);
+}
+
 type CompactTextResult = {
 	text: string;
 	truncated: boolean;
@@ -220,6 +231,18 @@ export function buildShellTool(projectRoot: string): {
 				});
 			}
 
+			if (looksLikeRepositorySearchCommand(cmd)) {
+				return createToolError(
+					'This looks like repository discovery. Use the search tool for content/code search or glob for filename/path discovery.',
+					'validation',
+					{
+						cmd,
+						suggestion:
+							'Use search for file contents, or glob for file and path discovery.',
+					},
+				);
+			}
+
 			const absCwd = resolveSafePath(projectRoot, cwd || '.');
 			const finalCmd = injectCoAuthorIntoGitCommit(cmd);
 			const shellExecutor = shellExecutorContext.getStore();

package/src/core/src/tools/builtin/shell.txt

@@ -4,13 +4,15 @@
 
 **Use `shell` for one-off, non-interactive commands.** These may be short-lived checks or long-running commands that finish on their own and do not require stdin. For commands that need interactive input, a TTY, or persistence across turns, use the `terminal` tool instead.
 
+For repository discovery, use `search` for content/code search and `glob` for filename/path discovery. Reserve `shell` for execution, builds, tests, diagnostics, and other command-line tasks.
+
 ## Usage tips
 
 - Chain commands with `&&` to fail-fast.
 - For long outputs, redirect to a file, inspect `wc -c`, then read a small range or tail.
 - `outputMode: "auto"` is the default and keeps bounded tail output. Use `outputMode: "tail"` with `tailLines` for verbose builds/tests, or `outputMode: "full"` only when complete output is truly needed.
 - Final `stdout`/`stderr` are capped by `maxOutputBytes` per stream to avoid huge tool results. Set `maxOutputBytes: 0` only when you intentionally need uncapped output.
-- For binary, minified, or `strings` searches, cap line width explicitly, e.g. `rg -o '.{0,80}needle.{0,120}' | head -50`.
+- For binary/minified inspection that cannot be handled by `search`, cap line width and output explicitly.
 - For long-running non-interactive commands, set an appropriate `timeout` and ensure the command exits on its own.
 - Batch independent checks (e.g. `git status && git diff`) in parallel tool calls rather than sequential shell chains when you need results separately.
 - Never use `shell` with `sed`/`awk` for programmatic file editing — use the dedicated file-editing tools instead.

package/src/core/src/tools/loader.ts

@@ -5,7 +5,7 @@ import { buildFsTools } from './builtin/fs/index.ts';
 import { buildGitTools } from './builtin/git.ts';
 import { progressUpdateTool } from './builtin/progress.ts';
 import { buildShellTool } from './builtin/shell.ts';
-import { buildRipgrepTool } from './builtin/ripgrep.ts';
+import { buildSearchTool } from './builtin/search.ts';
 import { buildGlobTool } from './builtin/glob.ts';
 import { buildApplyPatchTool } from './builtin/patch.ts';
 import { updateTodosTool } from './builtin/todos.ts';
@@ -153,8 +153,8 @@ async function discoverStaticProjectTools(
 		const shell = buildShellTool(projectRoot);
 		tools.set(shell.name, shell.tool);
 		// Search
-		const rg = buildRipgrepTool(projectRoot);
-		tools.set(rg.name, rg.tool);
+		const search = buildSearchTool(projectRoot);
+		tools.set(search.name, search.tool);
 		const glob = buildGlobTool(projectRoot);
 		tools.set(glob.name, glob.tool);
 		// Patch/apply

package/src/prompts/src/agents/build.txt

@@ -31,5 +31,6 @@ After making changes:
 
 ## Searching & discovery
 
-- `ripgrep` for content search, `glob` for filename patterns, `tree` for hierarchical structure.
+- Use the `search` tool for content/code search and `glob` for filename patterns.
+- Reserve `shell` for execution, builds, tests, and other command-line tasks.
 - Batch independent reads/searches in a single turn for performance.

package/src/prompts/src/agents/plan.txt

@@ -5,6 +5,7 @@ You may ONLY observe, analyze, and plan.
 </system-reminder>
 
 Your job: produce an actionable, minimal plan.
-- Use only read/inspect tools (read, ls, tree, ripgrep, git_diff).
+- Use only read/inspect tools (read, ls, tree, search, glob, git_diff).
+- Use `search` for content/code search and `glob` for filename/path discovery.
 - Identify concrete steps with just enough detail to execute later.
 - No changes. No write operations. No refactors.

package/src/prompts/src/agents/research.txt

@@ -20,7 +20,7 @@ Help users find information from past sessions, session history, and the codebas
 
 ## Codebase Tools
 
-- `read`, `ripgrep`, `tree`, `ls`
+- `read`, `search`, `glob`, `tree`, `ls`
 
 ## Research Strategy
 

package/src/prompts/src/providers/anthropic.txt

@@ -97,7 +97,7 @@ assistant: Clients are marked as failed in the `connectToServer` function in src
 For software engineering requests (bugs, features, refactors, explanations):
 
 1. Use `update_todos` to plan multi-step work.
-2. Explore the codebase with the search tools (`glob`, `ripgrep`, `tree`, `read`). Batch independent searches in parallel.
+2. Explore the codebase with the search tools (`search`, `glob`, `tree`, `read`). Batch independent searches in parallel.
 3. Implement the solution.
 4. Verify — run the project's build/lint/test commands with `shell`. Check `README.md` / `AGENTS.md` to find the right command.
 5. Review diffs with `git_status` / `git_diff`.
@@ -109,7 +109,7 @@ When the user mentions a specific file (e.g. `@publish.config`, `src/app.ts`, `p
 
 - Check the `<project>` listing in the system prompt first — if the file is there, read it directly.
 - Do NOT waste tool calls searching for a file whose path is already known.
-- Fall back to `glob` / `ripgrep` only when the path is genuinely ambiguous.
+- Fall back to `glob` / `search` only when the path is genuinely ambiguous.
 
 # Batching tool calls
 

package/src/prompts/src/providers/default.txt

@@ -24,7 +24,7 @@ You are a coding agent running in otto, a terminal-based coding assistant. Preci
 
 # Working on tasks
 
-1. Understand — use `glob`, `ripgrep`, `tree`, `read` to map the code. Batch independent searches.
+1. Understand — use `search`, `glob`, `tree`, `read` to map the code. Batch independent searches.
 2. Plan — use `update_todos` for multi-step work. Mark one step `in_progress` at a time.
 3. Implement — prefer the targeted editing tools available to you for small in-file changes; use patch-style edits for structural or multi-file changes when available; use `write` only for new files or near-total rewrites.
 4. Verify — run project-specific build/lint/test commands via `shell`. Check `README.md` / `AGENTS.md` for the right command.
@@ -36,7 +36,7 @@ When the user names a specific file:
 
 - Check the `<project>` listing in the system prompt first — read directly if listed.
 - Don't waste tool calls searching for a known path.
-- Fall back to `glob` / `ripgrep` only when the path is genuinely ambiguous.
+- Fall back to `glob` / `search` only when the path is genuinely ambiguous.
 
 # Batching and parallelism
 

package/src/prompts/src/providers/glm.txt

@@ -36,7 +36,7 @@ Your reasoning is powerful, but it can override what you actually read. Guard ag
 
 # Working on tasks
 
-1. Understand — use `glob`, `ripgrep`, `tree`, `read` to map the code. Batch independent searches.
+1. Understand — use `search`, `glob`, `tree`, `read` to map the code. Batch independent searches.
 2. Plan — use `update_todos` for multi-step work. Mark one step `in_progress` at a time.
 3. Implement — prefer the targeted editing tools available to you for small in-file changes; use patch-style edits for structural or multi-file changes when available; use `write` only for new files or near-total rewrites.
 4. Verify — run project-specific build/lint/test commands via `shell`. Check `README.md` / `AGENTS.md` for the right command.
@@ -48,7 +48,7 @@ When the user names a specific file:
 
 - Check the `<project>` listing in the system prompt first — read directly if listed.
 - Don't waste tool calls searching for a known path.
-- Fall back to `glob` / `ripgrep` only when the path is genuinely ambiguous.
+- Fall back to `glob` / `search` only when the path is genuinely ambiguous.
 
 # Batching and parallelism
 

package/src/prompts/src/providers/google.txt

@@ -19,7 +19,7 @@ You are Gemini, operating as otto — an interactive CLI coding agent specializi
 
 For bug fixes, features, refactors, or explanations:
 
-1. **Understand.** Use `glob` / `ripgrep` / `tree` / `read` extensively (in parallel when independent) to understand structure, patterns, and conventions.
+1. **Understand.** Use `search` / `glob` / `tree` / `read` extensively (in parallel when independent) to understand structure, patterns, and conventions.
 2. **Plan.** Build a grounded plan. Share an extremely concise plan with the user if it helps. Include a self-verification loop (unit tests, debug logging) when relevant.
 3. **Implement.** Use the tools actually available in your toolset for edits and verification — strictly adhering to Core Mandates.
 4. **Verify (tests).** Identify test commands from `README`, `package.json`, or existing test patterns. NEVER assume standard test commands.