@nghyane/arcane 0.1.12 → 0.1.14

package/src/patch/schemas.ts

@@ -0,0 +1,208 @@
+import { StringEnum } from "@nghyane/arcane-ai";
+import { type Static, Type } from "@sinclair/typebox";
+
+export const replaceEditSchema = Type.Object({
+	path: Type.String({ description: "File path (relative or absolute)" }),
+	old_text: Type.String({
+		description: "Text to find (fuzzy whitespace matching enabled)",
+	}),
+	new_text: Type.String({ description: "Replacement text" }),
+	all: Type.Optional(
+		Type.Boolean({
+			description: "Replace all occurrences (default: unique match required)",
+		}),
+	),
+});
+
+export const patchEditSchema = Type.Object({
+	path: Type.String({ description: "File path" }),
+	op: Type.Optional(
+		StringEnum(["create", "delete", "update"], {
+			description: "Operation (default: update)",
+		}),
+	),
+	rename: Type.Optional(Type.String({ description: "New path for move" })),
+	diff: Type.Optional(
+		Type.String({
+			description: "Diff hunks (update) or full content (create)",
+		}),
+	),
+});
+
+export type ReplaceParams = Static<typeof replaceEditSchema>;
+export type PatchParams = Static<typeof patchEditSchema>;
+
+/** Pattern matching hashline display format: `LINE#ID:CONTENT` */
+const HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*\d+#[0-9a-zA-Z]{1,16}:/;
+
+/** Pattern matching a unified-diff `+` prefix (but not `++`) */
+const DIFF_PLUS_RE = /^[+-](?![+-])/;
+
+/**
+ * Strip hashline display prefixes and diff `+` markers from replacement lines.
+ *
+ * Models frequently copy the `LINE#ID  ` prefix from read output into their
+ * replacement content, or include unified-diff `+` prefixes. Both corrupt the
+ * output file. This strips them heuristically before application.
+ */
+export function stripNewLinePrefixes(lines: string[]): string[] {
+	// Detect whether the *majority* of non-empty lines carry a prefix —
+	// if only one line out of many has a match it's likely real content.
+	let hashPrefixCount = 0;
+	let diffPlusCount = 0;
+	let nonEmpty = 0;
+	for (const l of lines) {
+		if (l.length === 0) continue;
+		nonEmpty++;
+		if (HASHLINE_PREFIX_RE.test(l)) hashPrefixCount++;
+		if (DIFF_PLUS_RE.test(l)) diffPlusCount++;
+	}
+	if (nonEmpty === 0) return lines;
+
+	const stripHash = hashPrefixCount > 0 && hashPrefixCount >= nonEmpty * 0.5;
+	const stripPlus = !stripHash && nonEmpty >= 2 && diffPlusCount > 0 && diffPlusCount >= nonEmpty * 0.5;
+
+	if (!stripHash && !stripPlus) return lines;
+
+	return lines.map(l => {
+		if (stripHash) return l.replace(HASHLINE_PREFIX_RE, "");
+		if (stripPlus) return l.replace(DIFF_PLUS_RE, "");
+		return l;
+	});
+}
+
+const hashlineReplaceContentFormat = (kind: string) =>
+	Type.Union([
+		Type.Null(),
+		Type.Array(Type.String(), { description: `${kind} lines` }),
+		Type.String({ description: `${kind} line` }),
+	]);
+
+const hashlineInsertContentFormat = (kind: string) =>
+	Type.Union([
+		Type.Array(Type.String(), { description: `${kind} lines`, minItems: 1 }),
+		Type.String({ description: `${kind} line`, minLength: 1 }),
+	]);
+
+const hashlineTagFormat = (what: string) =>
+	Type.String({
+		description: `Tag identifying the ${what} — format "N#XX" (e.g. "5#PM"), copied verbatim from read output`,
+	});
+
+export function hashlineParseContent(edit: string | string[] | null): string[] {
+	if (edit === null) return [];
+	if (Array.isArray(edit)) return edit;
+	const lines = stripNewLinePrefixes(edit.split("\n"));
+	if (lines.length === 0) return [];
+	if (lines.length > 1 && lines[lines.length - 1].trim() === "") return lines.slice(0, -1);
+	return lines;
+}
+
+export function hashlineParseContentString(edit: string | string[] | null): string {
+	if (edit === null) return "";
+	if (Array.isArray(edit)) return edit.join("\n");
+	return edit;
+}
+
+const hashlineTargetEditSchema = Type.Object(
+	{
+		op: Type.Literal("set"),
+		tag: hashlineTagFormat("line being replaced"),
+		content: hashlineReplaceContentFormat("Replacement"),
+	},
+	{ additionalProperties: false },
+);
+
+const hashlineAppendEditSchema = Type.Object(
+	{
+		op: Type.Literal("append"),
+		after: Type.Optional(hashlineTagFormat("line after which to append")),
+		content: hashlineInsertContentFormat("Appended"),
+	},
+	{ additionalProperties: false },
+);
+
+const hashlinePrependEditSchema = Type.Object(
+	{
+		op: Type.Literal("prepend"),
+		before: Type.Optional(hashlineTagFormat("line before which to prepend")),
+		content: hashlineInsertContentFormat("Prepended"),
+	},
+	{ additionalProperties: false },
+);
+
+const hashlineRangeEditSchema = Type.Object(
+	{
+		op: Type.Literal("replace"),
+		first: hashlineTagFormat("first line"),
+		last: hashlineTagFormat("last line"),
+		content: hashlineReplaceContentFormat("Replacement"),
+	},
+	{ additionalProperties: false },
+);
+
+const hashlineInsertEditSchema = Type.Object(
+	{
+		op: Type.Literal("insert"),
+		before: Type.Optional(hashlineTagFormat("line before which to insert")),
+		after: Type.Optional(hashlineTagFormat("line after which to insert")),
+		content: hashlineInsertContentFormat("Inserted"),
+	},
+	{ additionalProperties: false },
+);
+
+const hashlineReplaceTextEditSchema = Type.Object(
+	{
+		op: Type.Literal("replaceText"),
+		old_text: Type.String({ description: "Text to find", minLength: 1 }),
+		new_text: hashlineReplaceContentFormat("Replacement"),
+		all: Type.Optional(Type.Boolean({ description: "Replace all occurrences" })),
+	},
+	{ additionalProperties: false },
+);
+
+const HL_REPLACE_ENABLED = Bun.env.ARCANE_HL_REPLACETXT === "1";
+
+export const hashlineEditSpecSchema = Type.Union([
+	hashlineTargetEditSchema,
+	hashlineRangeEditSchema,
+	hashlineAppendEditSchema,
+	hashlinePrependEditSchema,
+	hashlineInsertEditSchema,
+	...(HL_REPLACE_ENABLED ? [hashlineReplaceTextEditSchema] : []),
+]);
+
+export const hashlineEditSchema = Type.Object(
+	{
+		path: Type.String({ description: "File path (relative or absolute)" }),
+		edits: Type.Array(hashlineEditSpecSchema, {
+			description: "Changes to apply to the file at `path`",
+			minItems: 0,
+		}),
+		delete: Type.Optional(Type.Boolean({ description: "Delete the file when true" })),
+		rename: Type.Optional(Type.String({ description: "New path if moving" })),
+	},
+	{ additionalProperties: false },
+);
+
+export type HashlineToolEdit = Static<typeof hashlineEditSpecSchema>;
+export type HashlineParams = Static<typeof hashlineEditSchema>;
+
+export type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlineEditSchema;
+
+export type EditMode = "replace" | "patch" | "hashline";
+
+export const DEFAULT_EDIT_MODE: EditMode = "patch";
+
+export function normalizeEditMode(mode?: string | null): EditMode | null {
+	switch (mode) {
+		case "replace":
+			return "replace";
+		case "patch":
+			return "patch";
+		case "hashline":
+			return "hashline";
+		default:
+			return null;
+	}
+}

