@oh-my-pi/pi-coding-agent 15.1.8 → 15.2.1

package/src/config/model-registry.ts

@@ -1017,7 +1017,8 @@ export class ModelRegistry {
 	}
 
 	#addImplicitDiscoverableProviders(configuredProviders: Set<string>): void {
-		if (!configuredProviders.has("ollama")) {
+		const disabledProviders = getDisabledProviderIdsFromSettings();
+		if (!configuredProviders.has("ollama") && !disabledProviders.has("ollama")) {
 			this.#discoverableProviders.push({
 				provider: "ollama",
 				api: "openai-responses",
@@ -1027,7 +1028,7 @@ export class ModelRegistry {
 			});
 			this.#keylessProviders.add("ollama");
 		}
-		if (!configuredProviders.has("llama.cpp")) {
+		if (!configuredProviders.has("llama.cpp") && !disabledProviders.has("llama.cpp")) {
 			this.#discoverableProviders.push({
 				provider: "llama.cpp",
 				api: "openai-responses",
@@ -1040,7 +1041,7 @@ export class ModelRegistry {
 				this.#keylessProviders.add("llama.cpp");
 			}
 		}
-		if (!configuredProviders.has("lm-studio")) {
+		if (!configuredProviders.has("lm-studio") && !disabledProviders.has("lm-studio")) {
 			this.#discoverableProviders.push({
 				provider: "lm-studio",
 				api: "openai-completions",
@@ -1160,9 +1161,12 @@ export class ModelRegistry {
 		strategy: ModelRefreshStrategy,
 		providerFilter?: ReadonlySet<string>,
 	): Promise<void> {
-		const selectedDiscoverableProviders = providerFilter
-			? this.#discoverableProviders.filter(provider => providerFilter.has(provider.provider))
-			: this.#discoverableProviders;
+		const disabledProviders = getDisabledProviderIdsFromSettings();
+		const selectedDiscoverableProviders = (
+			providerFilter
+				? this.#discoverableProviders.filter(provider => providerFilter.has(provider.provider))
+				: this.#discoverableProviders
+		).filter(provider => !disabledProviders.has(provider.provider));
 		const configuredDiscoveriesPromise =
 			selectedDiscoverableProviders.length === 0
 				? Promise.resolve<Model<Api>[]>([])
@@ -1366,17 +1370,24 @@ export class ModelRegistry {
 				},
 			},
 		];
+		const disabledProviders = getDisabledProviderIdsFromSettings();
+		const standardProviderDescriptors = PROVIDER_DESCRIPTORS.filter(
+			descriptor => !disabledProviders.has(descriptor.providerId),
+		);
+		const enabledSpecialProviderDescriptors = specialProviderDescriptors.filter(
+			descriptor => !disabledProviders.has(descriptor.providerId),
+		);
 		// Use peekApiKey to avoid OAuth token refresh during discovery.
 		// The token is only needed if the dynamic fetch fires (cache miss),
 		// and failures there are handled gracefully.
 		const peekKey = (descriptor: { providerId: string }) => this.#peekApiKeyForProvider(descriptor.providerId);
 		const [standardProviderKeys, specialKeys] = await Promise.all([
-			Promise.all(PROVIDER_DESCRIPTORS.map(peekKey)),
-			Promise.all(specialProviderDescriptors.map(peekKey)),
+			Promise.all(standardProviderDescriptors.map(peekKey)),
+			Promise.all(enabledSpecialProviderDescriptors.map(peekKey)),
 		]);
 		const options: ModelManagerOptions<Api>[] = [];
-		for (let i = 0; i < PROVIDER_DESCRIPTORS.length; i++) {
-			const descriptor = PROVIDER_DESCRIPTORS[i];
+		for (let i = 0; i < standardProviderDescriptors.length; i++) {
+			const descriptor = standardProviderDescriptors[i];
 			const apiKey = standardProviderKeys[i];
 			if (isAuthenticated(apiKey) || descriptor.allowUnauthenticated) {
 				options.push(
@@ -1388,8 +1399,8 @@ export class ModelRegistry {
 			}
 		}
 
-		for (let i = 0; i < specialProviderDescriptors.length; i++) {
-			const descriptor = specialProviderDescriptors[i];
+		for (let i = 0; i < enabledSpecialProviderDescriptors.length; i++) {
+			const descriptor = enabledSpecialProviderDescriptors[i];
 			const key = descriptor.resolveKey(specialKeys[i]);
 			if (!isAuthenticated(key)) {
 				continue;

package/src/config/settings-schema.ts

@@ -583,6 +583,18 @@ export const SETTINGS_SCHEMA = {
 		description:
 			"Maximum height in terminal rows for inline images (default 20). Set to 0 to use only the viewport-based limit (60% of terminal height).",
 	},
+
+	"tui.hyperlinks": {
+		type: "enum",
+		values: ["off", "auto", "always"] as const,
+		default: "auto",
+		ui: {
+			tab: "appearance",
+			label: "Terminal Hyperlinks",
+			description:
+				"Wrap file paths in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)",
+		},
+	},
 	// Display rendering
 	"display.tabWidth": {
 		type: "number",

package/src/config/settings.ts

@@ -129,6 +129,18 @@ function stringArrayFromUnknown(value: unknown): string[] {
 	return [];
 }
 
+function shallowStringRecord(value: unknown): Record<string, string> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+
+	const result: Record<string, string> = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (typeof item === "string") {
+			result[key] = item;
+		}
+	}
+	return result;
+}
+
 function resolvePathScopedStringArray(settingPath: SettingPath, value: unknown, cwd: string): string[] | undefined {
 	if (!PATH_SCOPED_ARRAY_SETTINGS.has(settingPath) || !Array.isArray(value)) return undefined;
 
@@ -424,8 +436,19 @@ export class Settings {
 	 * Set a model role (helper for modelRoles record).
 	 */
 	setModelRole(role: ModelRole | string, modelId: string): void {
-		const current = this.get("modelRoles");
+		const current = shallowStringRecord(getByPath(this.#global, ["modelRoles"]));
+		const runtimeOverrides = getByPath(this.#overrides, ["modelRoles"]);
+		const updateRuntimeOverride =
+			!!runtimeOverrides &&
+			typeof runtimeOverrides === "object" &&
+			!Array.isArray(runtimeOverrides) &&
+			Object.hasOwn(runtimeOverrides, role);
+
 		this.set("modelRoles", { ...current, [role]: modelId });
+
+		if (updateRuntimeOverride) {
+			this.override("modelRoles", { ...shallowStringRecord(runtimeOverrides), [role]: modelId });
+		}
 	}
 
 	/**
@@ -440,20 +463,20 @@ export class Settings {
 	 * Get all model roles (helper for modelRoles record).
 	 */
 	getModelRoles(): ReadOnlyDict<string> {
-		return this.get("modelRoles");
+		return { ...this.get("modelRoles") };
 	}
 
 	/*
 	 * Override model roles (helper for modelRoles record).
 	 */
 	overrideModelRoles(roles: ReadOnlyDict<string>): void {
-		const prev = this.get("modelRoles");
+		const next = shallowStringRecord(getByPath(this.#overrides, ["modelRoles"]));
 		for (const [role, modelId] of Object.entries(roles)) {
 			if (modelId) {
-				prev[role] = modelId;
+				next[role] = modelId;
 			}
 		}
-		this.override("modelRoles", prev);
+		this.override("modelRoles", next);
 	}
 
 	/**

package/src/edit/renderer.ts

@@ -25,7 +25,7 @@ import {
 	truncateDiffByHunk,
 } from "../tools/render-utils";
 import { type VimRenderArgs, vimToolRenderer } from "../tools/vim";
-import { Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+import { fileHyperlink, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
 import type { EditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
 import type { DiffError, DiffResult } from "./diff";
@@ -219,14 +219,16 @@ function formatEditPathDisplay(
 	uiTheme: Theme,
 	options?: { rename?: string; firstChangedLine?: number },
 ): string {
-	let pathDisplay = rawPath ? uiTheme.fg("accent", shortenPath(rawPath)) : uiTheme.fg("toolOutput", "…");
+	let pathDisplay = rawPath
+		? fileHyperlink(rawPath, uiTheme.fg("accent", shortenPath(rawPath)))
+		: uiTheme.fg("toolOutput", "…");
 
 	if (options?.firstChangedLine) {
 		pathDisplay += uiTheme.fg("warning", `:${options.firstChangedLine}`);
 	}
 
 	if (options?.rename) {
-		pathDisplay += ` ${uiTheme.fg("dim", "→")} ${uiTheme.fg("accent", shortenPath(options.rename))}`;
+		pathDisplay += ` ${uiTheme.fg("dim", "→")} ${fileHyperlink(options.rename, uiTheme.fg("accent", shortenPath(options.rename)))}`;
 	}
 
 	return pathDisplay;

package/src/eval/py/executor.ts

@@ -209,6 +209,15 @@ function formatTimeoutAnnotation(timeoutMs?: number): string | undefined {
 	return `Command timed out after ${secs} seconds`;
 }
 
+function formatKernelTimeoutAnnotation(timeoutMs: number | undefined, kernelKilled: boolean): string {
+	const secs = timeoutMs === undefined ? undefined : Math.max(1, Math.round(timeoutMs / 1000));
+	if (kernelKilled) {
+		return "eval cell timed out and the kernel was unresponsive to interrupt; the kernel has been killed and will be recreated on the next call.";
+	}
+	const duration = secs === undefined ? "the configured timeout" : `${secs}s`;
+	return `eval cell timed out after ${duration}; kernel interrupted but remains running. Reset the kernel via { reset: true } if state appears corrupted.`;
+}
+
 function createCancelledPythonResult(timedOut: boolean, timeoutMs?: number): PythonResult {
 	const output = timedOut ? (formatTimeoutAnnotation(timeoutMs) ?? "Command timed out") : "";
 	const outputBytes = Buffer.byteLength(output, "utf-8");
@@ -434,7 +443,9 @@ async function executeWithKernel(
 		});
 
 		if (result.cancelled) {
-			const annotation = result.timedOut ? formatTimeoutAnnotation(executionTimeoutMs) : undefined;
+			const annotation = result.timedOut
+				? formatKernelTimeoutAnnotation(executionTimeoutMs, result.kernelKilled ?? false)
+				: undefined;
 			return {
 				exitCode: undefined,
 				cancelled: true,

package/src/eval/py/kernel.ts

@@ -46,8 +46,10 @@ const STARTUP_TIMEOUT_MS = 10_000;
 // How long to wait after SIGINT for the runner to emit `done`. If the cell is
 // stuck in code that ignores Python signals (e.g. a C extension holding the
 // GIL), we escalate to a full subprocess shutdown so the host queue unblocks
-// instead of hanging the session forever.
-const INTERRUPT_ESCALATION_MS = 2_000;
+// instead of hanging the session forever. The grace window is intentionally
+// generous: a clean interrupt is far preferable to losing the persistent
+// kernel's state, so we only kill as a last-resort recovery path.
+const INTERRUPT_ESCALATION_MS = 5_000;
 
 export interface KernelExecuteOptions {
 	signal?: AbortSignal;
@@ -66,6 +68,12 @@ export interface KernelExecuteResult {
 	cancelled: boolean;
 	timedOut: boolean;
 	stdinRequested: boolean;
+	/**
+	 * True when the kernel subprocess was killed as part of settling this
+	 * execution (e.g. SIGINT was ignored and we escalated to shutdown, or the
+	 * kernel died unexpectedly). When false, the kernel remains reusable.
+	 */
+	kernelKilled?: boolean;
 }
 
 export interface KernelShutdownResult {
@@ -162,6 +170,7 @@ interface PendingExecution {
 	cancelled: boolean;
 	timedOut: boolean;
 	stdinRequested: boolean;
+	kernelKilled: boolean;
 	settled: boolean;
 	escalationTimer?: NodeJS.Timeout;
 }
@@ -222,7 +231,7 @@ export class PythonKernel {
 		kernel.#exitedPromise = proc.exited;
 		void kernel.#exitedPromise.then(code => {
 			kernel.#alive = false;
-			kernel.#abortPendingExecutions(`Python kernel exited with code ${code}`);
+			kernel.#abortPendingExecutions(`Python kernel exited with code ${code}`, { kernelKilled: true });
 		});
 
 		kernel.#startReader(proc.stdout as ReadableStream<Uint8Array>);
@@ -261,6 +270,7 @@ export class PythonKernel {
 			timedOut: false,
 			stdinRequested: false,
 			settled: false,
+			kernelKilled: false,
 		};
 		this.#pending.set(msgId, pending);
 
@@ -276,6 +286,7 @@ export class PythonKernel {
 				cancelled: pending.cancelled,
 				timedOut: pending.timedOut,
 				stdinRequested: pending.stdinRequested,
+				kernelKilled: pending.kernelKilled,
 			});
 		};
 
@@ -287,9 +298,12 @@ export class PythonKernel {
 				logger.warn("Python runner did not respond to SIGINT; terminating subprocess", {
 					kernelId: this.id,
 				});
-				// `shutdown()` aborts pending executions immediately and escalates to
-				// SIGTERM/SIGKILL, so the host queue unblocks even if the runner is
-				// stuck in a non-interruptible state.
+				// SIGINT was ignored; mark the cell as kernel-killed so callers can
+				// surface the harsher recovery message. `shutdown()` aborts pending
+				// executions immediately and escalates to SIGTERM/SIGKILL, so the
+				// host queue unblocks even if the runner is stuck in a
+				// non-interruptible state.
+				pending.kernelKilled = true;
 				void this.shutdown();
 			}, INTERRUPT_ESCALATION_MS);
 			escalation.unref?.();
@@ -363,7 +377,7 @@ export class PythonKernel {
 		if (this.#shutdownConfirmed) return { confirmed: true };
 
 		this.#alive = false;
-		this.#abortPendingExecutions("Python kernel shutdown");
+		this.#abortPendingExecutions("Python kernel shutdown", { kernelKilled: true });
 
 		const timeoutMs = options?.timeoutMs ?? SHUTDOWN_GRACE_MS;
 		const proc = this.#proc;
@@ -410,10 +424,11 @@ export class PythonKernel {
 		return { confirmed };
 	}
 
-	#abortPendingExecutions(reason: string): void {
+	#abortPendingExecutions(reason: string, options?: { kernelKilled?: boolean }): void {
 		if (this.#pending.size === 0) return;
 		const pending = Array.from(this.#pending.values());
 		this.#pending.clear();
+		const kernelKilledDefault = options?.kernelKilled ?? false;
 		for (const entry of pending) {
 			if (entry.settled) continue;
 			entry.settled = true;
@@ -425,6 +440,7 @@ export class PythonKernel {
 				stdinRequested: entry.stdinRequested,
 				executionCount: entry.executionCount,
 				error: entry.error,
+				kernelKilled: entry.kernelKilled || kernelKilledDefault,
 			});
 		}
 	}

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -154,7 +154,7 @@ interface LegacyPiMirrorState {
 function getMirrorPath(sourcePath: string, state: LegacyPiMirrorState): string {
 	const extension = path.extname(sourcePath) || ".js";
 	const digest = Bun.hash(sourcePath).toString(36);
-	return path.join(state.root, `${digest}${extension}`);
+	return path.join(state.root, `module-${digest}${extension}`);
 }
 
 async function rewriteRelativeImportsForLegacyExtension(
@@ -212,7 +212,7 @@ async function mirrorLegacyPiFile(sourcePath: string, state: LegacyPiMirrorState
 }
 
 export async function loadLegacyPiModule(resolvedPath: string): Promise<unknown> {
-	const root = path.join(os.tmpdir(), "omp-legacy-pi-file", Bun.hash(resolvedPath).toString(36));
+	const root = path.join(os.tmpdir(), "omp-legacy-pi-file", `entry-${Bun.hash(resolvedPath).toString(36)}`);
 	await fs.rm(root, { recursive: true, force: true });
 	const state: LegacyPiMirrorState = { root, seen: new Map() };
 	const mirroredEntry = await mirrorLegacyPiFile(resolvedPath, state);

package/src/goals/runtime.ts

@@ -379,7 +379,7 @@ export class GoalRuntime {
 		validateTokenBudget(input.tokenBudget);
 		return await this.#withAccounting(async () => {
 			const existing = this.#host.getState();
-			if (existing?.goal && existing.goal.status !== "dropped") {
+			if (existing?.goal && existing.goal.status !== "dropped" && existing.goal.status !== "complete") {
 				throw new Error("cannot create a new goal because this session already has a goal");
 			}
 			const now = this.#now();
@@ -459,8 +459,14 @@ export class GoalRuntime {
 		return await this.#withAccounting(async () => {
 			await this.#flushUsageLocked("suppressed");
 			const state = this.#getStateClone();
-			if (!state?.enabled || !state.goal) {
-				throw new Error("cannot complete goal because goal mode is not active");
+			if (!state?.goal) {
+				throw new Error("cannot complete goal because no goal is active");
+			}
+			if (state.goal.status === "complete") {
+				throw new Error("goal is already complete");
+			}
+			if (state.goal.status === "dropped") {
+				throw new Error("cannot complete a dropped goal");
 			}
 			state.enabled = false;
 			state.goal.status = "complete";

package/src/goals/state.ts

@@ -21,7 +21,7 @@ export interface GoalModeState {
 }
 
 export interface GoalToolDetails {
-	op: "create" | "get" | "complete";
+	op: "create" | "get" | "complete" | "resume" | "drop";
 	goal?: Goal | null;
 	remainingTokens?: number | null;
 	completionBudgetReport?: string | null;

package/src/goals/tools/goal-tool.ts

@@ -15,7 +15,7 @@ import { completionBudgetReport, remainingTokens } from "../runtime";
 import type { Goal, GoalStatus, GoalToolDetails } from "../state";
 
 const goalSchema = z.object({
-	op: z.enum(["create", "get", "complete"]).describe("goal operation"),
+	op: z.enum(["create", "get", "complete", "resume", "drop"]).describe("goal operation"),
 	objective: z.string().describe("goal objective").optional(),
 	token_budget: z.number().int().describe("token budget").optional(),
 });
@@ -86,7 +86,13 @@ export class GoalTool implements AgentTool<typeof goalSchema, GoalToolDetails> {
 			response = buildGoalToolResponse(created.goal);
 		} else if (params.op === "get") {
 			const state = this.#session.getGoalModeState?.();
-			response = buildGoalToolResponse(state?.enabled ? state.goal : null);
+			response = buildGoalToolResponse(state?.goal ?? null);
+		} else if (params.op === "resume") {
+			const resumed = await runtime.resumeGoal();
+			response = buildGoalToolResponse(resumed.goal);
+		} else if (params.op === "drop") {
+			const dropped = await runtime.dropGoal();
+			response = buildGoalToolResponse(dropped ?? null);
 		} else {
 			const completed = await runtime.completeGoalFromTool();
 			response = buildGoalToolResponse(completed, { includeCompletionReport: true });
@@ -126,6 +132,10 @@ function describeOp(op: string | undefined): string {
 			return "complete";
 		case "get":
 			return "check";
+		case "resume":
+			return "resume";
+		case "drop":
+			return "drop";
 		default:
 			return op ?? "?";
 	}

package/src/hashline/diff.ts

@@ -30,7 +30,7 @@ export async function computeHashlineSectionDiff(
 		const rawContent = await readHashlineFileText(Bun.file(absolutePath), absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		const result = applyHashlineEdits(normalized, parseHashline(section.diff), options);
+		const result = applyHashlineEdits(normalized, parseHashline(section.diff, { path: section.path }), options);
 		if (normalized === result.lines) return { error: `No changes would be made to ${section.path}.` };
 		return generateDiffString(normalized, result.lines);
 	} catch (err) {

package/src/hashline/execute.ts

@@ -106,7 +106,7 @@ async function preflightHashlineSection(options: ExecuteHashlineSingleOptions &
 	const { session, path: sectionPath, diff } = options;
 
 	const absolutePath = resolvePlanPath(session, sectionPath);
-	const { edits } = parseHashlineWithWarnings(diff);
+	const { edits } = parseHashlineWithWarnings(diff, { path: sectionPath });
 	enforcePlanModeWrite(session, sectionPath, { op: "update" });
 
 	const source = await readHashlineFile(absolutePath, sectionPath);
@@ -139,7 +139,7 @@ async function executeHashlineSection(
 	} = options;
 
 	const absolutePath = resolvePlanPath(session, sourcePath);
-	const { edits, warnings: parseWarnings } = parseHashlineWithWarnings(diff);
+	const { edits, warnings: parseWarnings } = parseHashlineWithWarnings(diff, { path: sourcePath });
 	enforcePlanModeWrite(session, sourcePath, { op: "update" });
 
 	const source = await readHashlineFile(absolutePath, sourcePath);

package/src/hashline/parser.ts

@@ -74,22 +74,86 @@ export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
 	if (cursor.kind === "after_anchor") return { kind: "after_anchor", anchor: { ...cursor.anchor } };
 	return cursor;
 }
-/** Returns true when every non-empty payload line starts with `${sep} ` (sep + one space). */
+/**
+ * Returns true when every non-empty payload line looks like the `~ TEXT` readability-padding
+ * typo: exactly one leading space followed by a non-space character (or a bare single space).
+ *
+ * Indented file content (Python 4-space, YAML/JSON/Markdown 2-space, etc.) starts with two or
+ * more leading spaces, so this heuristic ignores legitimate indentation while still flagging
+ * the common `~ beta` mistake that silently corrupts file content with a stray space.
+ */
 function hasUniformSeparatorPadding(payload: string[]): boolean {
 	let any = false;
 	for (const text of payload) {
 		if (text.length === 0) continue;
-		if (!text.startsWith(" ")) return false;
+		if (text.charCodeAt(0) !== 0x20) return false;
+		// Two or more leading spaces is real indentation, not separator padding.
+		if (text.length > 1 && text.charCodeAt(1) === 0x20) return false;
 		any = true;
 	}
 	return any;
 }
 
+/**
+ * File extensions where leading single-space indentation is plausible legitimate file content
+ * (off-side-rule languages, structured-indent data formats, prose with continuation indent).
+ * For these we suppress the separator-padding warning entirely — the heuristic's false-positive
+ * cost on a real edit outweighs the rare chance it catches a `~ TEXT` typo.
+ */
+const INDENT_SENSITIVE_EXTS: Record<string, true> = {
+	".py": true,
+	".pyi": true,
+	".pyx": true,
+	".pyw": true,
+	".yml": true,
+	".yaml": true,
+	".md": true,
+	".mdx": true,
+	".markdown": true,
+	".rst": true,
+	".adoc": true,
+	".asciidoc": true,
+	".toml": true,
+	".json": true,
+	".jsonc": true,
+	".json5": true,
+	".ndjson": true,
+	".jsonl": true,
+	".tf": true,
+	".tfvars": true,
+	".hcl": true,
+	".nix": true,
+	".coffee": true,
+	".litcoffee": true,
+	".haml": true,
+	".slim": true,
+	".pug": true,
+	".jade": true,
+	".sass": true,
+	".styl": true,
+	".nim": true,
+	".cr": true,
+	".elm": true,
+	".fs": true,
+	".fsi": true,
+	".fsx": true,
+};
+
+function isIndentationSensitivePath(path: string | undefined): boolean {
+	if (!path) return false;
+	const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	const dot = path.lastIndexOf(".");
+	if (dot <= slash) return false;
+	const ext = path.slice(dot).toLowerCase();
+	return INDENT_SENSITIVE_EXTS[ext] === true;
+}
+
 function collectPayload(
 	lines: string[],
 	startIndex: number,
 	opLineNum: number,
 	requirePayload: boolean,
+	checkPadding: boolean,
 ): { payload: string[]; nextIndex: number; paddingWarning?: string } {
 	const payload: string[] = [];
 	let index = startIndex;
@@ -125,21 +189,32 @@ function collectPayload(
 	if (payload.length === 0 && requirePayload) {
 		throw new Error(`line ${opLineNum}: + and < operations require at least one ${HL_EDIT_SEP}TEXT payload line.`);
 	}
-	const paddingWarning = hasUniformSeparatorPadding(payload)
-		? `line ${opLineNum}: all payload lines start with "${HL_EDIT_SEP} " (separator + space). ` +
-			`The space becomes file content. Remove it unless the target file requires leading spaces.`
-		: undefined;
+	const paddingWarning =
+		checkPadding && hasUniformSeparatorPadding(payload)
+			? `line ${opLineNum}: every payload line begins with exactly one space before non-space content, ` +
+				`which looks like a readability gap after "${HL_EDIT_SEP}". The space becomes file content. ` +
+				`Drop it unless the file genuinely uses a one-space indent.`
+			: undefined;
 	return { payload, nextIndex: index, paddingWarning };
 }
 
-export function parseHashline(diff: string): HashlineEdit[] {
-	return parseHashlineWithWarnings(diff).edits;
+export function parseHashline(diff: string, opts: ParseHashlineOptions = {}): HashlineEdit[] {
+	return parseHashlineWithWarnings(diff, opts).edits;
+}
+
+export interface ParseHashlineOptions {
+	/** File path the diff targets. Used to suppress indent-sensitive false-positive warnings. */
+	path?: string;
 }
 
-export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]; warnings: string[] } {
+export function parseHashlineWithWarnings(
+	diff: string,
+	opts: ParseHashlineOptions = {},
+): { edits: HashlineEdit[]; warnings: string[] } {
 	const edits: HashlineEdit[] = [];
 	const warnings: string[] = [];
 	const lines = diff.split(/\r?\n/);
+	const checkPadding = !isIndentationSensitivePath(opts.path);
 	let editIndex = 0;
 
 	const pushInsert = (cursor: HashlineCursor, text: string, lineNum: number) => {
@@ -172,7 +247,7 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const insertBeforeMatch = INSERT_BEFORE_OP_RE.exec(line);
 		if (insertBeforeMatch) {
 			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
-			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true, checkPadding);
 			if (paddingWarning) warnings.push(paddingWarning);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
@@ -182,7 +257,7 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const insertAfterMatch = INSERT_AFTER_OP_RE.exec(line);
 		if (insertAfterMatch) {
 			const cursor = parseInsertTarget(insertAfterMatch[1], lineNum, "after");
-			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true, checkPadding);
 			if (paddingWarning) warnings.push(paddingWarning);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
@@ -201,7 +276,7 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const replaceMatch = REPLACE_OP_RE.exec(line);
 		if (replaceMatch) {
 			const range = parseRange(replaceMatch[1], lineNum);
-			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, false);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, false, checkPadding);
 			if (paddingWarning) warnings.push(paddingWarning);
 			// `= A..B` with no payload blanks the range to a single empty line.
 			const replacement = payload.length === 0 ? [""] : payload;

package/src/internal-urls/memory-protocol.ts

@@ -14,7 +14,7 @@ const MEMORY_NAMESPACE = "root";
  * Each session has its own cwd (possibly a worktree), so subagents and main
  * may see different roots.
  */
-function memoryRootsFromRegistry(): string[] {
+export function memoryRootsFromRegistry(): string[] {
 	const agentDir = getAgentDir();
 	const roots: string[] = [];
 	for (const ref of AgentRegistry.global().list()) {

package/src/main.ts

@@ -199,7 +199,7 @@ function applyExtensionFlagValues(session: AgentSession, rawArgs: string[]): Map
 
 type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
 
-interface AcpSessionFactoryOptions {
+export interface AcpSessionFactoryOptions {
 	baseOptions: CreateAgentSessionOptions;
 	settings: Settings;
 	sessionDir?: string;
@@ -210,7 +210,17 @@ interface AcpSessionFactoryOptions {
 	createSession: (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
 }
 
-function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory {
+/**
+ * Build the per-`session/new` factory used by ACP mode.
+ *
+ * MCP servers in ACP sessions are owned exclusively by the ACP client, which
+ * supplies them through `session/new.mcpServers` and re-applies them via
+ * {@link AcpAgent#configureMcpServers}. We therefore force `enableMCP: false`
+ * on every session created here so {@link createAgentSession} skips the on-disk
+ * `.mcp.json` discovery path — otherwise host MCP tools land in the session's
+ * tool registry and shadow the client-supplied servers (issue #1234).
+ */
+export function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory {
 	return async cwd => {
 		const nextSettings = await args.settings.cloneForCwd(cwd);
 		const nextSessionManager = SessionManager.create(cwd, args.sessionDir);
@@ -224,6 +234,7 @@ function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFact
 			modelRegistry: args.modelRegistry,
 			agentId,
 			hasUI: false,
+			enableMCP: false,
 		});
 		if (args.parsedArgs.apiKey && !args.baseOptions.model && nextSession.model) {
 			args.authStorage.setRuntimeApiKey(nextSession.model.provider, args.parsedArgs.apiKey);