@oh-my-pi/pi-coding-agent 14.6.5 → 14.7.0

package/src/edit/modes/hashline.ts

@@ -103,6 +103,9 @@ export interface CompactHashlineDiffOptions {
 	/** Maximum entries kept on each side of an unchanged-context truncation (default: 2). */
 	maxUnchangedRun?: number;
 }
+export interface HashlineApplyOptions {
+	autoDropPureInsertDuplicates?: boolean;
+}
 
 export interface SplitHashlineOptions {
 	cwd?: string;
@@ -140,7 +143,7 @@ const HL_OUTPUT_PREFIX_SEPARATOR_RE = `[:${HL_BODY_SEP_RE_RAW}]`;
 const HL_PREFIX_RE = new RegExp(`^\\s*(?:>>>|>>)?\\s*(?:[+*]\\s*)?\\d+[a-z]{2}${HL_OUTPUT_PREFIX_SEPARATOR_RE}`);
 const HL_PREFIX_PLUS_RE = new RegExp(`^\\s*(?:>>>|>>)?\\s*\\+\\s*\\d+[a-z]{2}${HL_OUTPUT_PREFIX_SEPARATOR_RE}`);
 const DIFF_PLUS_RE = /^[+](?![+])/;
-const READ_TRUNCATION_NOTICE_RE = /^\[(?:Showing lines \d+-\d+ of \d+|\d+ more lines? in (?:file|\S+))\b.*\bsel=L?\d+/;
+const READ_TRUNCATION_NOTICE_RE = /^\[(?:Showing lines \d+-\d+ of \d+|\d+ more lines? in (?:file|\S+))\b.*\bUse :L?\d+/;
 
 const HL_HASH_HINT_RE = /^[a-z]{2}$/i;
 const HL_ANCHOR_EXAMPLES = describeAnchorExamples("160");
@@ -1003,10 +1006,150 @@ function deleteEditForAutoAbsorbedLine(
 	};
 }
 
+interface HashlinePureInsertGroup {
+	startIndex: number;
+	endIndex: number;
+	sourceLineNum: number;
+	cursor: HashlineCursor;
+	payload: string[];
+}
+
+function cursorMatches(a: HashlineCursor, b: HashlineCursor): boolean {
+	if (a.kind !== b.kind) return false;
+	if (a.kind === "bof" || a.kind === "eof") return true;
+	const aAnchor = (a as { anchor: Anchor }).anchor;
+	const bAnchor = (b as { anchor: Anchor }).anchor;
+	return aAnchor.line === bAnchor.line && aAnchor.hash === bAnchor.hash;
+}
+
+/**
+ * Collects a run of consecutive `insert` edits that all share the same
+ * `lineNum` and `cursor`, IFF that run is not immediately followed by a
+ * `delete` at the same `lineNum` (which would make it a replacement group
+ * instead). Returns the contiguous payload so we can check it for boundary
+ * duplicates against the file.
+ */
+function findPureInsertGroup(edits: HashlineEdit[], startIndex: number): HashlinePureInsertGroup | undefined {
+	const first = edits[startIndex];
+	if (first?.kind !== "insert") return undefined;
+
+	const sourceLineNum = first.lineNum;
+	const cursor = first.cursor;
+	const payload: string[] = [];
+	let index = startIndex;
+	while (index < edits.length) {
+		const edit = edits[index];
+		if (edit.kind !== "insert" || edit.lineNum !== sourceLineNum) break;
+		if (!cursorMatches(edit.cursor, cursor)) break;
+		payload.push(edit.text);
+		index++;
+	}
+
+	// If the run is followed by a delete at the same source lineNum, this is a
+	// replacement group (handled by absorbReplacement…). Decline.
+	if (index < edits.length && edits[index].kind === "delete" && edits[index].lineNum === sourceLineNum) {
+		return undefined;
+	}
+
+	return { startIndex, endIndex: index - 1, sourceLineNum, cursor, payload };
+}
+
+/**
+ * For a pure-insert group, locate the file region adjacent to the insertion
+ * point. Returns 0-indexed bounds:
+ *   - `aboveEndIdx`: index of the last file line strictly above the insertion
+ *     point (-1 if none).
+ *   - `belowStartIdx`: index of the first file line strictly below the
+ *     insertion point (`fileLines.length` if none).
+ */
+function pureInsertNeighborhood(
+	cursor: HashlineCursor,
+	fileLines: string[],
+): { aboveEndIdx: number; belowStartIdx: number } {
+	if (cursor.kind === "bof") return { aboveEndIdx: -1, belowStartIdx: 0 };
+	if (cursor.kind === "eof") return { aboveEndIdx: fileLines.length - 1, belowStartIdx: fileLines.length };
+	if (cursor.kind === "before_anchor") {
+		return { aboveEndIdx: cursor.anchor.line - 2, belowStartIdx: cursor.anchor.line - 1 };
+	}
+	// after_anchor
+	return { aboveEndIdx: cursor.anchor.line - 1, belowStartIdx: cursor.anchor.line };
+}
+
+interface PureInsertAbsorbResult {
+	keptPayload: string[];
+	absorbedLeading: number;
+	absorbedTrailing: number;
+	leadingFileRange?: { start: number; end: number }; // 1-indexed inclusive
+	trailingFileRange?: { start: number; end: number }; // 1-indexed inclusive
+}
+
+/**
+ * Mirror of replacement-absorb's prefix/suffix block check, but for pure
+ * inserts: drop payload lines that exactly duplicate the file lines
+ * immediately above (leading) or immediately below (trailing) the insertion
+ * point. Requires a minimum run of 2 to avoid spurious single-line matches,
+ * matching the existing replacement-absorb threshold.
+ */
+function tryAbsorbPureInsertGroup(group: HashlinePureInsertGroup, fileLines: string[]): PureInsertAbsorbResult {
+	const empty: PureInsertAbsorbResult = { keptPayload: group.payload, absorbedLeading: 0, absorbedTrailing: 0 };
+	if (group.payload.length < 2) return empty;
+
+	const { aboveEndIdx, belowStartIdx } = pureInsertNeighborhood(group.cursor, fileLines);
+
+	// Leading: payload[0..k-1] vs fileLines[aboveEndIdx-k+1 .. aboveEndIdx].
+	let absorbedLeading = 0;
+	const maxLead = Math.min(group.payload.length, aboveEndIdx + 1);
+	for (let count = maxLead; count >= 2; count--) {
+		let ok = true;
+		for (let offset = 0; offset < count; offset++) {
+			if (group.payload[offset] !== fileLines[aboveEndIdx - count + 1 + offset]) {
+				ok = false;
+				break;
+			}
+		}
+		if (ok) {
+			absorbedLeading = count;
+			break;
+		}
+	}
+
+	// Trailing: payload[len-k..len-1] vs fileLines[belowStartIdx..belowStartIdx+k-1].
+	// Don't double-count payload lines already absorbed as leading.
+	let absorbedTrailing = 0;
+	const remaining = group.payload.length - absorbedLeading;
+	const maxTrail = Math.min(remaining, fileLines.length - belowStartIdx);
+	for (let count = maxTrail; count >= 2; count--) {
+		let ok = true;
+		for (let offset = 0; offset < count; offset++) {
+			if (group.payload[group.payload.length - count + offset] !== fileLines[belowStartIdx + offset]) {
+				ok = false;
+				break;
+			}
+		}
+		if (ok) {
+			absorbedTrailing = count;
+			break;
+		}
+	}
+
+	if (absorbedLeading === 0 && absorbedTrailing === 0) return empty;
+
+	return {
+		keptPayload: group.payload.slice(absorbedLeading, group.payload.length - absorbedTrailing),
+		absorbedLeading,
+		absorbedTrailing,
+		leadingFileRange:
+			absorbedLeading > 0 ? { start: aboveEndIdx - absorbedLeading + 2, end: aboveEndIdx + 1 } : undefined,
+		trailingFileRange:
+			absorbedTrailing > 0 ? { start: belowStartIdx + 1, end: belowStartIdx + absorbedTrailing } : undefined,
+	};
+}
+
 function absorbReplacementBoundaryDuplicates(
 	edits: HashlineEdit[],
 	fileLines: string[],
 	warnings: string[],
+	options: HashlineApplyOptions,
 ): HashlineEdit[] {
 	let nextSyntheticIndex = edits.length;
 	const absorbed: HashlineEdit[] = [];
@@ -1021,6 +1164,47 @@ function absorbReplacementBoundaryDuplicates(
 	for (let index = 0; index < edits.length; index++) {
 		const group = findReplacementGroup(edits, index);
 		if (!group) {
+			if (options.autoDropPureInsertDuplicates) {
+				const pureInsert = findPureInsertGroup(edits, index);
+				if (pureInsert) {
+					const result = tryAbsorbPureInsertGroup(pureInsert, fileLines);
+					if (result.absorbedLeading > 0 || result.absorbedTrailing > 0) {
+						if (result.leadingFileRange) {
+							const { start, end } = result.leadingFileRange;
+							const key = `pure-insert-leading:${start}..${end}`;
+							if (!emittedAbsorbKeys.has(key)) {
+								emittedAbsorbKeys.add(key);
+								warnings.push(
+									`Auto-dropped ${result.absorbedLeading} duplicate line(s) at the start of insert at line ${pureInsert.sourceLineNum} ` +
+										`(file lines ${start}..${end} already match the payload's leading lines).`,
+								);
+							}
+						}
+						if (result.trailingFileRange) {
+							const { start, end } = result.trailingFileRange;
+							const key = `pure-insert-trailing:${start}..${end}`;
+							if (!emittedAbsorbKeys.has(key)) {
+								emittedAbsorbKeys.add(key);
+								warnings.push(
+									`Auto-dropped ${result.absorbedTrailing} duplicate line(s) at the end of insert at line ${pureInsert.sourceLineNum} ` +
+										`(file lines ${start}..${end} already match the payload's trailing lines).`,
+								);
+							}
+						}
+						for (const text of result.keptPayload) {
+							absorbed.push({
+								kind: "insert",
+								cursor: cloneCursor(pureInsert.cursor),
+								text,
+								lineNum: pureInsert.sourceLineNum,
+								index: nextSyntheticIndex++,
+							});
+						}
+						index = pureInsert.endIndex;
+						continue;
+					}
+				}
+			}
 			absorbed.push(edits[index]);
 			continue;
 		}
@@ -1094,7 +1278,11 @@ function bucketAnchorEditsByLine(edits: IndexedEdit[]): Map<number, IndexedEdit[
 	return byLine;
 }
 
-export function applyHashlineEdits(text: string, edits: HashlineEdit[]): HashlineApplyResult {
+export function applyHashlineEdits(
+	text: string,
+	edits: HashlineEdit[],
+	options: HashlineApplyOptions = {},
+): HashlineApplyResult {
 	if (edits.length === 0) return { lines: text, firstChangedLine: undefined };
 
 	const fileLines = text.split("\n");
@@ -1109,7 +1297,7 @@ export function applyHashlineEdits(text: string, edits: HashlineEdit[]): Hashlin
 	const mismatches = validateHashlineAnchors(edits, fileLines, warnings);
 	if (mismatches.length > 0) throw new HashlineMismatchError(mismatches, fileLines);
 
-	const normalizedEdits = absorbReplacementBoundaryDuplicates(edits, fileLines, warnings);
+	const normalizedEdits = absorbReplacementBoundaryDuplicates(edits, fileLines, warnings, options);
 
 	// Normalize after_anchor inserts to before_anchor of the next line, or EOF
 	// when the anchor is the final line. This keeps the bucketing logic below
@@ -1332,6 +1520,7 @@ async function readHashlineFileText(file: { text(): Promise<string> }, pathText:
 export async function computeHashlineDiff(
 	input: { input: string; path?: string },
 	cwd: string,
+	options: HashlineApplyOptions = {},
 ): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
 	try {
 		const sections = splitHashlineInputs(input.input, { cwd, path: input.path });
@@ -1344,7 +1533,7 @@ export async function computeHashlineDiff(
 		const rawContent = await readHashlineFileText(Bun.file(absolutePath), section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		const result = applyHashlineEdits(normalized, parseHashline(section.diff));
+		const result = applyHashlineEdits(normalized, parseHashline(section.diff), options);
 		if (normalized === result.lines) return { error: `No changes would be made to ${section.path}.` };
 		return generateDiffString(normalized, result.lines);
 	} catch (err) {
@@ -1382,6 +1571,12 @@ function formatNoChangeDiagnostic(pathText: string): string {
 	return `Edits to ${pathText} resulted in no changes being made.`;
 }
 
+function getHashlineApplyOptions(session: ToolSession): HashlineApplyOptions {
+	return {
+		autoDropPureInsertDuplicates: session.settings.get("edit.hashlineAutoDropPureInsertDuplicates"),
+	};
+}
+
 function getTextContent(result: AgentToolResult<EditToolDetails>): string {
 	return result.content.map(part => (part.type === "text" ? part.text : "")).join("\n");
 }
@@ -1408,7 +1603,7 @@ async function preflightHashlineSection(options: ExecuteHashlineSingleOptions &
 
 	const { text } = stripBom(source.rawContent);
 	const normalized = normalizeToLF(text);
-	const result = applyHashlineEdits(normalized, edits);
+	const result = applyHashlineEdits(normalized, edits, getHashlineApplyOptions(session));
 	if (normalized === result.lines) throw new Error(formatNoChangeDiagnostic(sectionPath));
 }
 
@@ -1436,7 +1631,7 @@ async function executeHashlineSection(
 	const { bom, text } = stripBom(source.rawContent);
 	const originalEnding = detectLineEnding(text);
 	const originalNormalized = normalizeToLF(text);
-	const result = applyHashlineEdits(originalNormalized, edits);
+	const result = applyHashlineEdits(originalNormalized, edits, getHashlineApplyOptions(session));
 
 	if (originalNormalized === result.lines) {
 		return {
@@ -1486,7 +1681,9 @@ async function executeHashlineSection(
 export async function executeHashlineSingle(
 	options: ExecuteHashlineSingleOptions,
 ): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>> {
-	const sections = splitHashlineInputs(options.input, { cwd: options.session.cwd, path: options.path });
+	const sections = mergeSamePathSections(
+		splitHashlineInputs(options.input, { cwd: options.session.cwd, path: options.path }),
+	);
 
 	// Fast path: a single section needs no preflight pass.
 	if (sections.length === 1) return executeHashlineSection({ ...options, ...sections[0] });
@@ -1518,3 +1715,20 @@ export async function executeHashlineSingle(
 		},
 	};
 }
+
+/**
+ * Collapse consecutive or interleaved sections targeting the same path into a
+ * single section with concatenated diffs. Anchors authored against the same
+ * file snapshot must be applied as one batch; otherwise the first sub-edit
+ * shifts line numbers out from under the second's anchors and rebase fails.
+ * Path order is preserved by first occurrence.
+ */
+function mergeSamePathSections(sections: HashlineInputSection[]): HashlineInputSection[] {
+	const byPath = new Map<string, string[]>();
+	for (const section of sections) {
+		const existing = byPath.get(section.path);
+		if (existing) existing.push(section.diff);
+		else byPath.set(section.path, [section.diff]);
+	}
+	return Array.from(byPath, ([path, diffs]) => ({ path, diff: diffs.join("\n") }));
+}

package/src/edit/streaming.ts

@@ -32,6 +32,7 @@ export interface StreamingDiffContext {
 	signal: AbortSignal;
 	fuzzyThreshold?: number;
 	allowFuzzy?: boolean;
+	hashlineAutoDropPureInsertDuplicates?: boolean;
 }
 
 export interface EditStreamingStrategy<Args = unknown> {
@@ -222,7 +223,9 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	async computeDiffPreview(args, ctx) {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
 		ctx.signal.throwIfAborted();
-		const result = await computeHashlineDiff({ input: args.input, path: args.path }, ctx.cwd);
+		const result = await computeHashlineDiff({ input: args.input, path: args.path }, ctx.cwd, {
+			autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
+		});
 		ctx.signal.throwIfAborted();
 		if ("error" in result && !args.path) return [{ path: "", error: result.error }];
 		return [toPerFilePreview(args.path ?? "", result)];

package/src/export/html/index.ts

@@ -124,7 +124,7 @@ export async function exportSessionToHtml(
 		header: sm.getHeader(),
 		entries: sm.getEntries(),
 		leafId: sm.getLeafId(),
-		systemPrompt: state?.systemPrompt,
+		systemPrompt: state?.systemPrompt.join("\n\n"),
 		tools: state?.tools?.map(t => ({ name: t.name, description: t.description })),
 	};
 

package/src/extensibility/extensions/runner.ts

@@ -55,7 +55,7 @@ import type {
 /** Combined result from all before_agent_start handlers */
 interface BeforeAgentStartCombinedResult {
 	messages?: NonNullable<BeforeAgentStartEventResult["message"]>[];
-	systemPrompt?: string;
+	systemPrompt?: string[];
 }
 
 export type ExtensionErrorListener = (error: ExtensionError) => void;
@@ -168,7 +168,7 @@ export class ExtensionRunner {
 	#hasPendingMessagesFn: () => boolean = () => false;
 	#getContextUsageFn: () => ContextUsage | undefined = () => undefined;
 	#compactFn: (instructionsOrOptions?: string | CompactOptions) => Promise<void> = async () => {};
-	#getSystemPromptFn: () => string = () => "";
+	#getSystemPromptFn: () => string[] = () => [];
 	#newSessionHandler: NewSessionHandler = async () => ({ cancelled: false });
 	#branchHandler: BranchHandler = async () => ({ cancelled: false });
 	#navigateTreeHandler: NavigateTreeHandler = async () => ({ cancelled: false });
@@ -795,7 +795,7 @@ export class ExtensionRunner {
 	async emitBeforeAgentStart(
 		prompt: string,
 		images: ImageContent[] | undefined,
-		systemPrompt: string,
+		systemPrompt: string[],
 	): Promise<BeforeAgentStartCombinedResult | undefined> {
 		const ctx = this.createContext();
 		const messages: NonNullable<BeforeAgentStartEventResult["message"]>[] = [];

package/src/extensibility/extensions/types.ts

@@ -240,7 +240,7 @@ export interface ExtensionContext {
 	/** Gracefully shutdown and exit. */
 	shutdown(): void;
 	/** Get the current effective system prompt. */
-	getSystemPrompt(): string;
+	getSystemPrompt(): string[];
 	/** @deprecated Use hasPendingMessages() instead */
 	hasQueuedMessages(): boolean;
 }
@@ -492,7 +492,7 @@ export interface BeforeAgentStartEvent {
 	type: "before_agent_start";
 	prompt: string;
 	images?: ImageContent[];
-	systemPrompt: string;
+	systemPrompt: string[];
 }
 
 /** Fired when an agent loop starts */
@@ -876,7 +876,7 @@ export interface ToolResultEventResult {
 export interface BeforeAgentStartEventResult {
 	message?: Pick<CustomMessage, "customType" | "content" | "display" | "details" | "attribution">;
 	/** Replace the system prompt for this turn. If multiple extensions return this, they are chained. */
-	systemPrompt?: string;
+	systemPrompt?: string[];
 }
 
 export interface SessionBeforeSwitchResult {
@@ -1318,7 +1318,7 @@ export interface ExtensionContextActions {
 	shutdown: () => void;
 	getContextUsage: () => ContextUsage | undefined;
 	compact: (instructionsOrOptions?: string | CompactOptions) => Promise<void>;
-	getSystemPrompt: () => string;
+	getSystemPrompt: () => string[];
 }
 
 /** Actions for ExtensionCommandContext (ctx.* in command handlers). */

package/src/main.ts

@@ -540,11 +540,11 @@ async function buildSessionOptions(
 
 	// System prompt
 	if (resolvedSystemPrompt && resolvedAppendPrompt) {
-		options.systemPrompt = `${resolvedSystemPrompt}\n\n${resolvedAppendPrompt}`;
+		options.systemPrompt = defaultPrompt => [resolvedSystemPrompt, resolvedAppendPrompt, ...defaultPrompt.slice(1)];
 	} else if (resolvedSystemPrompt) {
-		options.systemPrompt = resolvedSystemPrompt;
+		options.systemPrompt = defaultPrompt => [resolvedSystemPrompt, ...defaultPrompt.slice(1)];
 	} else if (resolvedAppendPrompt) {
-		options.systemPrompt = defaultPrompt => `${defaultPrompt}\n\n${resolvedAppendPrompt}`;
+		options.systemPrompt = defaultPrompt => [...defaultPrompt, resolvedAppendPrompt];
 	}
 
 	// Tools

package/src/memories/index.ts

@@ -602,7 +602,7 @@ async function runStage1Job(options: {
 		const response = await completeSimple(
 			model,
 			{
-				systemPrompt: stageOneSystemTemplate,
+				systemPrompt: [stageOneSystemTemplate],
 				messages: [{ role: "user", content: [{ type: "text", text: inputPrompt }], timestamp: Date.now() }],
 			},
 			{

package/src/modes/components/agent-dashboard.ts

@@ -635,7 +635,7 @@ export class AgentDashboard extends Container {
 			modelRegistry,
 			settings,
 			model: selectedModel,
-			systemPrompt,
+			systemPrompt: [systemPrompt],
 			hasUI: false,
 			enableLsp: false,
 			enableMCP: false,

package/src/modes/components/custom-editor.ts

@@ -197,12 +197,11 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		// Intercept configured exit shortcut (only when editor is empty)
+		// Intercept configured exit shortcut. Always consume the shortcut so it
+		// never reaches the parent handler; firing onExit is the controller's
+		// chance to snapshot the current text as a draft before shutting down.
 		if (this.#matchesAction(data, "app.exit")) {
-			if (this.getText().length === 0 && this.onExit) {
-				this.onExit();
-			}
-			// Always consume exit shortcut (don't pass to parent)
+			this.onExit?.();
 			return;
 		}
 

package/src/modes/components/read-tool-group.ts

@@ -8,6 +8,7 @@ import type { ToolExecutionHandle } from "./tool-execution";
 type ReadRenderArgs = {
 	path?: string;
 	file_path?: string;
+	// Legacy field from the old schema; tolerated for rebuilt transcripts.
 	sel?: string;
 };
 
@@ -37,7 +38,6 @@ function getSuffixResolution(details: ReadToolResultDetails | undefined): ReadTo
 type ReadEntry = {
 	toolCallId: string;
 	path: string;
-	sel?: string;
 	status: "pending" | "success" | "warning" | "error";
 	correctedFrom?: string;
 	contentText?: string;
@@ -62,15 +62,14 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 
 	updateArgs(args: ReadRenderArgs, toolCallId?: string): void {
 		if (!toolCallId) return;
-		const rawPath = args.file_path || args.path || "";
+		const basePath = args.file_path || args.path || "";
+		const rawPath = args.sel ? `${basePath}:${args.sel}` : basePath;
 		const entry: ReadEntry = this.#entries.get(toolCallId) ?? {
 			toolCallId,
 			path: rawPath,
-			sel: args.sel,
 			status: "pending",
 		};
 		entry.path = rawPath;
-		entry.sel = args.sel;
 		this.#entries.set(toolCallId, entry);
 		this.#updateDisplay();
 	}
@@ -172,9 +171,8 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 	#addContentPreview(entry: ReadEntry): void {
 		const lang = getLanguageFromPath(entry.path);
 		const filePath = shortenPath(entry.path);
-		const selectionSuffix = entry.sel ? `:${entry.sel}` : "";
 		const correctionSuffix = entry.correctedFrom ? ` (corrected from ${shortenPath(entry.correctedFrom)})` : "";
-		const title = filePath ? `Read ${filePath}${selectionSuffix}${correctionSuffix}` : `Read${selectionSuffix}`;
+		const title = filePath ? `Read ${filePath}${correctionSuffix}` : "Read";
 		let cachedWidth: number | undefined;
 		let cachedLines: string[] | undefined;
 		const expanded = this.#expanded;
@@ -211,9 +209,6 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 	#formatPath(entry: ReadEntry): string {
 		const filePath = shortenPath(entry.path);
 		let pathDisplay = filePath ? theme.fg("accent", filePath) : theme.fg("toolOutput", "…");
-		if (entry.sel) {
-			pathDisplay += theme.fg("warning", `:${entry.sel}`);
-		}
 		if (entry.correctedFrom) {
 			pathDisplay += theme.fg("dim", ` (corrected from ${shortenPath(entry.correctedFrom)})`);
 		}

package/src/modes/components/tool-execution.ts

@@ -67,6 +67,7 @@ export interface ToolExecutionOptions {
 	showImages?: boolean; // default: true (only used if terminal supports images)
 	editFuzzyThreshold?: number;
 	editAllowFuzzy?: boolean;
+	hashlineAutoDropPureInsertDuplicates?: boolean;
 }
 
 export interface ToolExecutionHandle {
@@ -100,6 +101,7 @@ export class ToolExecutionComponent extends Container {
 	#showImages: boolean;
 	#editFuzzyThreshold: number | undefined;
 	#editAllowFuzzy: boolean | undefined;
+	#hashlineAutoDropPureInsertDuplicates: boolean | undefined;
 	#isPartial = true;
 	#tool?: AgentTool;
 	#ui: TUI;
@@ -147,6 +149,7 @@ export class ToolExecutionComponent extends Container {
 		this.#showImages = options.showImages ?? true;
 		this.#editFuzzyThreshold = options.editFuzzyThreshold;
 		this.#editAllowFuzzy = options.editAllowFuzzy;
+		this.#hashlineAutoDropPureInsertDuplicates = options.hashlineAutoDropPureInsertDuplicates;
 		this.#tool = tool;
 		this.#ui = ui;
 		this.#cwd = cwd;
@@ -248,6 +251,7 @@ export class ToolExecutionComponent extends Container {
 				signal: controller.signal,
 				fuzzyThreshold: this.#editFuzzyThreshold,
 				allowFuzzy: this.#editAllowFuzzy,
+				hashlineAutoDropPureInsertDuplicates: this.#hashlineAutoDropPureInsertDuplicates,
 			});
 			if (controller.signal.aborted) return;
 			if (previews) {

package/src/modes/controllers/event-controller.ts

@@ -280,6 +280,7 @@ export class EventController {
 							showImages: settings.get("terminal.showImages"),
 							editFuzzyThreshold: settings.get("edit.fuzzyThreshold"),
 							editAllowFuzzy: settings.get("edit.fuzzyMatch"),
+							hashlineAutoDropPureInsertDuplicates: settings.get("edit.hashlineAutoDropPureInsertDuplicates"),
 						},
 						tool,
 						this.ctx.ui,
@@ -383,6 +384,7 @@ export class EventController {
 					showImages: settings.get("terminal.showImages"),
 					editFuzzyThreshold: settings.get("edit.fuzzyThreshold"),
 					editAllowFuzzy: settings.get("edit.fuzzyMatch"),
+					hashlineAutoDropPureInsertDuplicates: settings.get("edit.hashlineAutoDropPureInsertDuplicates"),
 				},
 				tool,
 				this.ctx.ui,

package/src/modes/controllers/input-controller.ts

@@ -403,7 +403,9 @@ export class InputController {
 	}
 
 	handleCtrlD(): void {
-		// Only called when editor is empty (enforced by CustomEditor)
+		// Editor text (if any) is snapshotted at the start of shutdown() and
+		// persisted as a draft for the next resume. Empty text is also fine —
+		// shutdown clears any stale sidecar in that case.
 		void this.ctx.shutdown();
 	}
 

package/src/modes/interactive-mode.ts

@@ -445,6 +445,20 @@ export class InteractiveMode implements InteractiveModeContext {
 		// Restore mode from session (e.g. plan mode on resume)
 		await this.#restoreModeFromSession();
 
+		// Restore unsent editor draft from previous session shutdown (Ctrl+D).
+		// One-shot: consumeDraft removes the sidecar after read so the next
+		// resume does not re-restore the same text.
+		try {
+			const draft = await this.sessionManager.consumeDraft();
+			if (draft && !this.editor.getText()) {
+				this.editor.setText(draft);
+				this.updateEditorBorderColor();
+				this.ui.requestRender();
+			}
+		} catch (err) {
+			logger.warn("Failed to restore session draft", { error: String(err) });
+		}
+
 		// Subscribe to agent events
 		this.#subscribeToAgent();
 
@@ -1189,8 +1203,18 @@ export class InteractiveMode implements InteractiveModeContext {
 		if (this.#isShuttingDown) return;
 		this.#isShuttingDown = true;
 
+		// Snapshot the editor before any teardown empties it. Persisting the draft
+		// here covers Ctrl+D shutdown with non-empty text; for /exit the editor is
+		// already cleared so saveDraft("") just removes any stale sidecar.
+		const draftText = this.editor.getText();
+
 		// Flush pending session writes before shutdown
 		await this.sessionManager.flush();
+		try {
+			await this.sessionManager.saveDraft(draftText);
+		} catch (err) {
+			logger.warn("Failed to save session draft", { error: String(err) });
+		}
 		this.#btwController.dispose();
 
 		// Emit shutdown event to hooks

package/src/modes/rpc/rpc-types.ts

@@ -89,7 +89,7 @@ export interface RpcSessionState {
 	queuedMessageCount: number;
 	todoPhases: TodoPhase[];
 	/** For session dump / export (plain-text parity with /dump). */
-	systemPrompt?: string;
+	systemPrompt?: string[];
 	dumpTools?: Array<{ name: string; description: string; parameters: unknown }>;
 	/** Current context window usage. Null tokens/percent when unknown (e.g. right after compaction). */
 	contextUsage?: ContextUsage;