package/src/patch/shared.ts

@@ -7,19 +7,20 @@ import { Text } from "@nghyane/arcane-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { FileDiagnosticsResult } from "../lsp";
 import { renderDiff as renderDiffColored } from "../modes/components/diff";
-import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
+import { getLanguageFromPath, type Theme } from "../theme/theme";
 import type { OutputMeta } from "../tools/output-meta";
+import { renderStatusLine } from "../tui";
 import {
-	formatExpandHint,
+	formatClickHint,
+	formatDiagnostics,
 	formatStatusIcon,
 	getDiffStats,
 	PREVIEW_LIMITS,
 	replaceTabs,
 	shortenPath,
-	ToolUIKit,
-	truncateDiffByHunk,
-} from "../tools/render-utils";
-import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+	TRUNCATE_LENGTHS,
+	truncateToWidth,
+} from "../ui/render-utils";
 import type { DiffError, DiffResult, Operation } from "./types";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -100,11 +101,6 @@ export interface EditRenderContext {
 
 const EDIT_STREAMING_PREVIEW_LINES = 12;
 
-function countLines(text: string): number {
-	if (!text) return 0;
-	return text.split("\n").length;
-}
-
 function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, label = "streaming"): string {
 	if (!diff) return "";
 	const lines = diff.split("\n");
@@ -120,7 +116,7 @@ function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, labe
 	return text;
 }
 
