@oh-my-pi/pi-coding-agent 17.1.7 → 17.2.0

package/src/discovery/claude-plugins.ts

@@ -41,6 +41,20 @@ interface ResolvedPluginDir {
 	warnings: string[];
 }
 
+interface ResolvedMCPConfig {
+	/** On-disk config file to read, or null when servers are inline or nothing applies. */
+	path: string | null;
+	/** Server map declared inline in the plugin manifest, or null when the source is a file. */
+	inlineServers: Record<string, unknown> | null;
+	/** Path recorded as each discovered server's capability source. */
+	sourcePath: string;
+	/** Directory that relative stdio `command`/`cwd` values resolve against. */
+	baseDir: string;
+	/** True when a plugin manifest named this source, false for the conventional fallback. */
+	declared: boolean;
+	warnings: string[];
+}
+
 async function readPluginManifest(root: ClaudePluginRoot): Promise<ClaudePluginManifest | null> {
 	const manifestPath = path.join(root.path, ".claude-plugin", "plugin.json");
 	const raw = await readFile(manifestPath);
@@ -375,50 +389,144 @@ async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
 // MCP Servers
 // =============================================================================
 
-async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
-	const items: MCPServer[] = [];
-	const warnings: string[] = [];
-
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
-	warnings.push(...rootWarnings);
+/**
+ * Unwrap a parsed MCP config file to its server map. Supports the nested
+ * `{ mcpServers: { … } }` project shape and the flat `{ name: cfg, … }`
+ * marketplace-plugin shape. Returns null when a `mcpServers` field is present
+ * but not an object map (malformed) so the caller skips the file.
+ */
+function extractServerMap(obj: Record<string, unknown>): Record<string, unknown> | null {
+	if (isRecord(obj.mcpServers)) return obj.mcpServers;
+	if (!("mcpServers" in obj)) return obj;
+	return null;
+}
 
-	for (const root of roots) {
-		const mcpPath = path.join(root.path, ".mcp.json");
-		const raw = await readFile(mcpPath);
-		if (raw === null) continue; // file absent — skip silently
+/**
+ * Resolve where a plugin's MCP servers come from, honoring the manifest's
+ * `mcpServers` field before the conventional root `.mcp.json`.
+ *
+ * `.omp-plugin/plugin.json` takes precedence over `.claude-plugin/plugin.json`.
+ * The field may be an inline object (the server map itself) or a string path to
+ * a config file within the plugin root; a path escaping the root is rejected
+ * with a warning. When no manifest declares the field, `<root>/.mcp.json` is the
+ * fallback source.
+ */
+async function resolvePluginMCPConfig(root: ClaudePluginRoot): Promise<ResolvedMCPConfig> {
+	const fallback = path.join(root.path, ".mcp.json");
+	for (const manifestDir of [".omp-plugin", ".claude-plugin"]) {
+		const manifestPath = path.join(root.path, manifestDir, "plugin.json");
+		const raw = await readFile(manifestPath);
+		if (raw === null) continue;
 
 		let parsed: unknown;
 		try {
 			parsed = JSON.parse(raw);
 		} catch {
-			warnings.push(`[claude-plugins] Invalid JSON in ${mcpPath}`);
-			logger.warn(`[claude-plugins] Invalid JSON in ${mcpPath}`);
 			continue;
 		}
+		if (!isRecord(parsed)) continue;
+		const pointer = parsed.mcpServers;
+
+		// Inline object form: the manifest value is the server map itself, rooted
+		// at the plugin directory (Claude's ${CLAUDE_PLUGIN_ROOT} base).
+		if (isRecord(pointer)) {
+			return {
+				path: null,
+				inlineServers: pointer,
+				sourcePath: manifestPath,
+				baseDir: root.path,
+				declared: true,
+				warnings: [],
+			};
+		}
+
+		// File-pointer form: resolve the named config file within the plugin root.
+		if (typeof pointer === "string") {
+			const configured = pointer.trim();
+			if (configured.length === 0) continue;
+			const resolved = path.resolve(root.path, configured);
+			if (!isWithinPluginRoot(root.path, resolved)) {
+				return {
+					path: null,
+					inlineServers: null,
+					sourcePath: manifestPath,
+					baseDir: root.path,
+					declared: true,
+					warnings: [
+						`[claude-plugins] Ignoring mcpServers path outside plugin root for ${root.id}: ${configured}`,
+					],
+				};
+			}
+			return {
+				path: resolved,
+				inlineServers: null,
+				sourcePath: resolved,
+				baseDir: path.dirname(resolved),
+				declared: true,
+				warnings: [],
+			};
+		}
+	}
+
+	return {
+		path: fallback,
+		inlineServers: null,
+		sourcePath: fallback,
+		baseDir: path.dirname(fallback),
+		declared: false,
+		warnings: [],
+	};
+}
+
+async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
+	const items: MCPServer[] = [];
+	const warnings: string[] = [];
 
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
-		const obj = parsed as Record<string, unknown>;
-
-		// Two shapes are supported:
-		//   nested: { "mcpServers": { name: cfg, ... } }   (OMP/Claude Code project shape)
-		//   flat:   { name: cfg, ... }                      (Claude marketplace plugin shape)
-		// If "mcpServers" is present and an object, treat it as the canonical map.
-		// Otherwise, treat the whole object as the server map.
-		let servers: Record<string, unknown>;
-		if (
-			obj.mcpServers !== undefined &&
-			obj.mcpServers !== null &&
-			typeof obj.mcpServers === "object" &&
-			!Array.isArray(obj.mcpServers)
-		) {
-			servers = obj.mcpServers as Record<string, unknown>;
-		} else if (!("mcpServers" in obj)) {
-			servers = obj;
+	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
+	warnings.push(...rootWarnings);
+
+	for (const root of roots) {
+		const resolved = await resolvePluginMCPConfig(root);
+		warnings.push(...resolved.warnings);
+
+		let servers: Record<string, unknown> | null;
+		if (resolved.inlineServers) {
+			servers = resolved.inlineServers;
+		} else if (resolved.path !== null) {
+			const raw = await readFile(resolved.path);
+			if (raw === null) {
+				// The conventional fallback is optional, but a manifest that names a
+				// missing file is an authoring error that would otherwise register
+				// zero servers with no explanation.
+				if (resolved.declared) {
+					const warning = `[claude-plugins] Missing mcpServers file declared by ${root.id}: ${resolved.path}`;
+					warnings.push(warning);
+					logger.warn(warning);
+				}
+				continue;
+			}
+
+			let parsed: unknown;
+			try {
+				parsed = JSON.parse(raw);
+			} catch {
+				warnings.push(`[claude-plugins] Invalid JSON in ${resolved.path}`);
+				logger.warn(`[claude-plugins] Invalid JSON in ${resolved.path}`);
+				continue;
+			}
+			// Two file shapes are supported:
+			//   nested: { "mcpServers": { name: cfg, ... } }   (OMP/Claude Code project shape)
+			//   flat:   { name: cfg, ... }                      (Claude marketplace plugin shape)
+			if (!isRecord(parsed)) continue;
+			servers = extractServerMap(parsed);
 		} else {
 			continue;
 		}
+		if (servers === null) continue;
 
-		for (const [serverName, serverCfg] of Object.entries(servers)) {
+		const { sourcePath, baseDir } = resolved;
+		for (const serverName in servers) {
+			const serverCfg = servers[serverName];
 			if (!serverCfg || typeof serverCfg !== "object" || Array.isArray(serverCfg)) continue;
 			const raw = serverCfg as {
 				enabled?: boolean;
@@ -437,7 +545,9 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 			// occasionally ship .mcp.json entries with neither, which would register a useless
 			// server and surface as a connection error at runtime.
 			if (typeof raw.command !== "string" && typeof raw.url !== "string") {
-				warnings.push(`[claude-plugins] Skipping MCP server "${serverName}" in ${mcpPath}: missing command or url`);
+				warnings.push(
+					`[claude-plugins] Skipping MCP server "${serverName}" in ${sourcePath}: missing command or url`,
+				);
 				continue;
 			}
 			const namespacedName = root.plugin ? `${root.plugin}:${serverName}` : serverName;
@@ -446,7 +556,7 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 			const substitutedCwd = raw.cwd !== undefined ? substitutePluginRoot(raw.cwd, root.path) : undefined;
 			// Root relative command/cwd at the plugin's config directory, not the
 			// session cwd (MCP stdio spawning resolves relative values there).
-			const rooted = resolvePluginStdioPaths({ command: substitutedCommand, cwd: substitutedCwd }, root.path);
+			const rooted = resolvePluginStdioPaths({ command: substitutedCommand, cwd: substitutedCwd }, baseDir);
 			const server: MCPServer = {
 				name: namespacedName,
 				...(raw.enabled !== undefined && { enabled: raw.enabled }),
@@ -460,7 +570,7 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 				...(raw.auth !== undefined && { auth: raw.auth }),
 				...(raw.oauth !== undefined && { oauth: raw.oauth }),
 				...(raw.type !== undefined && { transport: raw.type as MCPServer["transport"] }),
-				_source: createSourceMeta(PROVIDER_ID, mcpPath, root.scope),
+				_source: createSourceMeta(PROVIDER_ID, sourcePath, root.scope),
 			};
 			items.push(server);
 		}

package/src/edit/edit-clipboard.ts

@@ -0,0 +1,23 @@
+/**
+ * Session-bound edit clipboard register.
+ *
+ * `CUT`/`PASTE` hashline ops share one {@link Clipboard} per session so
+ * content captured by one edit call can be pasted by a later one (and across
+ * files within one call). The executor works on a fork per batch and commits
+ * it back only after every write lands — see `executeHashlineSingle`.
+ */
+import type { Clipboard } from "@oh-my-pi/hashline";
+
+interface EditClipboardOwner {
+	editClipboard?: Clipboard;
+}
+
+/**
+ * Look up (or lazily create) the clipboard register attached to a session.
+ * Storage lives on `session.editClipboard` so it ages out exactly with the
+ * session itself.
+ */
+export function getEditClipboard(session: EditClipboardOwner): Clipboard {
+	session.editClipboard ??= {};
+	return session.editClipboard;
+}

package/src/edit/hashline/diff.ts

@@ -13,6 +13,7 @@ import * as path from "node:path";
 import {
 	type ApplyResult,
 	applyEdits,
+	type Clipboard,
 	type Cursor,
 	computeFileHash,
 	type Edit,
@@ -26,8 +27,10 @@ import {
 	parsePatchStreaming,
 	Recovery,
 	resolveBlockEdits,
+	resolveClipboardEdits,
 	type SnapshotStore,
 	stripBom,
+	validateClipboardSequence,
 } from "@oh-my-pi/hashline";
 import { resolveToCwd } from "../../tools/path-utils";
 import { generateDiffString } from "../diff";
@@ -48,6 +51,14 @@ export interface HashlineDiffOptions {
 	 * authoring input; the final apply path still validates through Patcher.
 	 */
 	skipHashValidation?: boolean;
+	/**
+	 * Clipboard register shared across the sections of one patch preview.
+	 * `CUT` in an earlier section feeds `PASTE` in a later one, so the preview
+	 * matches apply. Multi-section previews MUST thread one register through
+	 * sections in patch order; omitted, each section gets a
+	 * private register (same-file cut/paste still previews correctly).
+	 */
+	clipboard?: Clipboard;
 }
 
 async function readSectionText(absolutePath: string, sectionPath: string): Promise<string> {
@@ -144,6 +155,7 @@ function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
 		if (edit.kind === "block") return true;
+		if (edit.kind === "cut") return true;
 		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 	});
 }
@@ -204,14 +216,24 @@ function applyPreviewEdits(args: {
 	const liveMatches = expected !== undefined && computeFileHash(normalized) === expected;
 	const edits = parsePreviewEdits(section, options.streaming);
 	const resolved = resolvePreviewEdits({ section, absolutePath, normalized, snapshots, expected, liveMatches, edits });
-	if (options.skipHashValidation || expected === undefined || liveMatches) return applyEdits(normalized, resolved);
-	if (!hasAnchorScopedEdit(resolved)) return applyEdits(normalized, resolved);
+	const clipboard = options.clipboard ?? {};
+	// Mirror the Patcher: surface clipboard sequencing mistakes with their
+	// targeted message before the recovery path below swallows them. Streaming
+	// previews stay lenient — a mid-typed op transiently violating sequencing
+	// must not flash an error frame.
+	if (!options.streaming) validateClipboardSequence(resolved, clipboard);
+	const applyOptions = { clipboard, ...(options.streaming ? { onEmptyPaste: "drop" as const } : {}) };
+	if (options.skipHashValidation || expected === undefined || liveMatches) {
+		return applyEdits(normalized, resolved, applyOptions);
+	}
+	if (!hasAnchorScopedEdit(resolved)) return applyEdits(normalized, resolved, applyOptions);
 
 	const recovered = new Recovery(snapshots).tryRecover({
 		path: absolutePath,
 		currentText: normalized,
 		fileHash: expected,
 		edits: resolved,
+		clipboard,
 	});
 	if (recovered) return recovered;
 	throw createMismatchError(section, absolutePath, normalized, snapshots, expected);
@@ -250,18 +272,36 @@ function insertCursorLine(cursor: Cursor, fileLineCount: number): number {
 function buildStreamingSectionDiff(
 	section: PatchSection,
 	normalized: string,
+	clipboard: Clipboard,
 ): { diff: string; firstChangedLine: number | undefined } | { error: string } {
 	const { edits, fileOp } = parsePatchStreaming(section.diff);
-	const resolved = resolveBlockEdits(edits, normalized, section.path, nativeBlockResolver, { onUnresolved: "drop" });
+	const blockResolved = resolveBlockEdits(edits, normalized, section.path, nativeBlockResolver, {
+		onUnresolved: "drop",
+	});
+	const fileLines = normalized.split("\n");
+	// Expand clipboard ops so a `PASTE` previews the moved rows. Resolve into
+	// a scratch register and commit it back only on success: a mid-typed
+	// capture (out-of-range while the range digits are still streaming,
+	// transient sequencing violations) throws AFTER earlier captures may have
+	// landed, and leaking those into the shared register would let a later
+	// section preview a paste that never happened. On failure, fall back to
+	// filtering the clipboard edits out of this section's frame.
+	const scratch: Clipboard = { ...clipboard };
+	let resolved: readonly Edit[];
+	try {
+		resolved = resolveClipboardEdits(blockResolved, fileLines, scratch, { onEmptyPaste: "drop" });
+		if (scratch.lines === undefined) delete clipboard.lines;
+		else clipboard.lines = scratch.lines;
+	} catch {
+		resolved = blockResolved.filter(edit => edit.kind !== "cut" && edit.kind !== "paste");
+	}
 	if (resolved.length === 0) {
-		// A whole-file op (REM / MV) carries no line edits: the change is the
-		// delete/move itself, conveyed by the result header, so emit an empty
-		// diff rather than a misleading "No changes" error.
+		// A whole-file op (REM / MV) carries no line edits; the result header
+		// conveys the change, so emit an empty diff.
 		if (fileOp) return { diff: "", firstChangedLine: undefined };
 		return { error: `No changes would be made to ${section.path}.` };
 	}
 
-	const fileLines = normalized.split("\n");
 	const rows: string[] = [];
 	let firstChangedLine: number | undefined;
 
@@ -323,11 +363,10 @@ export async function computeHashlineSectionDiff(
 		// diff: feed the in-flight ops through the natural-order builder so the
 		// streamed cursor stays pinned to the bottom. The args-complete pass
 		// (`streaming` unset) falls through to the real Myers diff below.
-		if (options.streaming) return buildStreamingSectionDiff(section, normalized);
+		if (options.streaming) return buildStreamingSectionDiff(section, normalized, options.clipboard ?? {});
 		const result = applyPreviewEdits({ section, absolutePath, normalized, snapshots, options });
 		if (normalized === result.text) {
-			// REM/MV-only sections change no text; the header conveys the
-			// delete/move, so don't surface a "No changes" error.
+			// REM/MV-only sections change no text; the header conveys the op.
 			if (section.fileOp) return { diff: "", firstChangedLine: undefined };
 			return { error: `No changes would be made to ${section.path}.` };
 		}

package/src/edit/hashline/execute.ts

@@ -13,6 +13,9 @@
 import {
 	type BlockResolution,
 	buildCompactDiffPreview,
+	type Clipboard,
+	commitClipboard,
+	forkClipboard,
 	MismatchError as HashlineMismatchError,
 	Patch,
 	Patcher,
@@ -25,6 +28,7 @@ import type { ToolSession } from "../../tools";
 import { outputMeta } from "../../tools/output-meta";
 import { ToolError } from "../../tools/tool-errors";
 import { generateDiffString } from "../diff";
+import { getEditClipboard } from "../edit-clipboard";
 import { getFileSnapshotStore } from "../file-snapshot-store";
 import type { EditToolDetails, EditToolPerFileResult, LspBatchRequest } from "../renderer";
 import { pruneOversizedEditSnapshots } from "../snapshot-details";
@@ -98,12 +102,24 @@ interface RenderedSection {
 	perFileResult: EditToolPerFileResult;
 }
 
+const BLOCK_OP_LABELS: Record<BlockResolution["op"], string> = {
+	replace: "SWAP.BLK",
+	insert_after: "INS.BLK.POST",
+	cut: "CUT.BLK",
+	paste_after: "PASTE.BLK.POST",
+};
+
 function formatBlockResolution(resolution: BlockResolution): string {
-	const op = resolution.op === "delete" ? "DEL.BLK" : resolution.op === "insert_after" ? "INS.BLK.POST" : "SWAP.BLK";
+	const op = BLOCK_OP_LABELS[resolution.op];
 	const lines = resolution.end - resolution.start + 1;
 	const span =
 		resolution.start === resolution.end ? `line ${resolution.start}` : `lines ${resolution.start}-${resolution.end}`;
-	const suffix = resolution.op === "insert_after" ? `; body lands after line ${resolution.end}` : "";
+	const suffix =
+		resolution.op === "insert_after"
+			? `; body lands after line ${resolution.end}`
+			: resolution.op === "paste_after"
+				? `; clipboard lands after line ${resolution.end}`
+				: "";
 	return `${op} ${resolution.anchorLine} → resolved ${span} (${lines} line${lines === 1 ? "" : "s"})${suffix}`;
 }
 
@@ -213,12 +229,19 @@ export async function executeHashlineSingle(
 	const enforceSeenLines = options.session.settings.get("edit.enforceSeenLines");
 	const patcher = new Patcher({ fs, snapshots, blockResolver: nativeBlockResolver, enforceSeenLines });
 
+	// The clipboard register is session-persistent: `CUT` in one edit call can
+	// `PASTE` in a later one. Each batch works on a fork and publishes it back
+	// only after writes land.
+	const sessionClipboard = getEditClipboard(options.session);
+	const clipboard = forkClipboard(sessionClipboard);
+
 	// Single-section fast path: prepare, commit, render.
 	const inputHash = hashPatchInput(options.input);
 	if (patch.sections.length === 1) {
 		fs.setBatchRequest(narrowBatchRequest(options.batchRequest, true));
-		const prepared = await patcher.prepare(patch.sections[0]);
+		const prepared = await patcher.prepare(patch.sections[0], clipboard);
 		const sectionResult = await patcher.commit(prepared);
+		commitClipboard(clipboard, sessionClipboard);
 		if (sectionResult.op === "noop") {
 			const { count, escalate } = recordNoopEdit(options.session, sectionResult.canonicalPath, inputHash);
 			if (escalate) {
@@ -231,9 +254,18 @@ export async function executeHashlineSingle(
 	}
 
 	// Multi-section: prepare every section up front so we fail fast before
-	// any write hits the filesystem.
+	// any write hits the filesystem. One clipboard register spans the batch,
+	// so `CUT` in one section feeds `PASTE` in a later one.
 	const prepared: PreparedSection[] = [];
-	for (const section of patch.sections) prepared.push(await patcher.prepare(section));
+	// Register state after each section's prepare. Commits are non-atomic: a
+	// mid-batch write failure leaves earlier sections on disk, so the session
+	// register must reflect exactly the landed prefix — content a landed CUT
+	// deleted would otherwise be lost.
+	const sectionStates: Clipboard[] = [];
+	for (const section of patch.sections) {
+		prepared.push(await patcher.prepare(section, clipboard));
+		sectionStates.push(forkClipboard(clipboard));
+	}
 	assertUniqueCanonicalPaths(prepared);
 	for (const entry of prepared) {
 		if (entry.isNoop) {
@@ -251,6 +283,7 @@ export async function executeHashlineSingle(
 		const isLast = i === prepared.length - 1;
 		fs.setBatchRequest(narrowBatchRequest(options.batchRequest, isLast));
 		const sectionResult = await patcher.commit(prepared[i]);
+		commitClipboard(sectionStates[i], sessionClipboard);
 		if (sectionResult.op === "noop") {
 			const { count, escalate } = recordNoopEdit(options.session, sectionResult.canonicalPath, inputHash);
 			throw escalate
@@ -260,7 +293,6 @@ export async function executeHashlineSingle(
 		resetNoopEdit(options.session, sectionResult.canonicalPath);
 		rendered.push(renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path), prepared[i].section.path));
 	}
-
 	return {
 		content: [
 			{

package/src/edit/hashline/filesystem.ts

@@ -198,9 +198,33 @@ export class HashlineFilesystem extends Filesystem {
 		const finalContent = await serializeEditFileText(absolutePath, relativePath, content);
 
 		// Route through ACP bridge when available; skips internal artifacts.
-		if (await routeWriteThroughBridge(this.session, relativePath, absolutePath, finalContent, this.#signal)) {
+		// `finalContent` is storage-space (e.g. a notebook's full JSON); the
+		// bridge may also report content that diverges from it (e.g. the
+		// client reformatted on save). `WriteResult.text` must stay in
+		// view-space — the same space `readText` returns — so a follow-up
+		// `readText` sees exactly what this write reports.
+		const bridgeResult = await routeWriteThroughBridge(
+			this.session,
+			relativePath,
+			absolutePath,
+			finalContent,
+			this.#signal,
+		);
+		if (bridgeResult) {
 			this.#diagnosticsByPath.set(relativePath, undefined);
-			return { text: finalContent };
+			if (!bridgeResult.driftedFromRequest) {
+				// No client-side transform: the view we sent is what's on disk.
+				return { text: content };
+			}
+			// Drifted (e.g. format-on-save): re-derive the view from what
+			// actually landed on disk instead of assuming `content` still
+			// matches. Falls back to `content` if the drifted file can't be
+			// re-read as a valid view (e.g. a formatter broke notebook JSON).
+			try {
+				return { text: await readEditFileText(absolutePath, relativePath) };
+			} catch {
+				return { text: content };
+			}
 		}
 
 		const diagnostics = await this.#writethrough(
@@ -213,7 +237,7 @@ export class HashlineFilesystem extends Filesystem {
 		);
 		invalidateFsScanAfterWrite(absolutePath);
 		this.#diagnosticsByPath.set(relativePath, diagnostics);
-		return { text: finalContent };
+		return { text: content };
 	}
 
 	async exists(relativePath: string): Promise<boolean> {

package/src/edit/index.ts

@@ -399,14 +399,24 @@ export class EditTool implements AgentTool<TInput> {
 	readonly #editMode?: EditMode;
 	readonly #deferredDiagnostics: DeferredDiagnostics;
 
-	constructor(private readonly session: ToolSession) {
+	/**
+	 * `mode` pins the edit variant for this instance, for callers whose protocol
+	 * fixes the shape of an edit. The Cursor `pi_edit` frame carries
+	 * `old_text`/`new_text` pairs, which only `replace` accepts — under the
+	 * default `hashline` mode those args do not match the schema at all. Left
+	 * unset, the env/settings resolution applies as before.
+	 */
+	constructor(
+		private readonly session: ToolSession,
+		mode?: EditMode,
+	) {
 		const {
 			PI_EDIT_FUZZY: editFuzzy = "auto",
 			PI_EDIT_FUZZY_THRESHOLD: editFuzzyThreshold = "auto",
 			PI_EDIT_VARIANT: envEditVariant = "auto",
 		} = Bun.env;
 
-		this.#editMode = resolveConfiguredEditMode(envEditVariant);
+		this.#editMode = mode ?? resolveConfiguredEditMode(envEditVariant);
 		this.#allowFuzzy = resolveAllowFuzzy(session, editFuzzy);
 		this.#fuzzyThreshold = resolveFuzzyThreshold(session, editFuzzyThreshold);
 		const deduplicateDiagnostics =

package/src/edit/renderer.ts

@@ -140,7 +140,7 @@ interface HashlineInputEntry {
 	path: string;
 	op?: Operation;
 	rename?: string;
-	/** A SWAP/DEL/INS line-editing op precedes the file op — keeps a move framed. */
+	/** A SWAP/CUT/INS line-editing op precedes the file op — keeps a move framed. */
 	hasLineEdits?: boolean;
 }
 
@@ -568,9 +568,9 @@ function parseHashlineInputPreviewHeader(line: string): string | null {
 	return previewPath.length > 0 ? previewPath : null;
 }
 
-// Line-editing op headers (SWAP/DEL/INS family), distinct from the file-level
-// REM/MV ops. Body rows are always `+TEXT`, so this only matches real headers.
-const HL_LINE_OP_HEADER = /^(?:SWAP|DEL|INS)\b/;
+// Line-editing op headers (SWAP/CUT/INS family), distinct from file-level
+// REM/MV ops. Body rows are `+TEXT`, so this only matches real headers.
+const HL_LINE_OP_HEADER = /^(?:SWAP|CUT|INS)\b/;
 
 /**
  * Walk a (possibly mid-stream) hashline payload into per-section descriptors:

package/src/edit/streaming.ts

@@ -16,8 +16,10 @@
 import {
 	ABORT_MARKER,
 	BEGIN_PATCH_MARKER,
+	type Clipboard,
 	containsRecognizableHashlineOperations,
 	END_PATCH_MARKER,
+	forkClipboard,
 	type PatchSection as HashlineInputSection,
 	Patch as HashlinePatch,
 	type SnapshotStore,
@@ -50,6 +52,13 @@ export interface StreamingDiffContext {
 	 * not flicker in the preview.
 	 */
 	isStreaming?: boolean;
+	/**
+	 * Session-persistent clipboard register (`CUT`/`PASTE`). Previews
+	 * fork it per frame — never mutating it — so a `PASTE` of content cut in
+	 * an earlier edit call (or an earlier section of this patch) renders the
+	 * real rows.
+	 */
+	clipboard?: Clipboard;
 }
 
 /**
@@ -411,7 +420,7 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 			if (typeof edit?.diff !== "string") continue;
 			// `create` ops carry full file content in `diff` with no +/- markers;
 			// pass that content through whole.
-			const added = extractAddedLines(edit.diff, true);
+			const added = extractAddedLines(edit.diff, edit.op === "create");
 			digest = digest === undefined ? added : `${digest}\n${added}`;
 		}
 		return digest;
@@ -542,7 +551,9 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 			// to parse; suppress until the next chunk arrives. Once args are
 			// complete, surface the error so the model sees what went wrong.
 			if (ctx.isStreaming) return null;
-			const result = await computeHashlineDiff({ input }, ctx.cwd, ctx.snapshots);
+			const result = await computeHashlineDiff({ input }, ctx.cwd, ctx.snapshots, {
+				clipboard: forkClipboard(ctx.clipboard),
+			});
 			ctx.signal.throwIfAborted();
 			return [toPerFilePreview("", result)];
 		}
@@ -558,12 +569,16 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		const trailingProcessedIndex = sectionsToProcess.length - 1;
 
 		const previews: PerFileDiffPreview[] = [];
+		// Fork the session register per preview frame: sections feed each other
+		// in patch order, but a preview must never mutate the live register.
+		const clipboard = forkClipboard(ctx.clipboard);
 		for (let i = 0; i < sectionsToProcess.length; i++) {
 			ctx.signal.throwIfAborted();
 			const section = sectionsToProcess[i];
 			const result = await computeHashlineSectionDiff(section, ctx.cwd, ctx.snapshots, {
 				streaming: ctx.isStreaming,
 				skipHashValidation: ctx.isStreaming === true,
+				clipboard,
 			});
 			ctx.signal.throwIfAborted();
 			// Ignore parse/apply errors from the trailing (actively-typed)