@oh-my-pi/pi-coding-agent 14.2.1 → 14.4.0

package/src/cursor.ts

@@ -177,16 +177,11 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 
 	async grep(args: Parameters<NonNullable<ICursorExecHandlers["grep"]>>[0]) {
 		const toolCallId = decodeToolCallId(args.toolCallId);
+		const grepPath = args.glob ? `${args.path || "."}/${args.glob}` : args.path || ".";
 		const toolResultMessage = await executeTool(this.options, "grep", toolCallId, {
 			pattern: args.pattern,
-			path: args.path || undefined,
-			glob: args.glob || undefined,
-			mode: args.outputMode || undefined,
-			context: args.context ?? args.contextBefore ?? args.contextAfter ?? undefined,
-			ignore_case: args.caseInsensitive || undefined,
-			type: args.type || undefined,
-			limit: args.headLimit ?? undefined,
-			multiline: args.multiline || undefined,
+			path: grepPath,
+			i: args.caseInsensitive || undefined,
 		});
 		return toolResultMessage;
 	}

package/src/debug/system-info.ts

@@ -40,8 +40,12 @@ function macosMarketingName(release: string): string | undefined {
 
 /** Collect system information */
 export async function collectSystemInfo(): Promise<SystemInfo> {
-	const cpus = os.cpus();
-	const cpuModel = cpus[0]?.model ?? "Unknown CPU";
+	let cpuModel = "Unknown CPU";
+	try {
+		cpuModel = os.cpus()[0]?.model ?? cpuModel;
+	} catch {
+		// Keep debug report collection best-effort when CPU probing fails.
+	}
 
 	// Try to get shell from environment
 	const shell = Bun.env.SHELL ?? Bun.env.ComSpec ?? "unknown";

package/src/discovery/claude.ts

@@ -18,6 +18,7 @@ import { type SlashCommand, slashCommandCapability } from "../capability/slash-c
 import { type SystemPrompt, systemPromptCapability } from "../capability/system-prompt";
 import { type CustomTool, toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
+import { settings } from "../config/settings";
 import {
 	calculateDepth,
 	createSourceMeta,
@@ -252,48 +253,69 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 // Slash Commands
 // =============================================================================
 
+/**
+ * Read the Claude command-loading toggles from settings.
+ * Falls back to true (current behavior) when settings are not initialized,
+ * e.g. inside discovery unit tests that run without Settings.init().
+ */
+function readClaudeCommandToggles(): { enableUser: boolean; enableProject: boolean } {
+	try {
+		return {
+			enableUser: settings.get("commands.enableClaudeUser") ?? true,
+			enableProject: settings.get("commands.enableClaudeProject") ?? true,
+		};
+	} catch {
+		return { enableUser: true, enableProject: true };
+	}
+}
+
 async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
 	const items: SlashCommand[] = [];
 	const warnings: string[] = [];
+	const { enableUser, enableProject } = readClaudeCommandToggles();
+
+	if (enableUser) {
+		const userBase = getUserClaude(ctx);
+		const userCommandsDir = path.join(userBase, "commands");
+
+		const userResult = await loadFilesFromDir<SlashCommand>(ctx, userCommandsDir, PROVIDER_ID, "user", {
+			extensions: ["md"],
+			transform: (name, content, path, source) => {
+				const cmdName = name.replace(/\.md$/, "");
+				return {
+					name: cmdName,
+					path,
+					content,
+					level: "user",
+					_source: source,
+				};
+			},
+		});
 
-	const userBase = getUserClaude(ctx);
-	const userCommandsDir = path.join(userBase, "commands");
-
-	const userResult = await loadFilesFromDir<SlashCommand>(ctx, userCommandsDir, PROVIDER_ID, "user", {
-		extensions: ["md"],
-		transform: (name, content, path, source) => {
-			const cmdName = name.replace(/\.md$/, "");
-			return {
-				name: cmdName,
-				path,
-				content,
-				level: "user",
-				_source: source,
-			};
-		},
-	});
-
-	items.push(...userResult.items);
-	if (userResult.warnings) warnings.push(...userResult.warnings);
-
-	const projectCommandsDir = path.join(ctx.cwd, CONFIG_DIR, "commands");
+		items.push(...userResult.items);
+		if (userResult.warnings) warnings.push(...userResult.warnings);
+	}
 
-	const projectResult = await loadFilesFromDir<SlashCommand>(ctx, projectCommandsDir, PROVIDER_ID, "project", {
-		extensions: ["md"],
-		transform: (name, content, path, source) => {
-			const cmdName = name.replace(/\.md$/, "");
-			return {
-				name: cmdName,
-				path,
-				content,
-				level: "project",
-				_source: source,
-			};
-		},
-	});
+	if (enableProject) {
+		const projectCommandsDir = path.join(ctx.cwd, CONFIG_DIR, "commands");
+
+		const projectResult = await loadFilesFromDir<SlashCommand>(ctx, projectCommandsDir, PROVIDER_ID, "project", {
+			extensions: ["md"],
+			transform: (name, content, path, source) => {
+				const cmdName = name.replace(/\.md$/, "");
+				return {
+					name: cmdName,
+					path,
+					content,
+					level: "project",
+					_source: source,
+				};
+			},
+		});
 
-	items.push(...projectResult.items);
-	if (projectResult.warnings) warnings.push(...projectResult.warnings);
+		items.push(...projectResult.items);
+		if (projectResult.warnings) warnings.push(...projectResult.warnings);
+	}
 
 	return { items, warnings };
 }

package/src/discovery/helpers.ts

@@ -221,9 +221,9 @@ export function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAg
 
 	let tools = parseArrayOrCSV(frontmatter.tools)?.map(tool => tool.toLowerCase());
 
-	// Subagents with explicit tool lists always need submit_result
-	if (tools && !tools.includes("submit_result")) {
-		tools = [...tools, "submit_result"];
+	// Subagents with explicit tool lists always need yield
+	if (tools && !tools.includes("yield")) {
+		tools = [...tools, "yield"];
 	}
 
 	// Parse spawns field (array, "*", or CSV)

package/src/discovery/opencode.ts

@@ -26,6 +26,7 @@ import { type Settings, settingsCapability } from "../capability/settings";
 import { type Skill, skillCapability } from "../capability/skill";
 import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import { settings } from "../config/settings";
 
 import {
 	buildExtensionModuleItems,
@@ -236,9 +237,26 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 // Slash Commands (commands/)
 // =============================================================================
 
+/**
+ * Read the OpenCode command-loading toggles from settings.
+ * Falls back to true (current behavior) when settings are not initialized,
+ * e.g. inside discovery unit tests that run without Settings.init().
+ */
+function readOpencodeCommandToggles(): { enableUser: boolean; enableProject: boolean } {
+	try {
+		return {
+			enableUser: settings.get("commands.enableOpencodeUser") ?? true,
+			enableProject: settings.get("commands.enableOpencodeProject") ?? true,
+		};
+	} catch {
+		return { enableUser: true, enableProject: true };
+	}
+}
+
 async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
-	const userCommandsDir = getUserPath(ctx, "opencode", "commands");
-	const projectCommandsDir = getProjectPath(ctx, "opencode", "commands");
+	const { enableUser, enableProject } = readOpencodeCommandToggles();
+	const userCommandsDir = enableUser ? getUserPath(ctx, "opencode", "commands") : null;
+	const projectCommandsDir = enableProject ? getProjectPath(ctx, "opencode", "commands") : null;
 
 	const transformCommand =
 		(level: "user" | "project") => (name: string, content: string, filePath: string, source: SourceMeta) => {

package/src/edit/diff.ts

@@ -50,17 +50,8 @@ export class ApplyPatchError extends Error {
 // Diff String Generation
 // ═══════════════════════════════════════════════════════════════════════════
 
-function countContentLines(content: string): number {
-	const lines = content.split("\n");
-	if (lines.length > 1 && lines[lines.length - 1] === "") {
-		lines.pop();
-	}
-	return Math.max(1, lines.length);
-}
-
-function formatNumberedDiffLine(prefix: "+" | "-" | " ", lineNum: number, width: number, content: string): string {
-	const padded = String(lineNum).padStart(width, " ");
-	return `${prefix}${padded}|${content}`;
+function formatNumberedDiffLine(prefix: "+" | "-" | " ", lineNum: number, content: string): string {
+	return `${prefix}${lineNum}|${content}`;
 }
 
 /**
@@ -71,9 +62,6 @@ export function generateDiffString(oldContent: string, newContent: string, conte
 	const parts = Diff.diffLines(oldContent, newContent);
 	const output: string[] = [];
 
-	const maxLineNum = Math.max(countContentLines(oldContent), countContentLines(newContent));
-	const lineNumWidth = String(maxLineNum).length;
-
 	let oldLineNum = 1;
 	let newLineNum = 1;
 	let lastWasChange = false;
@@ -95,10 +83,10 @@ export function generateDiffString(oldContent: string, newContent: string, conte
 			// Show the change
 			for (const line of raw) {
 				if (part.added) {
-					output.push(formatNumberedDiffLine("+", newLineNum, lineNumWidth, line));
+					output.push(formatNumberedDiffLine("+", newLineNum, line));
 					newLineNum++;
 				} else {
-					output.push(formatNumberedDiffLine("-", oldLineNum, lineNumWidth, line));
+					output.push(formatNumberedDiffLine("-", oldLineNum, line));
 					oldLineNum++;
 				}
 			}
@@ -108,40 +96,57 @@ export function generateDiffString(oldContent: string, newContent: string, conte
 			const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
 
 			if (lastWasChange || nextPartIsChange) {
-				let linesToShow = raw;
-				let skipStart = 0;
-				let skipEnd = 0;
-
-				if (!lastWasChange) {
-					// Show only last N lines as leading context
-					skipStart = Math.max(0, raw.length - contextLines);
-					linesToShow = raw.slice(skipStart);
-				}
-
-				if (!nextPartIsChange && linesToShow.length > contextLines) {
-					// Show only first N lines as trailing context
-					skipEnd = linesToShow.length - contextLines;
-					linesToShow = linesToShow.slice(0, contextLines);
+				const contextLimit = Math.max(0, contextLines);
+				let leadingSkip = 0;
+				let middleSkip = 0;
+				let trailingSkip = 0;
+				let linesToShow: string[];
+
+				if (lastWasChange && nextPartIsChange) {
+					if (raw.length > contextLimit * 2) {
+						const leadingContext = raw.slice(0, contextLimit);
+						const trailingContext = raw.slice(raw.length - contextLimit);
+						middleSkip = raw.length - leadingContext.length - trailingContext.length;
+						linesToShow = [...leadingContext, ...trailingContext];
+					} else {
+						linesToShow = raw;
+					}
+				} else if (nextPartIsChange) {
+					leadingSkip = Math.max(0, raw.length - contextLimit);
+					linesToShow = raw.slice(leadingSkip);
+				} else {
+					trailingSkip = Math.max(0, raw.length - contextLimit);
+					linesToShow = raw.slice(0, contextLimit);
 				}
 
-				// Add ellipsis if we skipped lines at start
-				if (skipStart > 0) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, lineNumWidth, "..."));
-					oldLineNum += skipStart;
-					newLineNum += skipStart;
+				if (leadingSkip > 0) {
+					output.push(formatNumberedDiffLine(" ", oldLineNum, "..."));
+					oldLineNum += leadingSkip;
+					newLineNum += leadingSkip;
 				}
 
-				for (const line of linesToShow) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, lineNumWidth, line));
+				const firstChunkLength = middleSkip > 0 ? contextLimit : linesToShow.length;
+				for (const line of linesToShow.slice(0, firstChunkLength)) {
+					output.push(formatNumberedDiffLine(" ", oldLineNum, line));
 					oldLineNum++;
 					newLineNum++;
 				}
 
-				// Add ellipsis if we skipped lines at end
-				if (skipEnd > 0) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, lineNumWidth, "..."));
-					oldLineNum += skipEnd;
-					newLineNum += skipEnd;
+				if (middleSkip > 0) {
+					output.push(formatNumberedDiffLine(" ", oldLineNum, "..."));
+					oldLineNum += middleSkip;
+					newLineNum += middleSkip;
+					for (const line of linesToShow.slice(firstChunkLength)) {
+						output.push(formatNumberedDiffLine(" ", oldLineNum, line));
+						oldLineNum++;
+						newLineNum++;
+					}
+				}
+
+				if (trailingSkip > 0) {
+					output.push(formatNumberedDiffLine(" ", oldLineNum, "..."));
+					oldLineNum += trailingSkip;
+					newLineNum += trailingSkip;
 				}
 			} else {
 				// Skip these context lines entirely
@@ -184,8 +189,6 @@ export function generateUnifiedDiffString(oldContent: string, newContent: string
 	const patch = Diff.structuredPatch("", "", oldContent, newContent, "", "", { context: contextLines });
 	const output: string[] = [];
 	let firstChangedLine: number | undefined;
-	const maxLineNum = Math.max(countContentLines(oldContent), countContentLines(newContent));
-	const lineNumWidth = String(maxLineNum).length;
 	for (const hunk of patch.hunks) {
 		output.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
 		let oldLine = hunk.oldStart;
@@ -193,18 +196,18 @@ export function generateUnifiedDiffString(oldContent: string, newContent: string
 		for (const line of hunk.lines) {
 			if (line.startsWith("-")) {
 				if (firstChangedLine === undefined) firstChangedLine = newLine;
-				output.push(formatNumberedDiffLine("-", oldLine, lineNumWidth, line.slice(1)));
+				output.push(formatNumberedDiffLine("-", oldLine, line.slice(1)));
 				oldLine++;
 				continue;
 			}
 			if (line.startsWith("+")) {
 				if (firstChangedLine === undefined) firstChangedLine = newLine;
-				output.push(formatNumberedDiffLine("+", newLine, lineNumWidth, line.slice(1)));
+				output.push(formatNumberedDiffLine("+", newLine, line.slice(1)));
 				newLine++;
 				continue;
 			}
 			if (line.startsWith(" ")) {
-				output.push(formatNumberedDiffLine(" ", oldLine, lineNumWidth, line.slice(1)));
+				output.push(formatNumberedDiffLine(" ", oldLine, line.slice(1)));
 				oldLine++;
 				newLine++;
 				continue;

package/src/edit/index.ts

@@ -9,6 +9,7 @@ import {
 	writethroughNoop,
 } from "../lsp";
 import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
+import atomDescription from "../prompts/tools/atom.md" with { type: "text" };
 import chunkEditDescription from "../prompts/tools/chunk-edit.md" with { type: "text" };
 import hashlineDescription from "../prompts/tools/hashline.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
@@ -17,44 +18,33 @@ import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
-import {
-	type ApplyPatchParams,
-	applyPatchSchema,
-	expandApplyPatchToEntries,
-	isApplyPatchParams,
-} from "./modes/apply-patch";
+import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
+import {
+	type AtomParams,
+	type AtomToolEdit,
+	atomEditParamsSchema,
+	executeAtomSingle,
+	resolveAtomEntryPaths,
+} from "./modes/atom";
 import {
 	type ChunkParams,
 	type ChunkToolEdit,
 	chunkEditParamsSchema,
 	executeChunkSingle,
-	isChunkParams,
 	parseChunkEditPath,
 	resolveAnchorStyle,
 	resolveChunkAutoIndent,
 } from "./modes/chunk";
 import {
 	executeHashlineSingle,
+	HashlineMismatchError,
 	type HashlineParams,
 	type HashlineToolEdit,
 	hashlineEditParamsSchema,
-	isHashlineParams,
 } from "./modes/hashline";
-import {
-	executePatchSingle,
-	isPatchParams,
-	type PatchEditEntry,
-	type PatchParams,
-	patchEditSchema,
-} from "./modes/patch";
-import {
-	executeReplaceSingle,
-	isReplaceParams,
-	type ReplaceEditEntry,
-	type ReplaceParams,
-	replaceEditSchema,
-} from "./modes/replace";
+import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
+import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
@@ -62,30 +52,38 @@ export * from "./apply-patch";
 export * from "./diff";
 export * from "./line-hash";
 export * from "./modes/apply-patch";
+export * from "./modes/atom";
 export * from "./modes/chunk";
 export * from "./modes/hashline";
 export * from "./modes/patch";
 export * from "./modes/replace";
 export * from "./normalize";
 export * from "./renderer";
+export * from "./streaming";
 
 type TInput =
 	| typeof replaceEditSchema
 	| typeof patchEditSchema
 	| typeof hashlineEditParamsSchema
+	| typeof atomEditParamsSchema
 	| typeof chunkEditParamsSchema
 	| typeof vimSchema
 	| typeof applyPatchSchema;
 
 type VimParams = Static<typeof vimSchema>;
-type EditParams = ReplaceParams | PatchParams | HashlineParams | ChunkParams | VimParams | ApplyPatchParams;
+type EditParams =
+	| ReplaceParams
+	| PatchParams
+	| HashlineParams
+	| AtomParams
+	| ChunkParams
+	| VimParams
+	| ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;
 
 type EditModeDefinition = {
 	description: (session: ToolSession) => string;
 	parameters: TInput;
-	invalidParamsMessage: string;
-	validate: (params: EditParams) => boolean;
 	execute: (
 		tool: EditTool,
 		params: EditParams,
@@ -108,10 +106,6 @@ function resolveConfiguredEditMode(rawEditMode: string): EditMode | undefined {
 	return editMode;
 }
 
-function isVimParams(params: EditParams): params is VimParams {
-	return typeof params === "object" && params !== null && "file" in params && typeof params.file === "string";
-}
-
 function resolveAllowFuzzy(session: ToolSession, rawValue: string): boolean {
 	switch (rawValue) {
 		case "true":
@@ -147,6 +141,25 @@ function createEditWritethrough(session: ToolSession): WritethroughCallback {
 	return enableLsp ? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics }) : writethroughNoop;
 }
 
+/**
+ * Resolve per-entry `path` against an optional top-level `path` default.
+ * If both are absent on an entry, throws a descriptive error.
+ */
+function resolveEntryPaths<T extends { path?: string }>(
+	edits: readonly T[],
+	topLevelPath: string | undefined,
+): (T & { path: string })[] {
+	return edits.map((edit, i) => {
+		const path = (edit && typeof edit.path === "string" && edit.path) || topLevelPath;
+		if (!path) {
+			throw new Error(
+				`Edit ${i}: missing \`path\`. Provide \`path\` on this edit or supply a top-level \`path\` for the request.`,
+			);
+		}
+		return { ...edit, path };
+	});
+}
+
 /** Group items by a key, preserving insertion order. */
 function groupBy<T, K>(items: T[], key: (item: T) => K): Map<K, T[]> {
 	const map = new Map<K, T[]>();
@@ -202,7 +215,8 @@ async function executePerFile(
 			if (text) contentTexts.push(text);
 		} catch (err) {
 			const errorText = err instanceof Error ? err.message : String(err);
-			perFileResults.push({ path, diff: "", isError: true, errorText });
+			const displayErrorText = err instanceof HashlineMismatchError ? err.displayMessage : undefined;
+			perFileResults.push({ path, diff: "", isError: true, errorText, displayErrorText });
 			contentTexts.push(`Error editing ${path}: ${errorText}`);
 		}
 
@@ -306,10 +320,6 @@ export class EditTool implements AgentTool<TInput> {
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<EditToolResultDetails, TInput>> {
 		const modeDefinition = this.#getModeDefinition();
-		if (!modeDefinition.validate(params)) {
-			throw new Error(modeDefinition.invalidParamsMessage);
-		}
-
 		return modeDefinition.execute(this, params, signal, getLspBatchRequest(context?.toolCall), onUpdate);
 	}
 
@@ -322,9 +332,6 @@ export class EditTool implements AgentTool<TInput> {
 						chunkAutoIndent: resolveChunkAutoIndent(),
 					}),
 				parameters: chunkEditParamsSchema,
-				invalidParamsMessage:
-					"Invalid edit parameters for chunk mode. Expected `{ edits: [{ path: 'file:selector', ...op }, ...] }` with at least one edit. Each edit needs a `path`; supply one of `write` (string content; pass an empty string or omit it together with `replace`/`insert` to delete the chunk), `replace: { old, new }`, or `insert: { loc, body }`.",
-				validate: isChunkParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -332,8 +339,9 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits } = params as ChunkParams;
-					const byFile = groupBy(edits, (e: ChunkToolEdit) => parseChunkEditPath(e.path).filePath);
+					const { edits, path: topPath } = params as ChunkParams & { path?: string };
+					const resolved = resolveEntryPaths(edits as ChunkToolEdit[], topPath);
+					const byFile = groupBy(resolved, (e: ChunkToolEdit) => parseChunkEditPath(e.path).filePath);
 					const entries = [...byFile.entries()].map(([filePath, fileEdits]) => ({
 						path: filePath,
 						run: (br: LspBatchRequest | undefined) =>
@@ -353,8 +361,6 @@ export class EditTool implements AgentTool<TInput> {
 			patch: {
 				description: () => prompt.render(patchDescription),
 				parameters: patchEditSchema,
-				invalidParamsMessage: "Invalid edit parameters for patch mode.",
-				validate: isPatchParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -362,8 +368,9 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits } = params as PatchParams;
-					const entries = edits.map((entry: PatchEditEntry) => ({
+					const { edits, path: topPath } = params as PatchParams & { path?: string };
+					const resolved = resolveEntryPaths(edits as PatchEditEntry[], topPath);
+					const entries = resolved.map(entry => ({
 						path: entry.path,
 						run: (br: LspBatchRequest | undefined) =>
 							executePatchSingle({
@@ -383,8 +390,6 @@ export class EditTool implements AgentTool<TInput> {
 			apply_patch: {
 				description: () => prompt.render(applyPatchDescription),
 				parameters: applyPatchSchema,
-				invalidParamsMessage: "Invalid edit parameters for apply_patch mode.",
-				validate: isApplyPatchParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -393,8 +398,8 @@ export class EditTool implements AgentTool<TInput> {
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
 					const entries = expandApplyPatchToEntries(params as ApplyPatchParams);
-					const perFile = entries.map((entry: PatchEditEntry) => ({
-						path: entry.path,
+					const perFile = entries.map(entry => ({
+						path: entry.path!,
 						run: (br: LspBatchRequest | undefined) =>
 							executePatchSingle({
 								session: tool.session,
@@ -413,8 +418,6 @@ export class EditTool implements AgentTool<TInput> {
 			hashline: {
 				description: () => prompt.render(hashlineDescription),
 				parameters: hashlineEditParamsSchema,
-				invalidParamsMessage: "Invalid edit parameters for hashline mode.",
-				validate: isHashlineParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -422,8 +425,9 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits } = params as HashlineParams;
-					const byFile = groupBy(edits, (e: HashlineToolEdit) => e.path);
+					const { edits, path: topPath } = params as HashlineParams & { path?: string };
+					const resolved = resolveEntryPaths(edits as HashlineToolEdit[], topPath);
+					const byFile = groupBy(resolved, e => e.path);
 					const entries = [...byFile.entries()].map(([path, fileEdits]) => ({
 						path,
 						run: (br: LspBatchRequest | undefined) =>
@@ -440,11 +444,38 @@ export class EditTool implements AgentTool<TInput> {
 					return executePerFile(entries, batchRequest, onUpdate);
 				},
 			},
+			atom: {
+				description: () => prompt.render(atomDescription),
+				parameters: atomEditParamsSchema,
+				execute: (
+					tool: EditTool,
+					params: EditParams,
+					signal: AbortSignal | undefined,
+					batchRequest: LspBatchRequest | undefined,
+					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+				) => {
+					const { edits, path: topPath } = params as AtomParams & { path?: string };
+					const resolved = resolveAtomEntryPaths(edits as AtomToolEdit[], topPath);
+					const byFile = groupBy(resolved, e => e.path);
+					const entries = [...byFile.entries()].map(([path, fileEdits]) => ({
+						path,
+						run: (br: LspBatchRequest | undefined) =>
+							executeAtomSingle({
+								session: tool.session,
+								path,
+								edits: fileEdits,
+								signal,
+								batchRequest: br,
+								writethrough: tool.#writethrough,
+								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+							}),
+					}));
+					return executePerFile(entries, batchRequest, onUpdate);
+				},
+			},
 			replace: {
 				description: () => prompt.render(replaceDescription),
 				parameters: replaceEditSchema,
-				invalidParamsMessage: "Invalid edit parameters for replace mode.",
-				validate: isReplaceParams,
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -452,8 +483,9 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits } = params as ReplaceParams;
-					const entries = edits.map((entry: ReplaceEditEntry) => ({
+					const { edits, path: topPath } = params as ReplaceParams & { path?: string };
+					const resolved = resolveEntryPaths(edits as ReplaceEditEntry[], topPath);
+					const entries = resolved.map(entry => ({
 						path: entry.path,
 						run: (br: LspBatchRequest | undefined) =>
 							executeReplaceSingle({
@@ -473,8 +505,6 @@ export class EditTool implements AgentTool<TInput> {
 			vim: {
 				description: () => this.#vimTool.description,
 				parameters: vimSchema,
-				invalidParamsMessage: "Invalid edit parameters for vim mode.",
-				validate: isVimParams,
 				execute: async (
 					tool: EditTool,
 					params: EditParams,