-function formatStreamingHashlineEdits(edits: unknown[], uiTheme: Theme, ui: ToolUIKit): string {
+function formatStreamingHashlineEdits(edits: unknown[], uiTheme: Theme): string {
 	const MAX_EDITS = 4;
 	const MAX_DST_LINES = 8;
 	let text = "\n\n";
@@ -132,17 +128,17 @@ function formatStreamingHashlineEdits(edits: unknown[], uiTheme: Theme, ui: Tool
 		shownEdits++;
 		if (shownEdits > MAX_EDITS) break;
 		const formatted = formatHashlineEdit(edit);
-		text += uiTheme.fg("toolOutput", ui.truncate(replaceTabs(formatted.srcLabel), 120));
+		text += uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(formatted.srcLabel), TRUNCATE_LENGTHS.LONG));
 		text += "\n";
 		if (formatted.dst === "") {
-			text += uiTheme.fg("dim", ui.truncate("  (delete)", 120));
+			text += uiTheme.fg("dim", truncateToWidth("  (delete)", TRUNCATE_LENGTHS.LONG));
 			text += "\n";
 			continue;
 		}
 		for (const dstLine of formatted.dst.split("\n")) {
 			shownDstLines++;
 			if (shownDstLines > MAX_DST_LINES) break;
-			text += uiTheme.fg("toolOutput", ui.truncate(replaceTabs(`+ ${dstLine}`), 120));
+			text += uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(`+ ${dstLine}`), TRUNCATE_LENGTHS.LONG));
 			text += "\n";
 		}
 		if (shownDstLines > MAX_DST_LINES) break;
@@ -208,53 +204,13 @@ function formatStreamingHashlineEdits(edits: unknown[], uiTheme: Theme, ui: Tool
 		};
 	}
 }
