@ottocode/sdk 0.1.313 → 0.1.315

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.313",
+	"version": "0.1.315",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/config/src/index.ts

@@ -1,7 +1,10 @@
 import {
+	getProjectConfigDir,
+	getProjectConfigPath,
+	getProjectStateDir,
+	getLegacyProjectDataDir,
 	getGlobalConfigPath,
 	getGlobalSkillsConfigPath,
-	getLocalDataDir,
 	ensureDir,
 	fileExists,
 	joinPath,
@@ -22,7 +25,7 @@ const DEFAULT_PROVIDER_SETTINGS: OttoConfig['providers'] = {
 	xai: { enabled: false },
 	zai: { enabled: false },
 	'zai-coding': { enabled: false },
-	moonshot: { enabled: false },
+	kimi: { enabled: false },
 	minimax: { enabled: false },
 };
 
@@ -39,6 +42,7 @@ const DEFAULTS: {
 		reasoningText: true,
 		reasoningLevel: 'high',
 		theme: 'dark',
+		tuiTheme: 'tokyo-night',
 		vimMode: false,
 		compactThread: true,
 		fontFamily: 'IBM Plex Mono',
@@ -46,6 +50,7 @@ const DEFAULTS: {
 		releaseToSend: false,
 		fullWidthContent: false,
 		autoCompactThresholdTokens: null,
+		coAuthorCommits: false,
 		ottoEnabled: true,
 	},
 	providers: DEFAULT_PROVIDER_SETTINGS,
@@ -64,9 +69,21 @@ export async function loadConfig(
 		? String(projectRootInput)
 		: process.cwd();
 
-	const dataDir = getLocalDataDir(projectRoot);
-	const dbPath = joinPath(dataDir, 'otto.sqlite');
-	const projectConfigPath = joinPath(dataDir, 'config.json');
+	const projectConfigDir = getProjectConfigDir(projectRoot);
+	const projectConfigPath = getProjectConfigPath(projectRoot);
+	const projectStateDir = await getProjectStateDir(projectRoot);
+	const dataDir = projectStateDir;
+	const dbPath = joinPath(projectStateDir, 'otto.sqlite');
+	const attachmentsDir = joinPath(projectStateDir, 'attachments');
+	const debugDir = joinPath(projectStateDir, 'debug');
+	const debugDumpsDir = joinPath(projectStateDir, 'debug-dumps');
+	const logsDir = joinPath(projectStateDir, 'logs');
+	const tmpDir = joinPath(projectStateDir, 'tmp');
+	const cacheDir = joinPath(projectStateDir, 'cache');
+	const legacyDbPath = joinPath(
+		getLegacyProjectDataDir(projectRoot),
+		'otto.sqlite',
+	);
 	const globalConfigPath = getGlobalConfigPath();
 	const globalSkillsConfigPath = getGlobalSkillsConfigPath();
 
@@ -81,7 +98,12 @@ export async function loadConfig(
 		filterProjectConfig(projectCfg),
 	);
 
-	await ensureDir(dataDir);
+	await ensureDir(projectStateDir);
+	if ((await fileExists(legacyDbPath)) && !(await fileExists(dbPath))) {
+		console.warn(
+			`Legacy Otto database found at ${legacyDbPath}. Run: otto storage migrate`,
+		);
+	}
 
 	return {
 		projectRoot,
@@ -89,11 +111,19 @@ export async function loadConfig(
 		providers: merged.providers as OttoConfig['providers'],
 		skills: merged.skills as OttoConfig['skills'],
 		paths: {
-			dataDir,
-			dbPath,
+			projectConfigDir,
 			projectConfigPath: (await fileExists(projectConfigPath))
 				? projectConfigPath
 				: null,
+			projectStateDir,
+			dataDir,
+			dbPath,
+			attachmentsDir,
+			debugDir,
+			debugDumpsDir,
+			logsDir,
+			tmpDir,
+			cacheDir,
 			globalConfigPath: (await fileExists(globalConfigPath))
 				? globalConfigPath
 				: null,

package/src/config/src/manager.ts

@@ -86,6 +86,7 @@ export async function writeDefaults(
 		reasoningText: boolean;
 		reasoningLevel: 'minimal' | 'low' | 'medium' | 'high' | 'max' | 'xhigh';
 		theme: string;
+		tuiTheme: string;
 		vimMode: boolean;
 		compactThread: boolean;
 		fontFamily: string;
@@ -93,6 +94,7 @@ export async function writeDefaults(
 		releaseToSend: boolean;
 		fullWidthContent: boolean;
 		autoCompactThresholdTokens: number | null;
+		coAuthorCommits: boolean;
 		ottoEnabled: boolean;
 	}>,
 	projectRoot?: string,

package/src/config/src/paths.ts

@@ -110,18 +110,236 @@ export function getSessionSystemPromptPath(sessionId: string): string {
 	);
 }
 
-export function getLocalDataDir(projectRoot: string): string {
+/** Resolve the user-level Otto home directory for project state storage. */
+export function getOttoHomeDir(): string {
+	const ottoHome = process.env.OTTO_HOME;
+	if (ottoHome?.trim()) return ottoHome.replace(/\\/g, '/');
+	if (process.platform === 'win32') {
+		const appData = (process.env.APPDATA || '').replace(/\\/g, '/');
+		const base = appData || joinPath(getHomeDir(), 'AppData', 'Roaming');
+		return joinPath(base, 'otto');
+	}
+	return joinPath(getHomeDir(), '.local', 'state', 'otto');
+}
+
+/** Resolve the root directory containing per-project state directories. */
+export function getProjectsStateRoot(): string {
+	return joinPath(getOttoHomeDir(), 'projects');
+}
+
+const projectIdCache = new Map<string, Promise<string>>();
+
+/** Build a stable readable project ID from basename and git remote/path hash. */
+export async function getProjectId(projectRoot: string): Promise<string> {
+	const normalizedProjectRoot = projectRoot.replace(/\\/g, '/');
+	const cached = projectIdCache.get(normalizedProjectRoot);
+	if (cached) return cached;
+
+	const projectId = resolveProjectId(normalizedProjectRoot);
+	projectIdCache.set(normalizedProjectRoot, projectId);
+	return projectId;
+}
+
+async function resolveProjectId(
+	normalizedProjectRoot: string,
+): Promise<string> {
+	const slug = sanitizeProjectSlug(getPathBasename(normalizedProjectRoot));
+	const hashInput =
+		(await readGitRemoteUrl(normalizedProjectRoot)) ??
+		(await getCanonicalProjectRoot(normalizedProjectRoot));
+	const hash = (await sha256Hex(hashInput)).slice(0, 8);
+	return `${slug}-${hash}`;
+}
+
+/** Resolve the repository-local Otto project config directory. */
+export function getProjectConfigDir(projectRoot: string): string {
 	return joinPath(projectRoot, '.otto');
 }
 
+/** Resolve the repository-local Otto project config file path. */
+export function getProjectConfigPath(projectRoot: string): string {
+	return joinPath(getProjectConfigDir(projectRoot), 'config.json');
+}
+
+/** Resolve the user-level state directory for a project. */
+export async function getProjectStateDir(projectRoot: string): Promise<string> {
+	return joinPath(getProjectsStateRoot(), await getProjectId(projectRoot));
+}
+
+/** Resolve the project SQLite database path under user-level state. */
+export async function getProjectDbPath(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'otto.sqlite');
+}
+
+/** Resolve the project attachments directory under user-level state. */
+export async function getProjectAttachmentsDir(
+	projectRoot: string,
+): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'attachments');
+}
+
+/** Resolve the project debug directory under user-level state. */
+export async function getProjectDebugDir(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'debug');
+}
+
+/** Resolve the project debug dumps directory under user-level state. */
+export async function getProjectDebugDumpsDir(
+	projectRoot: string,
+): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'debug-dumps');
+}
+
+/** Resolve the project logs directory under user-level state. */
+export async function getProjectLogsDir(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'logs');
+}
+
+/** Resolve the project temporary files directory under user-level state. */
+export async function getProjectTmpDir(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'tmp');
+}
+
+/** Resolve the project cache directory under user-level state. */
+export async function getProjectCacheDir(projectRoot: string): Promise<string> {
+	return joinPath(await getProjectStateDir(projectRoot), 'cache');
+}
+
+/** Resolve the legacy repository-local data directory used before migration. */
+export function getLegacyProjectDataDir(projectRoot: string): string {
+	return joinPath(projectRoot, '.otto');
+}
+
+/** @deprecated Use getLegacyProjectDataDir() for legacy project-local data. */
+export function getLocalDataDir(projectRoot: string): string {
+	return getLegacyProjectDataDir(projectRoot);
+}
+
+function sanitizeProjectSlug(name: string): string {
+	return name.replace(/[^a-zA-Z0-9._-]+/g, '-') || 'project';
+}
+
+function getPathBasename(path: string): string {
+	const trimmed = path.replace(/\/+$/g, '');
+	const index = trimmed.lastIndexOf('/');
+	return index >= 0 ? trimmed.slice(index + 1) : trimmed;
+}
+
+async function sha256Hex(input: string): Promise<string> {
+	const subtle = globalThis.crypto?.subtle;
+	if (subtle) {
+		const encoded = new TextEncoder().encode(input);
+		const digest = await subtle.digest('SHA-256', encoded);
+		return Array.from(new Uint8Array(digest), (byte) =>
+			byte.toString(16).padStart(2, '0'),
+		).join('');
+	}
+
+	const { createHash } = await loadCrypto();
+	return createHash('sha256').update(input).digest('hex');
+}
+
+async function getCanonicalProjectRoot(projectRoot: string): Promise<string> {
+	try {
+		const { realpath } = await loadFsPromises();
+		return (await realpath(projectRoot)).replace(/\\/g, '/');
+	} catch {
+		return projectRoot.replace(/\\/g, '/');
+	}
+}
+
+async function readGitRemoteUrl(
+	projectRoot: string,
+): Promise<string | undefined> {
+	const currentBranchRemote = await readCurrentBranchRemote(projectRoot);
+	const remoteNames = currentBranchRemote
+		? [currentBranchRemote, 'origin']
+		: ['origin'];
+
+	for (const remoteName of remoteNames) {
+		const remoteUrl = await readGitConfigValue(
+			projectRoot,
+			`remote.${remoteName}.url`,
+		);
+		if (remoteUrl) return remoteUrl;
+	}
+
+	const remoteList = await readGitConfigValues(
+		projectRoot,
+		'config',
+		'--get-regexp',
+		'remote\\..*\\.url',
+	);
+	return remoteList
+		.map((line) => line.trim().split(/\s+/, 2)[1])
+		.find((url) => url?.trim());
+}
+
+async function readCurrentBranchRemote(
+	projectRoot: string,
+): Promise<string | undefined> {
+	const branch = await readGitConfigValues(
+		projectRoot,
+		'rev-parse',
+		'--abbrev-ref',
+		'HEAD',
+	);
+	const branchName = branch[0];
+	if (!branchName || branchName === 'HEAD') return undefined;
+	return readGitConfigValue(projectRoot, `branch.${branchName}.remote`);
+}
+
+async function readGitConfigValue(
+	projectRoot: string,
+	key: string,
+): Promise<string | undefined> {
+	const values = await readGitConfigValues(projectRoot, 'config', '--get', key);
+	return values[0];
+}
+
+async function readGitConfigValues(
+	projectRoot: string,
+	...args: string[]
+): Promise<string[]> {
+	try {
+		const { execFile } = await loadChildProcess();
+		const { promisify } = await loadUtil();
+		const execFileAsync = promisify(execFile);
+		const { stdout } = await execFileAsync('git', ['-C', projectRoot, ...args]);
+		const output = String(stdout);
+		return output
+			.split('\n')
+			.map((line) => line.trim())
+			.filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+
 async function loadFsPromises(): Promise<typeof import('node:fs/promises')> {
 	return Function('specifier', 'return import(specifier)')('node:fs/promises');
 }
 
+async function loadChildProcess(): Promise<
+	typeof import('node:child_process')
+> {
+	return Function(
+		'specifier',
+		'return import(specifier)',
+	)('node:child_process');
+}
+
+async function loadUtil(): Promise<typeof import('node:util')> {
+	return Function('specifier', 'return import(specifier)')('node:util');
+}
+
+async function loadCrypto(): Promise<typeof import('node:crypto')> {
+	return Function('specifier', 'return import(specifier)')('node:crypto');
+}
+
 export async function ensureDir(dir: string) {
-	const { mkdir, writeFile } = await loadFsPromises();
+	const { mkdir } = await loadFsPromises();
 	await mkdir(dir, { recursive: true }).catch(() => {});
-	await writeFile(joinPath(dir, '.keep'), '').catch(() => {});
 }
 
 export async function fileExists(p: string) {

package/src/core/src/providers/resolver.ts

@@ -33,7 +33,6 @@ export type ProviderName =
 	| 'xai'
 	| 'zai'
 	| 'zai-coding'
-	| 'moonshot'
 	| 'kimi'
 	| 'minimax';
 
@@ -222,7 +221,7 @@ export async function resolveModel(
 		});
 	}
 
-	if (provider === 'moonshot' || provider === 'kimi') {
+	if (provider === 'kimi') {
 		return createKimiModel(model, {
 			apiKey: config.apiKey,
 			baseURL: config.baseURL,

package/src/core/src/tools/builtin/fs/copy-attachment.ts

@@ -3,6 +3,10 @@ import { copyFile, mkdir, readFile, stat } from 'node:fs/promises';
 import { dirname, extname, join } from 'node:path';
 import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
+import {
+	loadConfig,
+	type OttoConfig,
+} from '../../../../../config/src/index.ts';
 import { createToolError, type ToolResponse } from '../../error.ts';
 import { expandTilde, isAbsoluteLike, resolveSafePath } from './util.ts';
 import { rememberFileWrite } from './read-tracker.ts';
@@ -16,10 +20,11 @@ type AttachmentMetadata = {
 	sha256: string;
 	kind: 'image' | 'pdf' | 'text' | 'binary';
 	originalPath: string;
+	storageRoot?: 'project-state';
+	relativePath?: string;
 	createdAt: string;
 };
 
-const ATTACHMENTS_DIR = '.otto/attachments';
 const MIME_EXTENSIONS: Record<string, string[]> = {
 	'image/png': ['.png'],
 	'image/jpeg': ['.jpg', '.jpeg'],
@@ -43,12 +48,11 @@ function replaceExtension(path: string, extension: string): string {
 }
 
 async function readAttachmentMetadata(
-	projectRoot: string,
+	cfg: OttoConfig,
 	attachmentId: string,
 ): Promise<AttachmentMetadata> {
 	const metadataPath = join(
-		projectRoot,
-		ATTACHMENTS_DIR,
+		cfg.paths.attachmentsDir,
 		attachmentId,
 		'metadata.json',
 	);
@@ -56,6 +60,19 @@ async function readAttachmentMetadata(
 	return JSON.parse(raw) as AttachmentMetadata;
 }
 
+function resolveAttachmentSource(
+	cfg: OttoConfig,
+	metadata: AttachmentMetadata,
+): string {
+	if (metadata.storageRoot === 'project-state' && metadata.relativePath) {
+		return join(cfg.paths.projectStateDir, metadata.relativePath);
+	}
+	return join(
+		cfg.paths.projectStateDir,
+		metadata.relativePath ?? metadata.originalPath,
+	);
+}
+
 export function buildCopyAttachmentTool(projectRoot: string): {
 	name: string;
 	tool: Tool;
@@ -83,8 +100,8 @@ export function buildCopyAttachmentTool(projectRoot: string): {
 		async execute({
 			attachmentId,
 			targetPath,
-			overwrite,
-			createDirs,
+			overwrite = false,
+			createDirs = true,
 		}: {
 			attachmentId: string;
 			targetPath: string;
@@ -132,11 +149,9 @@ export function buildCopyAttachmentTool(projectRoot: string): {
 			}
 
 			try {
-				const metadata = await readAttachmentMetadata(
-					projectRoot,
-					attachmentId,
-				);
-				const source = join(projectRoot, metadata.originalPath);
+				const cfg = await loadConfig(projectRoot);
+				const metadata = await readAttachmentMetadata(cfg, attachmentId);
+				const source = resolveAttachmentSource(cfg, metadata);
 				const expectedExtensions = getExpectedExtensions(metadata.mimeType);
 				const targetExtension = extname(requestedPath).toLowerCase();
 				const preferredExtension = expectedExtensions[0];
@@ -145,7 +160,7 @@ export function buildCopyAttachmentTool(projectRoot: string): {
 						? replaceExtension(requestedPath, preferredExtension)
 						: requestedPath;
 				const extensionAdjusted = req !== requestedPath;
-				const target = resolveSafePath(projectRoot, req);
+				const target = resolveSafePath(cfg.projectRoot, req);
 				try {
 					await stat(target);
 					if (!overwrite) {
@@ -168,7 +183,7 @@ export function buildCopyAttachmentTool(projectRoot: string): {
 					await mkdir(dirname(target), { recursive: true });
 				}
 				await copyFile(source, target);
-				await rememberFileWrite(projectRoot, target);
+				await rememberFileWrite(cfg.projectRoot, target);
 				const bytes = await readFile(target);
 				const sha256 = createHash('sha256').update(bytes).digest('hex');
 				return {

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

@@ -1,6 +1,6 @@
 Replace an exact text block in an existing file.
 
-Use this for targeted edits instead of structural patch-style editing whenever possible.
+Prefer `apply_patch` for most code/text edits when it is available, because it produces the clearest diff preview. Use `edit` when you have one precise old/new text replacement, when a patch would be awkward, or after patch attempts fail.
 
 Rules:
 - You must read the file first in the current session before editing it.

package/src/core/src/tools/builtin/fs/index.ts

@@ -9,6 +9,8 @@ import { buildTreeTool } from './tree.ts';
 import { buildPwdTool } from './pwd.ts';
 import { buildCdTool } from './cd.ts';
 
+export { rememberFileRead } from './read-tracker.ts';
+
 export function buildFsTools(
 	projectRoot: string,
 ): Array<{ name: string; tool: Tool }> {

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

@@ -1,6 +1,6 @@
 Apply multiple exact text replacements to a single existing file atomically.
 
-Use this when you need several edits in one file.
+Prefer `apply_patch` for most code/text edits when it is available, especially when a diff is easy to express. Use `multiedit` when you have several precise old/new replacements in one file, when a patch would be awkward, or after patch attempts fail.
 
 Rules:
 - Read the file first before editing.

package/src/core/src/tools/builtin/git-identity.ts

@@ -1,10 +1,40 @@
+import { readFileSync } from 'node:fs';
+import { getGlobalConfigPath } from '../../../../config/src/paths.ts';
+
 const OTTOCODE_BOT_USER_ID = '261994719';
 
 export const OTTOCODE_BOT_NAME = 'ottocode-io[bot]';
 export const OTTOCODE_BOT_EMAIL = `${OTTOCODE_BOT_USER_ID}+${OTTOCODE_BOT_NAME}@users.noreply.github.com`;
 export const OTTOCODE_CO_AUTHOR = `Co-authored-by: ${OTTOCODE_BOT_NAME} <${OTTOCODE_BOT_EMAIL}>`;
 
-export function appendCoAuthorTrailer(message: string): string {
+type JsonObject = Record<string, unknown>;
+
+function readCoAuthorCommits(filePath: string): boolean | undefined {
+	try {
+		const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+		if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+			return undefined;
+		}
+		const defaults = (parsed as JsonObject).defaults;
+		if (!defaults || typeof defaults !== 'object' || Array.isArray(defaults)) {
+			return undefined;
+		}
+		const value = (defaults as JsonObject).coAuthorCommits;
+		return typeof value === 'boolean' ? value : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function shouldCoAuthorCommits(_projectRoot?: string): boolean {
+	return readCoAuthorCommits(getGlobalConfigPath()) ?? false;
+}
+
+export function appendCoAuthorTrailer(
+	message: string,
+	enabled = false,
+): string {
+	if (!enabled) return message;
 	if (message.includes(OTTOCODE_CO_AUTHOR)) return message;
 	return `${message}\n\n${OTTOCODE_CO_AUTHOR}`;
 }
@@ -12,9 +42,13 @@ export function appendCoAuthorTrailer(message: string): string {
 const GIT_COMMIT_MSG_RE =
 	/git\s+commit\s+(?:[^"']*?)(?:-[a-z]*m|-m)\s+(["'])([\s\S]*?)\1/g;
 
-export function injectCoAuthorIntoGitCommit(cmd: string): string {
+export function injectCoAuthorIntoGitCommit(
+	cmd: string,
+	enabled = false,
+): string {
+	if (!enabled) return cmd;
 	return cmd.replace(GIT_COMMIT_MSG_RE, (match, quote, msg) => {
-		const patched = appendCoAuthorTrailer(msg);
+		const patched = appendCoAuthorTrailer(msg, true);
 		return match.replace(
 			`${quote}${msg}${quote}`,
 			`${quote}${patched}${quote}`,

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

@@ -6,7 +6,10 @@ import GIT_STATUS_DESCRIPTION from './git.status.txt' with { type: 'text' };
 import GIT_DIFF_DESCRIPTION from './git.diff.txt' with { type: 'text' };
 import GIT_COMMIT_DESCRIPTION from './git.commit.txt' with { type: 'text' };
 import { createToolError, type ToolResponse } from '../error.ts';
-import { appendCoAuthorTrailer } from './git-identity.ts';
+import {
+	appendCoAuthorTrailer,
+	shouldCoAuthorCommits,
+} from './git-identity.ts';
 
 const execAsync = promisify(exec);
 
@@ -120,7 +123,10 @@ export function buildGitTools(
 				});
 			}
 			const gitRoot = await findGitRoot();
-			const fullMessage = appendCoAuthorTrailer(message);
+			const fullMessage = appendCoAuthorTrailer(
+				message,
+				shouldCoAuthorCommits(projectRoot),
+			);
 			const args = [
 				'git',
 				'-C',

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

@@ -6,8 +6,12 @@
 
 **Use `glob` first to discover files** before reading them, unless you already know exact paths.
 
+Think of `glob` as the repository's fast local `find` replacement for filenames and paths. Use it before shelling out to `find`, `fd`, or `ls **`.
+
 ## Usage tips
 
 - 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).
+- Instead of `find packages -name "*.ts"`, call `glob` with `pattern: "packages/**/*.ts"`.
+- Instead of `find apps -name package.json`, call `glob` with `pattern: "apps/**/package.json"`.

package/src/core/src/tools/builtin/patch/indentation.ts

@@ -23,6 +23,7 @@ export function adjustReplacementIndentation(
 	let fileIndentChar: 'tab' | 'space' = 'space';
 	const deltas: number[] = [];
 	let hasAddStyleMismatch = false;
+	let hasContextContentMismatch = false;
 	let fileIndentDetected = false;
 
 	for (const fl of matchedFileLines) {
@@ -81,6 +82,7 @@ export function adjustReplacementIndentation(
 		if (line.kind === 'context') {
 			const fileLine = matchedFileLines[expectedIdx];
 			if (fileLine !== undefined) {
+				if (line.content !== fileLine) hasContextContentMismatch = true;
 				lastDelta = computeIndentDelta(line.content, fileLine, tabSize);
 				lastFileIndentExpanded = expandWhitespace(
 					getLeadingWhitespace(fileLine),
@@ -152,7 +154,12 @@ export function adjustReplacementIndentation(
 		}
 	}
 
-	if (!hasDelta && !hasStyleMismatch && !hasAddStyleMismatch) {
+	if (
+		!hasDelta &&
+		!hasStyleMismatch &&
+		!hasAddStyleMismatch &&
+		!hasContextContentMismatch
+	) {
 		return hunk.lines.filter((l) => l.kind !== 'remove').map((l) => l.content);
 	}
 

package/src/core/src/tools/builtin/patch/normalize.ts

@@ -3,6 +3,7 @@ enum NormalizationLevel {
 	TABS_ONLY = 'tabs',
 	WHITESPACE = 'whitespace',
 	AGGRESSIVE = 'aggressive',
+	COLLAPSED = 'collapsed',
 }
 
 const DEFAULT_TAB_SIZE = 2;
@@ -22,6 +23,8 @@ export function normalizeWhitespace(
 			return line.replace(/\t/g, tabReplacement).replace(/\s+$/, '');
 		case NormalizationLevel.AGGRESSIVE:
 			return line.replace(/\t/g, tabReplacement).trim();
+		case NormalizationLevel.COLLAPSED:
+			return line.replace(/\t/g, tabReplacement).trim().replace(/\s+/g, ' ');
 		default:
 			return line;
 	}
@@ -32,6 +35,7 @@ export const NORMALIZATION_LEVELS: NormalizationLevel[] = [
 	NormalizationLevel.TABS_ONLY,
 	NormalizationLevel.WHITESPACE,
 	NormalizationLevel.AGGRESSIVE,
+	NormalizationLevel.COLLAPSED,
 ];
 
 export function getLeadingWhitespace(line: string): string {