@oh-my-pi/pi-coding-agent 14.6.6 → 14.7.1

package/src/discovery/builtin.ts

@@ -5,6 +5,7 @@
  */
 import * as path from "node:path";
 import { logger, parseFrontmatter, tryParseJson } from "@oh-my-pi/pi-utils";
+import { YAML } from "bun";
 import { registerProvider } from "../capability";
 import { type ContextFile, contextFileCapability } from "../capability/context-file";
 import { type Extension, type ExtensionManifest, extensionCapability } from "../capability/extension";
@@ -778,22 +779,46 @@ async function loadSettings(ctx: LoadContext): Promise<LoadResult<Settings>> {
 	const items: Settings[] = [];
 	const warnings: string[] = [];
 
+	const parseYamlSettings = (content: string, filePath: string): Record<string, unknown> | null => {
+		try {
+			const data = YAML.parse(content);
+			if (!data || typeof data !== "object" || Array.isArray(data)) return {};
+			return data as Record<string, unknown>;
+		} catch {
+			warnings.push(`Failed to parse ${filePath}`);
+			return null;
+		}
+	};
+
 	for (const { dir, level } of await getConfigDirs(ctx)) {
 		const settingsPath = path.join(dir, "settings.json");
-		const content = await readFile(settingsPath);
-		if (!content) continue;
-
-		const data = tryParseJson<Record<string, unknown>>(content);
-		if (!data) {
-			warnings.push(`Failed to parse ${settingsPath}`);
-			continue;
+		const settingsContent = await readFile(settingsPath);
+		if (settingsContent) {
+			const data = tryParseJson<Record<string, unknown>>(settingsContent);
+			if (data) {
+				items.push({
+					path: settingsPath,
+					data,
+					level,
+					_source: createSourceMeta(PROVIDER_ID, settingsPath, level),
+				});
+			} else {
+				warnings.push(`Failed to parse ${settingsPath}`);
+			}
 		}
 
+		const configPath = path.join(dir, "config.yml");
+		const configContent = await readFile(configPath);
+		if (!configContent) continue;
+
+		const data = parseYamlSettings(configContent, configPath);
+		if (!data) continue;
+
 		items.push({
-			path: settingsPath,
+			path: configPath,
 			data,
 			level,
-			_source: createSourceMeta(PROVIDER_ID, settingsPath, level),
+			_source: createSourceMeta(PROVIDER_ID, configPath, level),
 		});
 	}
 

package/src/edit/line-hash.ts

@@ -783,18 +783,48 @@ export const HL_BODY_SEP = "|";
 export const HL_BODY_SEP_RE_RAW = regexEscape(HL_BODY_SEP);
 
 const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
+const RE_STRUCTURAL_STRIP = /[\s{}]/g;
+
+/**
+ * Bigram returned for lines that contain only whitespace and `{`/`}`.
+ * Picks the English ordinal suffix for the line number (`1` → `st`,
+ * `2` → `nd`, `3` → `rd`, `11`/`12`/`13` → `th`, else `th`) so the
+ * line digits + bigram BPE-merge into a single ordinal token (`1st`, `42nd`,
+ * `100th`, …). Brace-only lines therefore cost one token for the whole
+ * `LINE+ID` anchor instead of two.
+ */
+function structuralBigram(line: number): string {
+	const mod100 = line % 100;
+	if (mod100 >= 11 && mod100 <= 13) return "th";
+	switch (line % 10) {
+		case 1:
+			return "st";
+		case 2:
+			return "nd";
+		case 3:
+			return "rd";
+		default:
+			return "th";
+	}
+}
 
 /**
  * Compute a 2-character hash of a single line via xxHash32 mod 647 over
- * {@link HL_BIGRAMS}. Lines with no letter or digit (e.g. bare `}`,
- * bare `{`) mix the line number into the seed so adjacent identical
- * brace-only lines get distinct hashes; lines with significant content stay
- * line-number-independent so a line is identifiable across small shifts.
+ * {@link HL_BIGRAMS}. Lines that contain only whitespace and `{`/`}` collapse
+ * to an ordinal-suffix bigram (see {@link structuralBigram}) so brace-only
+ * structure shares one merged ordinal token (`1st`, `42nd`, `100th`, …).
+ * Other lines with no letter or digit mix the line number into the seed so
+ * adjacent identical punctuation-only lines get distinct hashes; lines with
+ * significant content stay line-number-independent so a line is identifiable
+ * across small shifts.
  *
  * The line input should not include a trailing newline.
  */
 export function computeLineHash(idx: number, line: string): string {
 	line = line.replace(/\r/g, "").trimEnd();
+	if (line.replace(RE_STRUCTURAL_STRIP, "").length === 0) {
+		return structuralBigram(idx);
+	}
 	const seed = RE_SIGNIFICANT.test(line) ? 0 : idx;
 	return HL_BIGRAMS[Bun.hash.xxHash32(line, seed) % HL_BIGRAMS_COUNT];
 }

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");
@@ -978,6 +981,110 @@ function countMatchingSuffixBlock(fileLines: string[], endLine: number, replacem
 	return 0;
 }
 
+// Single-line duplicate absorption is limited to structural closing delimiters.
+// General one-line context is too easy to delete incorrectly, but duplicated
+// `};` / `)` / `]` boundaries usually indicate a replacement range stopped one
+// line early and would otherwise produce a syntax error.
+const STRUCTURAL_CLOSING_BOUNDARY_RE = /^\s*[\])}]+[;,]?\s*$/;
+
+function isStructuralClosingBoundaryLine(line: string): boolean {
+	return STRUCTURAL_CLOSING_BOUNDARY_RE.test(line);
+}
+
+interface DelimiterBalance {
+	paren: number;
+	bracket: number;
+	brace: number;
+}
+
+const ZERO_DELIMITER_BALANCE: DelimiterBalance = { paren: 0, bracket: 0, brace: 0 };
+
+/**
+ * Naive bracket counter — does NOT skip string/template/comment contents. The
+ * single-line structural absorb relies on this being safe-by-asymmetry: the
+ * candidate boundary line is constrained by `STRUCTURAL_CLOSING_BOUNDARY_RE`
+ * to be pure delimiters, so noise in deleted lines or non-boundary kept payload
+ * tends to push `expected !== kept` and biases the heuristic toward NOT
+ * absorbing (the safe direction). If we ever extend this to opening boundaries
+ * or non-structural single lines, swap this for a real tokenizer.
+ */
+function computeDelimiterBalance(lines: string[]): DelimiterBalance {
+	const balance: DelimiterBalance = { paren: 0, bracket: 0, brace: 0 };
+	for (const line of lines) {
+		for (const char of line) {
+			switch (char) {
+				case "(":
+					balance.paren++;
+					break;
+				case ")":
+					balance.paren--;
+					break;
+				case "[":
+					balance.bracket++;
+					break;
+				case "]":
+					balance.bracket--;
+					break;
+				case "{":
+					balance.brace++;
+					break;
+				case "}":
+					balance.brace--;
+					break;
+			}
+		}
+	}
+	return balance;
+}
+
+function delimiterBalancesEqual(a: DelimiterBalance, b: DelimiterBalance): boolean {
+	return a.paren === b.paren && a.bracket === b.bracket && a.brace === b.brace;
+}
+
+/**
+ * Decides whether the structural-boundary candidate should be dropped: the
+ * `keptPayload` (full payload with the boundary line removed) must restore the
+ * caller's `expectedBalance`, while the `fullPayload` (boundary line still
+ * present) must NOT. For replacements `expectedBalance` is the deleted
+ * region's net delimiter balance; for pure inserts it is zero.
+ */
+function shouldDropSingleStructuralBoundary(
+	fullPayload: string[],
+	keptPayload: string[],
+	expectedBalance: DelimiterBalance,
+): boolean {
+	return (
+		delimiterBalancesEqual(computeDelimiterBalance(keptPayload), expectedBalance) &&
+		!delimiterBalancesEqual(computeDelimiterBalance(fullPayload), expectedBalance)
+	);
+}
+
+function countMatchingSingleStructuralPrefixBoundary(
+	fileLines: string[],
+	startLine: number,
+	replacement: string[],
+	expectedBalance: DelimiterBalance,
+): number {
+	if (replacement.length === 0 || startLine <= 1) return 0;
+	const line = replacement[0];
+	if (!isStructuralClosingBoundaryLine(line)) return 0;
+	if (fileLines[startLine - 2] !== line) return 0;
+	return shouldDropSingleStructuralBoundary(replacement, replacement.slice(1), expectedBalance) ? 1 : 0;
+}
+
+function countMatchingSingleStructuralSuffixBoundary(
+	fileLines: string[],
+	endLine: number,
+	replacement: string[],
+	expectedBalance: DelimiterBalance,
+): number {
+	if (replacement.length === 0 || endLine >= fileLines.length) return 0;
+	const line = replacement[replacement.length - 1];
+	if (!isStructuralClosingBoundaryLine(line)) return 0;
+	if (fileLines[endLine] !== line) return 0;
+	return shouldDropSingleStructuralBoundary(replacement, replacement.slice(0, -1), expectedBalance) ? 1 : 0;
+}
+
 function hasExternalTargets(lines: Iterable<number>, externalTargetLines: Set<number>): boolean {
 	for (const line of lines) {
 		if (externalTargetLines.has(line)) return true;
@@ -1003,10 +1110,181 @@ 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. Generic context echo absorption requires a minimum run of 2, but a
+ * single structural closing delimiter is absorbed because duplicated `}` /
+ * `});`-style boundaries almost always mean the insert included adjacent
+ * context.
+ */
+function tryAbsorbPureInsertGroup(
+	group: HashlinePureInsertGroup,
+	fileLines: string[],
+	allowGenericBoundaryAbsorb: boolean,
+): PureInsertAbsorbResult {
+	const empty: PureInsertAbsorbResult = { keptPayload: group.payload, absorbedLeading: 0, absorbedTrailing: 0 };
+	if (group.payload.length === 0) return empty;
+
+	const { aboveEndIdx, belowStartIdx } = pureInsertNeighborhood(group.cursor, fileLines);
+
+	// Leading: payload[0..k-1] vs fileLines[aboveEndIdx-k+1 .. aboveEndIdx].
+	let absorbedLeading = 0;
+	if (allowGenericBoundaryAbsorb) {
+		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;
+			}
+		}
+	}
+	if (
+		absorbedLeading === 0 &&
+		group.payload.length > 0 &&
+		aboveEndIdx >= 0 &&
+		isStructuralClosingBoundaryLine(group.payload[0]) &&
+		group.payload[0] === fileLines[aboveEndIdx] &&
+		shouldDropSingleStructuralBoundary(group.payload, group.payload.slice(1), ZERO_DELIMITER_BALANCE)
+	) {
+		absorbedLeading = 1;
+	}
+
+	// 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 remainingPayload = group.payload.slice(absorbedLeading);
+	const remaining = remainingPayload.length;
+	if (allowGenericBoundaryAbsorb) {
+		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 (
+		absorbedTrailing === 0 &&
+		remaining > 0 &&
+		belowStartIdx < fileLines.length &&
+		isStructuralClosingBoundaryLine(remainingPayload[remainingPayload.length - 1]) &&
+		remainingPayload[remainingPayload.length - 1] === fileLines[belowStartIdx] &&
+		shouldDropSingleStructuralBoundary(remainingPayload, remainingPayload.slice(0, -1), ZERO_DELIMITER_BALANCE)
+	) {
+		absorbedTrailing = 1;
+	}
+
+	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 +1299,54 @@ function absorbReplacementBoundaryDuplicates(
 	for (let index = 0; index < edits.length; index++) {
 		const group = findReplacementGroup(edits, index);
 		if (!group) {
+			const pureInsert = findPureInsertGroup(edits, index);
+			if (pureInsert) {
+				const result = tryAbsorbPureInsertGroup(
+					pureInsert,
+					fileLines,
+					options.autoDropPureInsertDuplicates === true,
+				);
+				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;
+				}
+				for (let groupIndex = pureInsert.startIndex; groupIndex <= pureInsert.endIndex; groupIndex++) {
+					absorbed.push(edits[groupIndex]);
+				}
+				index = pureInsert.endIndex;
+				continue;
+			}
 			absorbed.push(edits[index]);
 			continue;
 		}
@@ -1028,8 +1354,15 @@ function absorbReplacementBoundaryDuplicates(
 		const startLine = group.deletes[0].anchor.line;
 		const endLine = group.deletes[group.deletes.length - 1].anchor.line;
 
-		const prefixCount = countMatchingPrefixBlock(fileLines, startLine, group.replacement);
-		const suffixCount = countMatchingSuffixBlock(fileLines, endLine, group.replacement);
+		const deletedBalance = computeDelimiterBalance(
+			group.deletes.map(deleteEdit => fileLines[deleteEdit.anchor.line - 1] ?? ""),
+		);
+		const prefixCount =
+			countMatchingPrefixBlock(fileLines, startLine, group.replacement) ||
+			countMatchingSingleStructuralPrefixBoundary(fileLines, startLine, group.replacement, deletedBalance);
+		const suffixCount =
+			countMatchingSuffixBlock(fileLines, endLine, group.replacement) ||
+			countMatchingSingleStructuralSuffixBoundary(fileLines, endLine, group.replacement, deletedBalance);
 		const prefixLines = contiguousRange(startLine - prefixCount, prefixCount);
 		const suffixLines = contiguousRange(endLine + 1, suffixCount);
 		const safePrefixCount = hasExternalTargets(prefixLines, allTargetLines) ? 0 : prefixCount;
@@ -1094,7 +1427,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 +1446,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 +1669,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 +1682,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 +1720,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 +1752,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 +1780,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 {

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). */