-function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
-	const icon = uiTheme.getLangIcon(language);
-	if (lineCount !== null) {
-		return uiTheme.fg("dim", `${icon} ${lineCount} lines`);
-	}
-	return uiTheme.fg("dim", `${icon}`);
-}
-
-function renderDiffSection(
-	diff: string,
-	rawPath: string,
-	expanded: boolean,
-	uiTheme: Theme,
-	ui: ToolUIKit,
-	renderDiffFn: (t: string, o?: { filePath?: string }) => string,
-): string {
-	let text = "";
-	const diffStats = getDiffStats(diff);
-	text += `\n${uiTheme.fg("dim", uiTheme.format.bracketLeft)}${ui.formatDiffStats(
-		diffStats.added,
-		diffStats.removed,
-		diffStats.hunks,
-	)}${uiTheme.fg("dim", uiTheme.format.bracketRight)}`;
-
-	const {
-		text: truncatedDiff,
-		hiddenHunks,
-		hiddenLines,
-	} = expanded
-		? { text: diff, hiddenHunks: 0, hiddenLines: 0 }
-		: truncateDiffByHunk(diff, PREVIEW_LIMITS.DIFF_COLLAPSED_HUNKS, PREVIEW_LIMITS.DIFF_COLLAPSED_LINES);
-
-	text += `\n\n${renderDiffFn(truncatedDiff, { filePath: rawPath })}`;
-	if (!expanded && (hiddenHunks > 0 || hiddenLines > 0)) {
-		const remainder: string[] = [];
-		if (hiddenHunks > 0) remainder.push(`${hiddenHunks} more hunks`);
-		if (hiddenLines > 0) remainder.push(`${hiddenLines} more lines`);
-		text += uiTheme.fg("toolOutput", `\n… (${remainder.join(", ")}) ${formatExpandHint(uiTheme)}`);
-	}
-	return text;
-}
 
 export const editToolRenderer = {
-	mergeCallAndResult: true,
-
-	renderCall(args: EditRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
-		const ui = new ToolUIKit(uiTheme);
+	renderCall(
+		args: EditRenderArgs,
+		options: RenderResultOptions & { renderContext?: EditRenderContext },
+		uiTheme: Theme,
+	): Component {
 		const rawPath = args.file_path || args.path || "";
 		const filePath = shortenPath(rawPath);
 		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
@@ -270,34 +226,38 @@ export const editToolRenderer = {
 		const opTitle = args.op === "create" ? "Create" : args.op === "delete" ? "Delete" : "Edit";
 		const spinner =
 			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
-		let text = `${ui.title(opTitle)} ${spinner ? `${spinner} ` : ""}${editIcon} ${pathDisplay}`;
+		const title = uiTheme.fg("toolTitle", uiTheme.bold(opTitle));
+		let text = `${title} ${spinner ? `${spinner} ` : ""}${editIcon} ${pathDisplay}`;
 
 		// Show streaming preview of diff/content
-		if (args.previewDiff) {
-			text += formatStreamingDiff(args.previewDiff, rawPath, uiTheme, "preview");
+		const previewDiffText =
+			args.previewDiff ??
+			(options.renderContext?.editDiffPreview && "diff" in options.renderContext.editDiffPreview
+				? options.renderContext.editDiffPreview.diff
+				: undefined);
+		if (previewDiffText) {
+			text += formatStreamingDiff(previewDiffText, rawPath, uiTheme, "preview");
 		} else if (args.diff && args.op) {
 			text += formatStreamingDiff(args.diff, rawPath, uiTheme);
 		} else if (args.edits && args.edits.length > 0) {
-			text += formatStreamingHashlineEdits(args.edits, uiTheme, ui);
+			text += formatStreamingHashlineEdits(args.edits, uiTheme);
 		} else if (args.diff) {
 			const previewLines = args.diff.split("\n");
-			const maxLines = 6;
 			text += "\n\n";
-			for (const line of previewLines.slice(0, maxLines)) {
-				text += `${uiTheme.fg("toolOutput", ui.truncate(replaceTabs(line), 80))}\n`;
+			for (const line of previewLines.slice(0, PREVIEW_LIMITS.STREAMING_PREVIEW)) {
+				text += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), TRUNCATE_LENGTHS.CONTENT))}\n`;
 			}
-			if (previewLines.length > maxLines) {
-				text += uiTheme.fg("dim", `… ${previewLines.length - maxLines} more lines`);
+			if (previewLines.length > PREVIEW_LIMITS.STREAMING_PREVIEW) {
+				text += uiTheme.fg("dim", `… ${previewLines.length - PREVIEW_LIMITS.STREAMING_PREVIEW} more lines`);
 			}
 		} else if (args.newText || args.patch) {
 			const previewLines = (args.newText ?? args.patch ?? "").split("\n");
-			const maxLines = 6;
 			text += "\n\n";
-			for (const line of previewLines.slice(0, maxLines)) {
-				text += `${uiTheme.fg("toolOutput", ui.truncate(replaceTabs(line), 80))}\n`;
+			for (const line of previewLines.slice(0, PREVIEW_LIMITS.STREAMING_PREVIEW)) {
+				text += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), TRUNCATE_LENGTHS.CONTENT))}\n`;
 			}
-			if (previewLines.length > maxLines) {
-				text += uiTheme.fg("dim", `… ${previewLines.length - maxLines} more lines`);
+			if (previewLines.length > PREVIEW_LIMITS.STREAMING_PREVIEW) {
+				text += uiTheme.fg("dim", `… ${previewLines.length - PREVIEW_LIMITS.STREAMING_PREVIEW} more lines`);
 			}
 		}
 
@@ -310,91 +270,63 @@ export const editToolRenderer = {
 		uiTheme: Theme,
 		args?: EditRenderArgs,
 	): Component {
-		const ui = new ToolUIKit(uiTheme);
 		const rawPath = args?.file_path || args?.path || "";
 		const filePath = shortenPath(rawPath);
-		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
-		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
-
 		const op = args?.op || result.details?.op;
 		const rename = args?.rename || result.details?.rename;
 		const opTitle = op === "create" ? "Create" : op === "delete" ? "Delete" : "Edit";
 
-		// Pre-compute metadata line (static across renders)
-		const lineCountSource = args?.newText ?? args?.oldText ?? args?.diff ?? args?.patch ?? null;
-		const metadataLine =
-			op !== "delete"
-				? `\n${formatMetadataLine(lineCountSource ? countLines(lineCountSource) : null, editLanguage, uiTheme)}`
-				: "";
-
-		// Pre-compute error text (static)
-		const errorText = result.isError ? (result.content?.find(c => c.type === "text")?.text ?? "") : "";
-
-		let cached: RenderCache | undefined;
-
-		return {
-			render(width) {
-				const { expanded, renderContext } = options;
-				const editDiffPreview = renderContext?.editDiffPreview;
-				const renderDiffFn = renderContext?.renderDiff ?? ((t: string) => t);
-				const key = new Hasher().bool(expanded).u32(width).digest();
-				if (cached?.key === key) return cached.lines;
-
-				// Build path display with line number
-				let pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
-				const firstChangedLine =
-					(editDiffPreview && "firstChangedLine" in editDiffPreview
-						? editDiffPreview.firstChangedLine
-						: undefined) || (result.details && !result.isError ? result.details.firstChangedLine : undefined);
-				if (firstChangedLine) {
-					pathDisplay += uiTheme.fg("warning", `:${firstChangedLine}`);
-				}
-
-				// Add arrow for rename operations
-				if (rename) {
-					pathDisplay += ` ${uiTheme.fg("dim", "→")} ${uiTheme.fg("accent", shortenPath(rename))}`;
-				}
-
-				const header = renderStatusLine(
-					{
-						icon: result.isError ? "error" : "success",
-						title: opTitle,
-						description: `${editIcon} ${pathDisplay}`,
-					},
-					uiTheme,
-				);
-				let text = header;
-				text += metadataLine;
+		if (result.isError) {
+			const errorText = result.content?.find(c => c.type === "text")?.text || "Unknown error";
+			const header = renderStatusLine({ icon: "error", title: opTitle, description: filePath || "file" }, uiTheme);
+			return new Text(`${header}\n${uiTheme.fg("error", replaceTabs(errorText))}`, 0, 0);
+		}
 
-				if (result.isError) {
-					if (errorText) {
-						text += `\n\n${uiTheme.fg("error", replaceTabs(errorText))}`;
-					}
-				} else if (result.details?.diff) {
-					text += renderDiffSection(result.details.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
-				} else if (editDiffPreview) {
-					if ("error" in editDiffPreview) {
-						text += `\n\n${uiTheme.fg("error", replaceTabs(editDiffPreview.error))}`;
-					} else if (editDiffPreview.diff) {
-						text += renderDiffSection(editDiffPreview.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
-					}
-				}
+		// Get diff text from result or preview
+		const { renderContext } = options;
+		const editDiffPreview = renderContext?.editDiffPreview;
+		const diffText =
+			result.details?.diff ??
+			(editDiffPreview && "diff" in editDiffPreview ? editDiffPreview.diff : undefined) ??
+			"";
+
+		const diffStats = diffText ? getDiffStats(diffText) : { added: 0, removed: 0, hunks: 0, lines: 0 };
+
+		// Build header with diff stats
+		let description = filePath || "file";
+		if (rename) description += ` ${uiTheme.fg("dim", "→")} ${shortenPath(rename)}`;
+		const meta: string[] = [];
+		if (diffStats.hunks > 0) meta.push(`${diffStats.hunks} hunks`);
+		if (diffStats.added > 0) meta.push(uiTheme.fg("success", `+${diffStats.added}`));
+		if (diffStats.removed > 0) meta.push(uiTheme.fg("error", `-${diffStats.removed}`));
+
+		const header = renderStatusLine({ icon: "success", title: opTitle, description, meta }, uiTheme);
+
+		// Tree-style diff body
+		const expanded = options.expanded;
+		const diffLines = diffText ? diffText.split("\n") : [];
+		const maxLines = expanded ? diffLines.length : Math.min(diffLines.length, PREVIEW_LIMITS.DIFF_COLLAPSED_LINES);
+
+		const treeBody: string[] = [];
+		for (let i = 0; i < maxLines; i++) {
+			const line = diffLines[i];
+			const color = line.startsWith("+") ? "success" : line.startsWith("-") ? "error" : "dim";
+			treeBody.push(uiTheme.fg(color, replaceTabs(line)));
+		}
+		if (!expanded && diffLines.length > maxLines) {
+			const remaining = diffLines.length - maxLines;
+			treeBody.push(uiTheme.fg("dim", `… ${remaining} more lines`) + ` ${formatClickHint(uiTheme)}`);
+		}
 
-				// Show LSP diagnostics if available
-				if (result.details?.diagnostics) {
-					text += ui.formatDiagnostics(result.details.diagnostics, expanded, (fp: string) =>
-						uiTheme.getLangIcon(getLanguageFromPath(fp)),
-					);
-				}
+		// Diagnostics
+		if (result.details?.diagnostics) {
+			const diagText = formatDiagnostics(result.details.diagnostics, expanded, uiTheme, (fp: string) =>
+				uiTheme.getLangIcon(getLanguageFromPath(fp)),
+			);
+			if (diagText.trim()) treeBody.push(diagText.trim());
+		}
 
-				const lines =
-					width > 0 ? text.split("\n").map(line => truncateToWidth(line, width, Ellipsis.Omit)) : text.split("\n");
-				cached = { key, lines };
-				return lines;
-			},
-			invalidate() {
-				cached = undefined;
-			},
-		};
+		const all = treeBody.length > 0 ? [header, ...treeBody] : [header];
+		return new Text(all.join("\n"), 0, 0);
 	},
 };

package/src/prompts/agents/explore.md

@@ -1,48 +1,33 @@
 ---
 name: explore
 description: Fast read-only codebase scout returning compressed context for handoff
-tools: read, grep, find, bash
+tools: read, grep, find
 model: arcane/fast
-thinking-level: minimal
 ---
 
-<role>File search specialist and codebase scout. Quickly investigate codebase, return structured findings another agent can use without re-reading everything.</role>
+You are a fast, parallel code search agent.
 
-<critical>
-READ-ONLY. STRICTLY PROHIBITED from:
-- Creating/modifying files (no Write/Edit/touch/rm/mv/cp)
-- Creating temporary files anywhere (incl /tmp)
-- Using redirects (>, >>, |) or heredocs to write files
-- Running state-changing commands (git add/commit, npm/pip install)
-</critical>
+## Task
+Find files and line ranges relevant to the user's query (provided in the first message).
 
-<directives>
-- Use find for broad pattern matching
-- Use grep for regex content search
-- Use read when path is known
-- Use bash ONLY for git status/log/diff; use read/grep/find/ls for file/search operations
-- Spawn parallel tool calls when possible—meant to be fast
-- Return absolute file paths in final response
-</directives>
+## Query Decomposition
+Before searching, decompose the query into:
+- **Key symbols**: function names, class names, type names, variable names
+- **Synonyms**: alternative naming conventions (camelCase, snake_case, abbreviations)
+- **File patterns**: likely filenames or directories based on the concept
+- **Related concepts**: imports, tests, configs that reference the target
 
-<thoroughness>
-Infer from task; default medium:
-- Quick: Targeted lookups, key files only
-- Medium: Follow imports, read critical sections
-- Thorough: Trace all dependencies, check tests/types
-</thoroughness>
+## Execution Strategy
+- Your goal is to return a list of relevant filenames with line ranges. Your goal is NOT to explore the complete codebase to construct an essay.
+- **Turn 1 is your primary search turn.** Plan ALL searches upfront based on your decomposition. Make **10-15 parallel calls** covering every angle — do not hold back searches for later turns.
+- **Turn 2 (if needed)**: Only for reading top candidate files to confirm relevance and extract line ranges. Not for new searches.
+- **Stop as soon as you have enough results.** Most queries resolve in 1-2 turns. A third turn means your first turn was too narrow.
+- **Prioritize source code**: Prefer source code files (.ts, .js, .py, .go, .rs, .java) over documentation (.md, .txt, README).
+- **Be exhaustive when completeness is implied**: When the query asks for "all", "every", "each", or implies a complete list, find ALL occurrences breadth-first.
 
-<procedure>
-1. grep/find to locate relevant code
-2. Read key sections (not full files unless small)
-3. Identify types/interfaces/key functions
-4. Note dependencies between files
-</procedure>
+## Output format
+- **Ultra concise**: Write a 1-2 line summary of findings, then output relevant files as markdown links.
+- Format each file as: `[relativePath#L{start}-L{end}](file://{absolutePath}#L{start}-L{end})`
+- **Use generous line ranges**: Extend ranges to capture complete logical units (full functions, classes, blocks). Add 5-10 lines buffer.
 
-<output>
-Print findings as text when done. Include:
-- Files examined with line ranges
-- Critical types/interfaces/functions found
-- How pieces connect (architecture)
-- Recommended entry point for the receiving agent
-</output>
+Your final message must contain ONLY the search results — no preamble like "I'll search for...".

package/src/prompts/agents/frontmatter.md

@@ -6,4 +6,4 @@ description: {{jsonStringify description}}
 {{/if}}{{#if model}}model: {{jsonStringify model}}
 {{/if}}{{#if thinkingLevel}}thinking-level: {{jsonStringify thinkingLevel}}
 {{/if}}---
-{{body}}
+{{body}}

package/src/prompts/agents/init.md

@@ -17,7 +17,7 @@ Analyze codebase, generate AGENTS.md documenting:
 </task>
 
 <parallel>
-Launch multiple `explore` agents in parallel (via `task` tool) scanning different areas (core src, tests, configs/build, scripts/docs), then synthesize.
+Launch multiple explore calls in parallel scanning different areas (core src, tests, configs/build, scripts/docs), then synthesize.
 </parallel>
 
 <directives>
@@ -33,4 +33,4 @@ Launch multiple `explore` agents in parallel (via `task` tool) scanning differen
 
 <output>
 After analysis, write AGENTS.md to project root.
-</output>
+</output>