@oh-my-pi/pi-coding-agent 14.5.14 → 14.6.0

package/src/tools/find.ts

@@ -27,7 +27,7 @@ import {
 	formatPathRelativeToCwd,
 	normalizePathLikeInput,
 	parseFindPattern,
-	resolveMultiFindPattern,
+	resolveExplicitFindPatterns,
 	resolveToCwd,
 } from "./path-utils";
 import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
@@ -35,9 +35,10 @@ import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
 const findSchema = Type.Object({
-	pattern: Type.String({
-		description: "glob including search path",
-		examples: ["src/**/*.ts", "lib/*.json", "apps/,packages/", "*.ts"],
+	paths: Type.Array(Type.String({ description: "glob including search path" }), {
+		minItems: 1,
+		description: "globs including search paths",
+		examples: [["src/**/*.ts"], ["lib/*.json"], ["apps/", "packages/"], ["*.ts"]],
 	}),
 	hidden: Type.Optional(Type.Boolean({ description: "include hidden files", default: true })),
 	limit: Type.Optional(Type.Number({ description: "max results", default: 1000 })),
@@ -104,17 +105,17 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 		onUpdate?: AgentToolUpdateCallback<FindToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<FindToolDetails>> {
-		const { pattern, limit, hidden } = params;
+		const { paths, limit, hidden } = params;
 
 		return untilAborted(signal, async () => {
 			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
-			const normalizedPattern = normalizePathLikeInput(pattern).replace(/\\/g, "/");
-			if (!normalizedPattern) {
-				throw new ToolError("Pattern must not be empty");
+			const normalizedPatterns = paths.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
+			if (normalizedPatterns.some(pattern => pattern.length === 0)) {
+				throw new ToolError("`paths` must contain non-empty globs or paths");
 			}
 
-			const multiPattern = await resolveMultiFindPattern(normalizedPattern, this.session.cwd);
-			const parsedPattern = multiPattern ? null : parseFindPattern(normalizedPattern);
+			const multiPattern = await resolveExplicitFindPatterns(normalizedPatterns, this.session.cwd);
+			const parsedPattern = multiPattern ? null : parseFindPattern(normalizedPatterns[0] ?? ".");
 			const hasGlob = multiPattern ? true : (parsedPattern?.hasGlob ?? false);
 			const globPattern = multiPattern?.globPattern ?? parsedPattern?.globPattern ?? "**/*";
 			const searchPath = resolveToCwd(multiPattern?.basePath ?? parsedPattern?.basePath ?? ".", this.session.cwd);
@@ -292,7 +293,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 // =============================================================================
 
 interface FindRenderArgs {
-	pattern: string;
+	paths?: string[];
 	limit?: number;
 }
 
@@ -305,7 +306,7 @@ export const findToolRenderer = {
 		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
 
 		const text = renderStatusLine(
-			{ icon: "pending", title: "Find", description: args.pattern || "*", meta },
+			{ icon: "pending", title: "Find", description: args.paths?.join(", ") || "*", meta },
 			uiTheme,
 		);
 		return new Text(text, 0, 0);
@@ -342,7 +343,7 @@ export const findToolRenderer = {
 				{
 					icon: "success",
 					title: "Find",
-					description: args?.pattern,
+					description: args?.paths?.join(", "),
 					meta: [formatCount("file", lines.length)],
 				},
 				uiTheme,
@@ -381,7 +382,7 @@ export const findToolRenderer = {
 
 		if (fileCount === 0) {
 			const header = renderStatusLine(
-				{ icon: "warning", title: "Find", description: args?.pattern, meta: ["0 files"] },
+				{ icon: "warning", title: "Find", description: args?.paths?.join(", "), meta: ["0 files"] },
 				uiTheme,
 			);
 			return new Text([header, formatEmptyMessage("No files found", uiTheme)].join("\n"), 0, 0);
@@ -390,7 +391,7 @@ export const findToolRenderer = {
 		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
 		const header = renderStatusLine(
-			{ icon: truncated ? "warning" : "success", title: "Find", description: args?.pattern, meta },
+			{ icon: truncated ? "warning" : "success", title: "Find", description: args?.paths?.join(", "), meta },
 			uiTheme,
 		);
 

package/src/tools/path-utils.ts

@@ -47,15 +47,6 @@ function fileExists(filePath: string): boolean {
 	}
 }
 
-async function pathExists(filePath: string): Promise<boolean> {
-	try {
-		await fs.promises.access(filePath, fs.constants.F_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
 function normalizeAtPrefix(filePath: string): string {
 	if (!filePath.startsWith("@")) return filePath;
 
@@ -210,11 +201,17 @@ export interface ParsedFindPattern {
 	hasGlob: boolean;
 }
 
+export interface ResolvedSearchTarget {
+	basePath: string;
+	glob?: string;
+}
+
 export interface ResolvedMultiSearchPath {
 	basePath: string;
 	glob?: string;
 	scopePath: string;
 	exactFilePaths?: string[];
+	targets?: ResolvedSearchTarget[];
 }
 
 export interface ResolvedMultiFindPattern {
@@ -294,77 +291,6 @@ export function combineSearchGlobs(prefixGlob?: string, suffixGlob?: string): st
 	return `${normalizedPrefix}/${normalizedSuffix}`;
 }
 
-type TopLevelSeparator = "comma" | "whitespace";
-
-function splitTopLevel(value: string, separator: TopLevelSeparator): string[] {
-	const parts: string[] = [];
-	let current = "";
-	let braceDepth = 0;
-	let bracketDepth = 0;
-	let parenDepth = 0;
-	let quote: '"' | "'" | undefined;
-	let escaped = false;
-
-	const pushCurrent = () => {
-		const normalized = current.trim();
-		if (normalized.length > 0) {
-			parts.push(normalized);
-		}
-		current = "";
-	};
-
-	for (const char of value) {
-		if (escaped) {
-			current += char;
-			escaped = false;
-			continue;
-		}
-
-		if (char === "\\") {
-			current += char;
-			escaped = true;
-			continue;
-		}
-
-		if (quote) {
-			current += char;
-			if (char === quote) {
-				quote = undefined;
-			}
-			continue;
-		}
-
-		if (char === '"' || char === "'") {
-			quote = char;
-			current += char;
-			continue;
-		}
-
-		if (char === "{") braceDepth += 1;
-		else if (char === "}" && braceDepth > 0) braceDepth -= 1;
-		else if (char === "[") bracketDepth += 1;
-		else if (char === "]" && bracketDepth > 0) bracketDepth -= 1;
-		else if (char === "(") parenDepth += 1;
-		else if (char === ")" && parenDepth > 0) parenDepth -= 1;
-
-		const topLevel = braceDepth === 0 && bracketDepth === 0 && parenDepth === 0;
-		const isWhitespace = /\s/.test(char);
-		if (topLevel && separator === "comma" && char === ",") {
-			pushCurrent();
-			continue;
-		}
-		if (topLevel && separator === "whitespace" && isWhitespace) {
-			pushCurrent();
-			continue;
-		}
-
-		current += char;
-	}
-
-	pushCurrent();
-	return parts.length > 1 ? parts : [value.trim()];
-}
-
 function normalizePosixPath(filePath: string): string {
 	return filePath.replace(/\\/g, "/");
 }
@@ -412,121 +338,12 @@ function toScopeDisplay(items: string[], cwd: string): string {
 		.join(", ");
 }
 
-function looksLikeDelimitedPathToken(token: string): boolean {
-	return (
-		TOP_LEVEL_INTERNAL_URL_PREFIXES.some(prefix => token.startsWith(prefix)) ||
-		token.startsWith(".") ||
-		token.startsWith("/") ||
-		token.startsWith("~") ||
-		token.startsWith("@") ||
-		token.includes("/") ||
-		token.includes("\\") ||
-		hasGlobPathChars(token) ||
-		/\.[^./\\]+$/.test(token)
-	);
-}
-
-async function areDelimitedTokensResolvable(
-	tokens: string[],
-	cwd: string,
-	parseBasePath: (value: string) => string,
-	allowBareExistingTokens: boolean,
-): Promise<boolean> {
-	for (const token of tokens) {
-		if (TOP_LEVEL_INTERNAL_URL_PREFIXES.some(prefix => token.startsWith(prefix))) {
-			return false;
-		}
-
-		if (!allowBareExistingTokens && !looksLikeDelimitedPathToken(token)) {
-			// Bare names like "packages" don't look like path tokens syntactically,
-			// but may still be valid directory names. Check existence before rejecting.
-			const resolvedExactPath = resolveToCwd(token, cwd);
-			if (!(await pathExists(resolvedExactPath))) {
-				return false;
-			}
-			continue;
-		}
-
-		const basePath = parseBasePath(token);
-		const resolvedBasePath = resolveToCwd(basePath, cwd);
-		if (await pathExists(resolvedBasePath)) {
-			continue;
-		}
-
-		if (!allowBareExistingTokens) {
-			return false;
-		}
-
-		const resolvedExactPath = resolveToCwd(token, cwd);
-		if (!(await pathExists(resolvedExactPath))) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-async function filterResolvableTokens(
-	tokens: string[],
-	cwd: string,
-	parseBasePath: (value: string) => string,
-): Promise<string[]> {
-	const out: string[] = [];
-	for (const token of tokens) {
-		if (TOP_LEVEL_INTERNAL_URL_PREFIXES.some(prefix => token.startsWith(prefix))) continue;
-		const basePath = parseBasePath(token);
-		const resolvedBasePath = resolveToCwd(basePath, cwd);
-		if (await pathExists(resolvedBasePath)) {
-			out.push(token);
-			continue;
-		}
-		const resolvedExactPath = resolveToCwd(token, cwd);
-		if (await pathExists(resolvedExactPath)) {
-			out.push(token);
-		}
-	}
-	return out;
-}
-
-async function splitDelimitedSearchInput(
-	rawInput: string,
-	cwd: string,
-	parseBasePath: (value: string) => string,
-): Promise<string[] | undefined> {
-	const trimmed = rawInput.trim();
-	if (!trimmed) return undefined;
-
-	const resolvedExactPath = resolveToCwd(trimmed, cwd);
-	if (await pathExists(resolvedExactPath)) {
-		return undefined;
-	}
-
-	const commaSeparated = splitTopLevel(trimmed, "comma");
-	if (commaSeparated.length > 1) {
-		const resolvable = await filterResolvableTokens(commaSeparated, cwd, parseBasePath);
-		if (resolvable.length >= 1) {
-			return [...new Set(resolvable)];
-		}
-	}
-
-	const whitespaceSeparated = splitTopLevel(trimmed, "whitespace");
-	if (
-		whitespaceSeparated.length > 1 &&
-		(await areDelimitedTokensResolvable(whitespaceSeparated, cwd, parseBasePath, false))
-	) {
-		return [...new Set(whitespaceSeparated)];
-	}
-
-	return undefined;
-}
-
-export async function resolveMultiSearchPath(
-	rawPath: string,
+async function resolveSearchPathItems(
+	pathItems: string[],
 	cwd: string,
 	suffixGlob?: string,
 ): Promise<ResolvedMultiSearchPath | undefined> {
-	const pathItems = await splitDelimitedSearchInput(rawPath, cwd, value => parseSearchPath(value).basePath);
-	if (!pathItems || pathItems.length < 1) {
+	if (pathItems.length < 1) {
 		return undefined;
 	}
 
@@ -556,21 +373,37 @@ export async function resolveMultiSearchPath(
 		}
 		return relativeBasePath === "." ? path.basename(item.absoluteBasePath) : relativeBasePath;
 	});
+	const rootPath = path.parse(commonBasePath).root;
+	const isDegenerateRoot = commonBasePath === rootPath && parsedItems.length > 1;
+	const targets = isDegenerateRoot
+		? parsedItems.map(item => ({
+				basePath: item.absoluteBasePath,
+				glob: item.parsedPath.glob ? combineSearchGlobs(item.parsedPath.glob, suffixGlob) : suffixGlob,
+			}))
+		: undefined;
 
 	return {
 		basePath: commonBasePath,
 		glob: buildBraceUnion(combinedPatterns),
 		scopePath: toScopeDisplay(pathItems, cwd),
 		exactFilePaths: allExactFiles ? parsedItems.map(item => item.absoluteBasePath) : undefined,
+		targets,
 	};
 }
 
-export async function resolveMultiFindPattern(
-	rawPattern: string,
+export async function resolveExplicitSearchPaths(
+	pathItems: string[],
+	cwd: string,
+	suffixGlob?: string,
+): Promise<ResolvedMultiSearchPath | undefined> {
+	return resolveSearchPathItems([...new Set(pathItems)], cwd, suffixGlob);
+}
+
+async function resolveFindPatternItems(
+	patternItems: string[],
 	cwd: string,
 ): Promise<ResolvedMultiFindPattern | undefined> {
-	const patternItems = await splitDelimitedSearchInput(rawPattern, cwd, value => parseFindPattern(value).basePath);
-	if (!patternItems || patternItems.length <= 1) {
+	if (patternItems.length <= 1) {
 		return undefined;
 	}
 
@@ -602,6 +435,13 @@ export async function resolveMultiFindPattern(
 	};
 }
 
+export async function resolveExplicitFindPatterns(
+	patternItems: string[],
+	cwd: string,
+): Promise<ResolvedMultiFindPattern | undefined> {
+	return resolveFindPatternItems([...new Set(patternItems)], cwd);
+}
+
 export function resolveReadPath(filePath: string, cwd: string): string {
 	const resolved = resolveToCwd(filePath, cwd);
 	const shellEscapedVariant = tryShellEscapedPath(resolved);

package/src/tools/search.ts

@@ -22,7 +22,7 @@ import {
 	hasGlobPathChars,
 	normalizePathLikeInput,
 	parseSearchPath,
-	resolveMultiSearchPath,
+	resolveExplicitSearchPaths,
 	resolveToCwd,
 } from "./path-utils";
 import {
@@ -37,9 +37,10 @@ import { toolResult } from "./tool-result";
 
 const searchSchema = Type.Object({
 	pattern: Type.String({ description: "regex pattern", examples: ["function\\s+\\w+", "TODO"] }),
-	path: Type.String({
-		description: "file, directory, glob, comma-separated paths, or internal URL to search",
-		examples: ["src/", "src/foo.ts", "src/**/*.ts"],
+	paths: Type.Array(Type.String({ description: "file, directory, glob, or internal URL to search" }), {
+		minItems: 1,
+		description: "files, directories, globs, or internal URLs to search",
+		examples: [["src/"], ["src/foo.ts"], ["src/**/*.ts"], ["src/", "packages/"]],
 	}),
 	i: Type.Optional(Type.Boolean({ description: "case-insensitive search", default: false })),
 	gitignore: Type.Optional(Type.Boolean({ description: "respect gitignore", default: true })),
@@ -48,7 +49,7 @@ const searchSchema = Type.Object({
 
 export type SearchToolInput = Static<typeof searchSchema>;
 
-const DEFAULT_MATCH_LIMIT = 20;
+const DEFAULT_MATCH_LIMIT = 500;
 
 export interface SearchToolDetails {
 	truncation?: TruncationResult;
@@ -93,7 +94,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 		_onUpdate?: AgentToolUpdateCallback<SearchToolDetails>,
 		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<SearchToolDetails>> {
-		const { pattern, path: searchDir, i, gitignore, skip } = params;
+		const { pattern, paths, i, gitignore, skip } = params;
 
 		return untilAborted(signal, async () => {
 			const normalizedPattern = pattern.trim();
@@ -117,13 +118,19 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			let searchPath: string;
 			let scopePath: string;
 			let exactFilePaths: string[] | undefined;
+			let multiTargets: Array<{ basePath: string; glob?: string }> | undefined;
 			let globFilter: string | undefined;
-			const rawPath = normalizePathLikeInput(searchDir);
-			if (rawPath.length === 0) {
-				throw new ToolError("`path` must be a non-empty path or glob");
+			const rawPaths = paths.map(normalizePathLikeInput);
+			if (rawPaths.some(rawPath => rawPath.length === 0)) {
+				throw new ToolError("`paths` must contain non-empty paths or globs");
 			}
 			const internalRouter = this.session.internalRouter;
-			if (internalRouter?.canHandle(rawPath)) {
+			const resolvedPathInputs: string[] = [];
+			for (const rawPath of rawPaths) {
+				if (!internalRouter?.canHandle(rawPath)) {
+					resolvedPathInputs.push(rawPath);
+					continue;
+				}
 				if (hasGlobPathChars(rawPath)) {
 					throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
 				}
@@ -131,28 +138,30 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				if (!resource.sourcePath) {
 					throw new ToolError(`Cannot search internal URL without a backing file: ${rawPath}`);
 				}
-				searchPath = resource.sourcePath;
+				resolvedPathInputs.push(resource.sourcePath);
+			}
+			if (resolvedPathInputs.length === 1) {
+				const parsedPath = parseSearchPath(resolvedPathInputs[0] ?? ".");
+				searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
+				globFilter = parsedPath.glob;
 				scopePath = formatScopePath(searchPath);
 			} else {
-				const multiSearchPath = await resolveMultiSearchPath(rawPath, this.session.cwd, globFilter);
-				if (multiSearchPath) {
-					searchPath = multiSearchPath.basePath;
-					globFilter = multiSearchPath.exactFilePaths ? undefined : multiSearchPath.glob;
-					exactFilePaths = multiSearchPath.exactFilePaths;
-					scopePath = multiSearchPath.scopePath;
-				} else {
-					const parsedPath = parseSearchPath(rawPath);
-					searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-					globFilter = parsedPath.glob;
-					scopePath = formatScopePath(searchPath);
+				const multiSearchPath = await resolveExplicitSearchPaths(resolvedPathInputs, this.session.cwd, globFilter);
+				if (!multiSearchPath) {
+					throw new ToolError("`paths` must contain at least one path or glob");
 				}
+				searchPath = multiSearchPath.basePath;
+				exactFilePaths = multiSearchPath.exactFilePaths;
+				multiTargets = multiSearchPath.targets;
+				globFilter = exactFilePaths || multiTargets ? undefined : multiSearchPath.glob;
+				scopePath = multiSearchPath.scopePath;
 			}
 			let isDirectory: boolean;
 			try {
 				const stat = await Bun.file(searchPath).stat();
 				isDirectory = stat.isDirectory();
 			} catch {
-				const hint = scopePath.includes(",") ? ` (comma-separated paths must each exist relative to cwd)` : "";
+				const hint = rawPaths.length > 1 ? " (`paths` entries must each exist relative to cwd)" : "";
 				throw new ToolError(`Path not found: ${scopePath}${hint}`);
 			}
 
@@ -163,19 +172,26 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			// Run grep
 			let result: GrepResult;
 			try {
-				if (exactFilePaths) {
+				if (exactFilePaths || multiTargets) {
 					const matches: GrepMatch[] = [];
 					let limitReached = false;
-					for (const exactFilePath of exactFilePaths) {
-						const fileResult = await grep(
+					let totalMatches = 0;
+					let filesSearched = 0;
+					const targets = exactFilePaths
+						? exactFilePaths.map(filePath => ({ basePath: filePath, glob: undefined as string | undefined }))
+						: (multiTargets ?? []);
+					for (const target of targets) {
+						const targetResult = await grep(
 							{
 								pattern: normalizedPattern,
-								path: exactFilePath,
+								path: target.basePath,
+								glob: target.glob,
 								ignoreCase,
 								multiline: effectiveMultiline,
 								hidden: true,
 								gitignore: useGitignore,
 								cache: false,
+								maxCount: exactFilePaths ? undefined : internalLimit,
 								contextBefore: normalizedContextBefore,
 								contextAfter: normalizedContextAfter,
 								maxColumns: DEFAULT_MAX_COLUMN,
@@ -183,16 +199,21 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 							},
 							undefined,
 						);
-						limitReached = limitReached || Boolean(fileResult.limitReached);
-						const relativeFilePath = path.relative(searchPath, exactFilePath).replace(/\\/g, "/");
-						matches.push(...fileResult.matches.map(match => ({ ...match, path: relativeFilePath })));
+						limitReached = limitReached || Boolean(targetResult.limitReached);
+						totalMatches += targetResult.totalMatches;
+						filesSearched += targetResult.filesSearched;
+						for (const match of targetResult.matches) {
+							const absolute = path.resolve(target.basePath, match.path);
+							const rebased = path.relative(searchPath, absolute).replace(/\\/g, "/");
+							matches.push({ ...match, path: rebased });
+						}
 					}
 					const offsetMatches = matches.slice(normalizedSkip);
 					result = {
 						matches: offsetMatches,
-						totalMatches: offsetMatches.length,
+						totalMatches: exactFilePaths ? offsetMatches.length : totalMatches,
 						filesWithMatches: new Set(offsetMatches.map(match => match.path)).size,
-						filesSearched: exactFilePaths.length,
+						filesSearched: exactFilePaths ? exactFilePaths.length : filesSearched,
 						limitReached,
 					};
 				} else {
@@ -261,7 +282,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				: result.matches.slice(0, effectiveLimit);
 			const matchLimitReached = result.matches.length > effectiveLimit;
 			const nextSkip = normalizedSkip + selectedMatches.length;
-			const limitMessage = `Result limit reached; narrow path or use skip=${nextSkip}.`;
+			const limitMessage = `Result limit reached; narrow paths or use skip=${nextSkip}.`;
 			const { record: recordFile, list: fileList } = createFileRecorder();
 			const fileMatchCounts = new Map<string, number>();
 			if (selectedMatches.length === 0) {
@@ -381,7 +402,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 
 interface SearchRenderArgs {
 	pattern: string;
-	path?: string;
+	paths?: string[];
 	i?: boolean;
 	gitignore?: boolean;
 	skip?: number;
@@ -393,7 +414,7 @@ export const searchToolRenderer = {
 	inline: true,
 	renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const meta: string[] = [];
-		if (args.path) meta.push(`in ${args.path}`);
+		if (args.paths?.length) meta.push(`in ${args.paths.join(", ")}`);
 		if (args.i) meta.push("case:insensitive");
 		if (args.gitignore === false) meta.push("gitignore:false");
 		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);

package/src/utils/edit-mode.ts

@@ -1,12 +1,11 @@
-import { $env, $flag } from "@oh-my-pi/pi-utils";
+import { $env } from "@oh-my-pi/pi-utils";
 
-export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch" | "atom";
+export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch";
 
 export const DEFAULT_EDIT_MODE: EditMode = "hashline";
 
 const EDIT_MODE_IDS = {
 	apply_patch: "apply_patch",
-	atom: "atom",
 	hashline: "hashline",
 	patch: "patch",
 	replace: "replace",
@@ -38,14 +37,6 @@ export function resolveEditMode(session: EditModeSessionLike): EditMode {
 	const envMode = normalizeEditMode($env.PI_EDIT_VARIANT);
 	if (envMode) return envMode;
 
-	if (!$flag("PI_STRICT_EDIT_MODE")) {
-		if (activeModel?.includes("spark")) return "apply_patch";
-		if (activeModel?.includes("nano")) return "replace";
-		if (activeModel?.includes("mini")) return "replace";
-		if (activeModel?.includes("haiku")) return "replace";
-		if (activeModel?.includes("flash")) return "replace";
-	}
-
 	const settingsMode = normalizeEditMode(String(session.settings.get("edit.mode") ?? ""));
 	return settingsMode ?? DEFAULT_EDIT_MODE;
 }

package/src/utils/file-display-mode.ts

@@ -29,7 +29,7 @@ export function resolveFileDisplayMode(session: FileDisplayModeSession, options?
 	const { settings } = session;
 	const hasEditTool = session.hasEditTool ?? true;
 	const editMode = resolveEditMode(session);
-	const usesHashLineAnchors = editMode === "hashline" || editMode === "atom";
+	const usesHashLineAnchors = editMode === "hashline";
 	const raw = options?.raw === true;
 	const hashLines = !raw && hasEditTool && usesHashLineAnchors && settings.get("readHashLines") !== false;
 	return {

package/src/utils/git.ts

@@ -1258,6 +1258,23 @@ export async function restore(cwd: string, options: RestoreOptions = {}): Promis
 	await runEffect(cwd, args, { signal: options.signal });
 }
 
+/**
+ * Run `git reset` with options. Default is a soft reset (no flag); pass `hard: true` for a destructive reset.
+ *
+ * NOTE: stage.reset() handles the per-file unstaging case. This helper exists for tree-wide resets.
+ */
+export async function reset(
+	cwd: string,
+	options: { hard?: boolean; mixed?: boolean; soft?: boolean; target?: string; signal?: AbortSignal } = {},
+): Promise<void> {
+	const args = ["reset"];
+	if (options.hard) args.push("--hard");
+	else if (options.mixed) args.push("--mixed");
+	else if (options.soft) args.push("--soft");
+	if (options.target) args.push(options.target);
+	await runEffect(cwd, args, { signal: options.signal });
+}
+
 export async function clean(
 	cwd: string,
 	options: { ignoredOnly?: boolean; paths?: readonly string[]; signal?: AbortSignal } = {},

package/src/utils/session-color.ts

@@ -33,18 +33,6 @@ export function getSessionAccentHex(name: string): string {
 	return hslToHex(nameToHue(name), 0.9, 0.72);
 }
 
-/**
- * Auto-generated titles should not drive the session accent.
- * Legacy sessions with unknown title source keep the old behavior.
- */
-export function getSessionAccentHexForTitle(
-	name: string | undefined,
-	titleSource: "auto" | "user" | undefined,
-): string | undefined {
-	if (!name || titleSource === "auto") return undefined;
-	return getSessionAccentHex(name);
-}
-
 /**
  * Convert a hex accent color to an ANSI-16m foreground escape sequence.
  * Returns `undefined` if `hex` is nullish or Bun.color conversion fails.