@oh-my-pi/pi-coding-agent 14.6.1 → 14.6.3

package/src/config/settings.ts

@@ -568,6 +568,48 @@ export class Settings {
 			}
 		}
 
+		// Map legacy `memories.enabled` boolean to the explicit `memory.backend`
+		// enum if the latter hasn't been set yet. Idempotent: subsequent
+		// migrations are no-ops once memory.backend is materialised.
+		const memoryBackendObj = raw.memory as Record<string, unknown> | undefined;
+		const memoryBackendSet = memoryBackendObj && typeof memoryBackendObj.backend === "string";
+		const memoriesObj = raw.memories as Record<string, unknown> | undefined;
+		if (!memoryBackendSet && memoriesObj && typeof memoriesObj.enabled === "boolean") {
+			const next = memoriesObj.enabled ? "local" : "off";
+			const memoryRoot = (memoryBackendObj ?? {}) as Record<string, unknown>;
+			memoryRoot.backend = next;
+			raw.memory = memoryRoot;
+		}
+
+		// hindsight: dynamicBankId/agentName -> scoping enum + bankId
+		// - dynamicBankId=true  → scoping="per-project" (closest semantic match;
+		//   the legacy `agent::project::channel::user` tuple was per-project in
+		//   practice — the channel/user env vars were rarely set).
+		// - hindsight.agentName was only used as the agent slot in the legacy
+		//   dynamic tuple; if the user customised it we surface it as the new
+		//   bankId base when no explicit bankId is set.
+		const hindsightObj = raw.hindsight as Record<string, unknown> | undefined;
+		if (hindsightObj) {
+			if ("dynamicBankId" in hindsightObj) {
+				if (!("scoping" in hindsightObj) && hindsightObj.dynamicBankId === true) {
+					hindsightObj.scoping = "per-project";
+				}
+				delete hindsightObj.dynamicBankId;
+			}
+			if ("agentName" in hindsightObj) {
+				const agentName = hindsightObj.agentName;
+				if (
+					!("bankId" in hindsightObj) &&
+					typeof agentName === "string" &&
+					agentName.trim().length > 0 &&
+					agentName !== "omp"
+				) {
+					hindsightObj.bankId = agentName;
+				}
+				delete hindsightObj.agentName;
+			}
+		}
+
 		return raw;
 	}
 
@@ -713,6 +755,10 @@ const SETTING_HOOKS: Partial<Record<SettingPath, SettingHook<any>>> = {
 let globalInstance: Settings | null = null;
 let globalInstancePromise: Promise<Settings> | null = null;
 
+export function isSettingsInitialized(): boolean {
+	return globalInstance !== null;
+}
+
 /**
  * Reset the global singleton for testing.
  * @internal

package/src/discovery/helpers.ts

@@ -3,7 +3,14 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
-import { CONFIG_DIR_NAME, getConfigDirName, getProjectDir, parseFrontmatter, tryParseJson } from "@oh-my-pi/pi-utils";
+import {
+	CONFIG_DIR_NAME,
+	getConfigDirName,
+	getPluginsDir,
+	getProjectDir,
+	parseFrontmatter,
+	tryParseJson,
+} from "@oh-my-pi/pi-utils";
 import type { ExtensionModule } from "../capability/extension-module";
 import { invalidate as invalidateFsCache, readDirEntries, readFile } from "../capability/fs";
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
@@ -804,8 +811,9 @@ export async function listClaudePluginRoots(
 
 	// ── OMP installed plugins registry ───────────────────────────────────────
 	// OMP registry is authoritative: its entries replace Claude's entries for the same plugin ID.
-	// Path derived from `home` (not os.homedir()) so test isolation works when home is overridden.
-	const ompRegistryPath = path.join(home, getConfigDirName(), "plugins", "installed_plugins.json");
+	// getPluginsDir() resolves to the same path the marketplace writer uses
+	// (XDG-aware via the dir resolver), so reads and writes always agree.
+	const ompRegistryPath = path.join(getPluginsDir(), "installed_plugins.json");
 	const ompContent = await readFile(ompRegistryPath);
 	if (ompContent) {
 		const ompRegistry = parseClaudePluginsRegistry(ompContent);
@@ -928,9 +936,8 @@ export function clearClaudePluginRootsCache(): void {
  * installing/uninstalling/enabling/disabling plugins.
  */
 export function clearPluginRootsAndCaches(extraPaths?: readonly string[]): void {
-	const home = os.homedir();
-	invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
-	invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
+	invalidateFsCache(path.join(os.homedir(), ".claude", "plugins", "installed_plugins.json"));
+	invalidateFsCache(path.join(getPluginsDir(), "installed_plugins.json"));
 	for (const p of extraPaths ?? []) invalidateFsCache(p);
 	clearClaudePluginRootsCache();
 }

package/src/edit/index.ts

@@ -16,7 +16,7 @@ import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
-import { resolveLarkLidPlaceholders } from "./line-hash";
+import { resolveHashlineGrammarPlaceholders } from "./line-hash";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import {
@@ -35,8 +35,8 @@ export * from "./apply-patch";
 export * from "./diff";
 export * from "./line-hash";
 
-// Resolve the `$HASHFMT$` placeholder in the hashline Lark grammar.
-const hashlineGrammar = resolveLarkLidPlaceholders(hashlineGrammarTemplate);
+// Resolve the `$HFMT$` and `$HSEP$` placeholders in the hashline Lark grammar.
+const hashlineGrammar = resolveHashlineGrammarPlaceholders(hashlineGrammarTemplate);
 
 export * from "./modes/apply-patch";
 export * from "./modes/hashline";

package/src/edit/line-hash.ts

@@ -15,7 +15,7 @@
  * Order is stable forever — changing it would invalidate every saved
  * `LINE+ID` reference in transcripts and prompts.
  */
-export const HASHLINE_BIGRAMS = [
+export const HL_BIGRAMS = [
 	"aa",
 	"ab",
 	"ac",
@@ -665,7 +665,7 @@ export const HASHLINE_BIGRAMS = [
 	"zz",
 ] as const;
 
-export const HASHLINE_BIGRAMS_COUNT = HASHLINE_BIGRAMS.length;
+export const HL_BIGRAMS_COUNT = HL_BIGRAMS.length;
 
 /**
  * Decoration prefix that may precede a `LINE+HASH` anchor in tool output:
@@ -675,7 +675,7 @@ export const HASHLINE_BIGRAMS_COUNT = HASHLINE_BIGRAMS.length;
  * regex stays liberal because anchor-ref parsers accept whatever the model
  * echoes back.
  */
-export const HASHLINE_ANCHOR_DECORATION_RE_SRC = `\\s*[>+\\-*]*\\s*`;
+export const HL_ANCHOR_DECORATION_RE_RAW = `\\s*[>+\\-*]*\\s*`;
 
 /**
  * Capture-group regex source for a decorated `LINE+HASH` anchor. Group 1
@@ -683,62 +683,110 @@ export const HASHLINE_ANCHOR_DECORATION_RE_SRC = `\\s*[>+\\-*]*\\s*`;
  * source is intentionally unanchored — anchoring with `^` (or composing into a
  * larger pattern) is the caller's responsibility.
  */
-export const HASHLINE_ANCHOR_RE_SRC = `${HASHLINE_ANCHOR_DECORATION_RE_SRC}(\\d+)([a-z]{2})`;
+export const HL_ANCHOR_RE_RAW = `${HL_ANCHOR_DECORATION_RE_RAW}(\\d+)([a-z]{2})`;
 
 /**
  * Bare `LINE+HASH` Lid (no decorations, no captures, no anchors). Use for
  * embedding inside larger patterns where the line+hash unit appears as a
  * literal (e.g. range bounds, alternation arms, op-line heuristics).
  */
-export const HASHLINE_LID_RE_SRC = `[1-9]\\d*[a-z]{2}`;
+export const HL_HASH_RE_RAW = `[1-9]\\d*[a-z]{2}`;
 
 /**
- * Capture-group form of {@link HASHLINE_LID_RE_SRC}: group 1 captures the
+ * Capture-group form of {@link HL_HASH_RE_RAW}: group 1 captures the
  * line number, group 2 captures the hash.
  */
-export const HASHLINE_LID_CAPTURE_RE_SRC = `([1-9]\\d*)([a-z]{2})`;
+export const HL_HASH_CAPTURE_RE_RAW = `([1-9]\\d*)([a-z]{2})`;
 
 /** Width of a hash in display characters. */
-export const HASHLINE_HASH_WIDTH = 2;
+export const HL_HASH_WIDTH = 2;
 
 /**
  * Representative hash suffixes for use in user-facing error messages and
  * prompt examples.
  */
-export const HASHLINE_HASH_EXAMPLES = ["sr", "ab", "th"] as const;
+export const HL_HASH_EXAMPLES = ["sr", "ab", "th"] as const;
 
 /**
  * Format a comma-separated list of example anchors with an optional line-number
  * prefix, quoted for inclusion in error messages: `"160sr", "160ab", "160th"`.
  */
 export function describeAnchorExamples(linePrefix = ""): string {
-	return HASHLINE_HASH_EXAMPLES.map(e => `"${linePrefix}${e}"`).join(", ");
+	return HL_HASH_EXAMPLES.map(e => `"${linePrefix}${e}"`).join(", ");
 }
 
 /**
- * Sentinel token that the hashline Lark grammar uses for the hash
- * regex source. Replaced at module-load time by {@link resolveLarkLidPlaceholders}
- * so the grammar is re-derived from a single source of truth alongside its
- * TypeScript consumers. Update the placeholder name here and in the grammar together.
+ * Substitute every grammar placeholder with the value derived from its
+ * TypeScript counterpart. Grammars that don't reference these placeholders
+ * pass through unchanged.
  */
-export const LARK_LID_HASH_PLACEHOLDER = "$HASHFMT$";
+export function resolveHashlineGrammarPlaceholders(grammar: string): string {
+	return grammar.replaceAll("$HFMT$", "[a-z]{2}").replaceAll("$HSEP$", JSON.stringify(HL_EDIT_SEP));
+}
+
+/** @deprecated Use {@link resolveHashlineGrammarPlaceholders}. */
+export const resolveLarkLidPlaceholders = resolveHashlineGrammarPlaceholders;
+
+const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 /**
- * Substitute the LID hash placeholder in a Lark grammar text with the
- * `[a-z]{2}` hash regex source. Grammars that don't reference Lids pass
- * through unchanged.
+ * Single source of truth for the hashline edit payload separator. This is the
+ * configured separator that starts inserted/replacement payload lines in
+ * hashline edit input (`<separator>TEXT`) and separates inline modify ops from
+ * their appended/prepended text.
+ *
+ * Override at runtime with the `PI_HL_SEP` env var (e.g.
+ * `PI_HL_SEP=">"`, `PI_HL_SEP="\\"`). The value is read once at module load;
+ * the edit grammar, prompt helper, and edit parser derive from it.
+ *
+ * Default is `~`, chosen empirically. Benchmark across 8 candidate separators
+ * x 3 models (glm-4.7:nitro, gpt-5.4-nano, claude-sonnet-4-6), 24-48 runs per
+ * cell, hashline variant, 12 sampled tasks per run:
+ *
+ *   sep | task ✓ | edit ✓ | patch fail      | tok/run
+ *   ----|--------|--------|-----------------|--------
+ *    +  | 70.8%  | 78.0%  | 27/125 (21.6%)  | 32,127
+ *    ÷  | 70.7%  | 90.6%  | 22/211 (10.4%)  | 31,666
+ *    ~  | 69.4%  | 94.9%  |  6/107 ( 5.6%)  | 30,529   <-- default
+ *    >  | 69.2%  | 91.5%  | 21/219 ( 9.6%)  | 30,777
+ *    :  | 66.7%  | 86.4%  | 20/126 (15.9%)  | 33,900
+ *    |  | 65.9%  | 86.9%  | 20/127 (15.7%)  | 34,589
+ *    \  | 65.5%  | 89.8%  | 16/124 (12.9%)  | 36,010
+ *    %  | 63.9%  | 92.8%  | 11/125 ( 8.8%)  | 36,530
+ *
+ * `~` wins because:
+ *   - highest edit-tool success rate (94.9%) of any tested separator
+ *   - lowest patch-failure rate (5.6%) — model rarely emits a malformed payload
+ *   - cheapest in tokens alongside `>` (no retry overhead from format collisions)
+ *   - no line-leading role in any mainstream language, markdown, diff, regex,
+ *     or shell, so payload lines are unambiguous to both the parser and models
+ *   - task-success is statistically tied with `>` and `÷` (within run-to-run
+ *     noise), so the edit-reliability win is free
+ *
+ * `+` and `÷` lead on raw task-success but at the cost of ~2-4x more patch
+ * failures (the model retries until it lands a valid edit). `:`, `|`, `\`
+ * collide with line-leading syntax (label/object-key, body separator, escape)
+ * and degrade both edit reliability and intent-match.
  */
-export function resolveLarkLidPlaceholders(grammar: string): string {
-	return grammar.replaceAll(LARK_LID_HASH_PLACEHOLDER, "[a-z]{2}");
-}
+export const HL_EDIT_SEP = (() => {
+	const sep = process.env.PI_HL_SEP?.trim();
+	return sep?.length === 1 ? sep : "~";
+})();
+
+/** Regex-escaped form of {@link HL_EDIT_SEP}, safe for regexes. */
+export const HL_EDIT_SEP_RE_RAW = regexEscape(HL_EDIT_SEP);
+
+/** Stable separator for read/search/hashline display output. Intentionally not configurable. */
+export const HL_BODY_SEP = "|";
 
-export const HASHLINE_CONTENT_SEPARATOR = "|";
+/** Regex-escaped form of {@link HL_BODY_SEP}, safe for embedding inside a regex. */
+export const HL_BODY_SEP_RE_RAW = regexEscape(HL_BODY_SEP);
 
 const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
 
 /**
  * Compute a 2-character hash of a single line via xxHash32 mod 647 over
- * {@link HASHLINE_BIGRAMS}. Lines with no letter or digit (e.g. bare `}`,
+ * {@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.
@@ -748,7 +796,7 @@ const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
 export function computeLineHash(idx: number, line: string): string {
 	line = line.replace(/\r/g, "").trimEnd();
 	const seed = RE_SIGNIFICANT.test(line) ? 0 : idx;
-	return HASHLINE_BIGRAMS[Bun.hash.xxHash32(line, seed) % HASHLINE_BIGRAMS_COUNT];
+	return HL_BIGRAMS[Bun.hash.xxHash32(line, seed) % HL_BIGRAMS_COUNT];
 }
 
 /**
@@ -765,7 +813,7 @@ export function formatLineHash(line: number, lines: string): string {
  * Returns `LINE+ID|TEXT` (e.g., `42sr|function hi() {`, `3ab|}`).
  */
 export function formatHashLine(lineNumber: number, line: string): string {
-	return `${lineNumber}${computeLineHash(lineNumber, line)}${HASHLINE_CONTENT_SEPARATOR}${line}`;
+	return `${lineNumber}${computeLineHash(lineNumber, line)}${HL_BODY_SEP}${line}`;
 }
 
 /**

package/src/edit/modes/hashline.lark

@@ -1,4 +1,5 @@
 %import common.LF
+%import common.WS_INLINE
 
 start: section+
 
@@ -6,21 +7,27 @@ section: file_header line_op*
 
 file_header: "@" path LF
 
-line_op: insert_before_op payload+
+line_op: inline_before_op payload*
+       | inline_after_op payload*
+       | insert_before_op payload+
        | insert_after_op payload+
        | replace_op payload*
        | delete_op
        | blank
 
+inline_before_op: "<" LID $HSEP$ line_text? LF
+inline_after_op: "+" LID $HSEP$ line_text? LF
 insert_before_op: "<" insert_target LF
 insert_after_op: "+" insert_target LF
 replace_op: "=" range LF
 delete_op: "-" range LF
-payload: "|" /[^\r\n]*/ LF
+payload: $HSEP$ line_text? LF
+
+line_text: /[^\r\n]+/
 
 insert_target: LID | "EOF" | "BOF"
 range: LID (".." LID)?
 
 path: /(?:[^\s\r\n]+|"[^"\r\n]+"|'[^'\r\n]+')/
-LID: /[1-9][0-9]*$HASHFMT$/
+LID: /[1-9][0-9]*$HFMT$/
 blank: LF

package/src/edit/modes/hashline.ts

@@ -44,9 +44,12 @@ import {
 	computeLineHash,
 	describeAnchorExamples,
 	formatHashLine,
-	HASHLINE_ANCHOR_RE_SRC,
-	HASHLINE_CONTENT_SEPARATOR,
-	HASHLINE_LID_CAPTURE_RE_SRC,
+	HL_ANCHOR_RE_RAW,
+	HL_BODY_SEP,
+	HL_BODY_SEP_RE_RAW,
+	HL_EDIT_SEP,
+	HL_EDIT_SEP_RE_RAW,
+	HL_HASH_CAPTURE_RE_RAW,
 } from "../line-hash";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "../normalize";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
@@ -75,7 +78,8 @@ type HashlineCursor =
 
 export type HashlineEdit =
 	| { kind: "insert"; cursor: HashlineCursor; text: string; lineNum: number; index: number }
-	| { kind: "delete"; anchor: Anchor; lineNum: number; index: number; oldAssertion?: string };
+	| { kind: "delete"; anchor: Anchor; lineNum: number; index: number; oldAssertion?: string }
+	| { kind: "modify"; anchor: Anchor; prefix: string; suffix: string; lineNum: number; index: number };
 
 export const hashlineEditParamsSchema = Type.Object({ input: Type.String() });
 export type HashlineParams = Static<typeof hashlineEditParamsSchema>;
@@ -131,17 +135,18 @@ const RANGE_INTERIOR_HASH = "**";
 /** Header marker introducing a new file section in multi-section input. */
 const FILE_HEADER_PREFIX = "@";
 
-const HASHLINE_CONTENT_SEPARATOR_RE = "[:|]";
-const HASHLINE_PREFIX_RE = new RegExp(`^\\s*(?:>>>|>>)?\\s*(?:[+*]\\s*)?\\d+[a-z]{2}${HASHLINE_CONTENT_SEPARATOR_RE}`);
-const HASHLINE_PREFIX_PLUS_RE = new RegExp(`^\\s*(?:>>>|>>)?\\s*\\+\\s*\\d+[a-z]{2}${HASHLINE_CONTENT_SEPARATOR_RE}`);
+const HL_EDIT_SEPARATOR_RE = HL_EDIT_SEP_RE_RAW;
+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 HASHLINE_HASH_HINT_RE = /^[a-z]{2}$/i;
-const HASHLINE_ANCHOR_EXAMPLES = describeAnchorExamples("160");
+const HL_HASH_HINT_RE = /^[a-z]{2}$/i;
+const HL_ANCHOR_EXAMPLES = describeAnchorExamples("160");
 
-const PARSE_TAG_RE = new RegExp(`^${HASHLINE_ANCHOR_RE_SRC}`);
-const LID_CAPTURE_RE = new RegExp(`^${HASHLINE_LID_CAPTURE_RE_SRC}$`);
+const PARSE_TAG_RE = new RegExp(`^${HL_ANCHOR_RE_RAW}`);
+const LID_CAPTURE_RE = new RegExp(`^${HL_HASH_CAPTURE_RE_RAW}$`);
 
 // ───────────────────────────────────────────────────────────────────────────
 // 4. Small string utilities
@@ -156,7 +161,7 @@ function stripLeadingHashlinePrefixes(line: string): string {
 	let previous: string;
 	do {
 		previous = result;
-		result = result.replace(HASHLINE_PREFIX_RE, "");
+		result = result.replace(HL_PREFIX_RE, "");
 	} while (result !== previous);
 	return result;
 }
@@ -193,8 +198,8 @@ function collectLinePrefixStats(lines: string[]): LinePrefixStats {
 			continue;
 		}
 		stats.nonEmpty++;
-		if (HASHLINE_PREFIX_RE.test(line)) stats.hashPrefixCount++;
-		if (HASHLINE_PREFIX_PLUS_RE.test(line)) stats.diffPlusHashPrefixCount++;
+		if (HL_PREFIX_RE.test(line)) stats.hashPrefixCount++;
+		if (HL_PREFIX_PLUS_RE.test(line)) stats.diffPlusHashPrefixCount++;
 		if (DIFF_PLUS_RE.test(line)) stats.diffPlusCount++;
 	}
 	return stats;
@@ -218,8 +223,8 @@ export function stripNewLinePrefixes(lines: string[]): string[] {
 		.map(line => {
 			if (stripHash) return stripLeadingHashlinePrefixes(line);
 			if (stripPlus) return line.replace(DIFF_PLUS_RE, "");
-			if (stats.diffPlusHashPrefixCount > 0 && HASHLINE_PREFIX_PLUS_RE.test(line)) {
-				return line.replace(HASHLINE_PREFIX_RE, "");
+			if (stats.diffPlusHashPrefixCount > 0 && HL_PREFIX_PLUS_RE.test(line)) {
+				return line.replace(HL_PREFIX_RE, "");
 			}
 			return line;
 		});
@@ -379,14 +384,14 @@ export async function* streamHashLinesFromUtf8(
 
 export function formatFullAnchorRequirement(raw?: string): string {
 	const suffix = typeof raw === "string" ? raw.trim() : "";
-	const hashOnlyHint = HASHLINE_HASH_HINT_RE.test(suffix)
+	const hashOnlyHint = HL_HASH_HINT_RE.test(suffix)
 		? ` It looks like you supplied only the hash suffix (${JSON.stringify(suffix)}). ` +
 			`Copy the full anchor exactly as shown (for example, "160${suffix}").`
 		: "";
 	const received = raw === undefined ? "" : ` Received ${JSON.stringify(raw)}.`;
 	return (
 		`the full anchor exactly as shown by read/search output ` +
-		`(line number + hash, for example ${HASHLINE_ANCHOR_EXAMPLES})${received}${hashOnlyHint}`
+		`(line number + hash, for example ${HL_ANCHOR_EXAMPLES})${received}${hashOnlyHint}`
 	);
 }
 
@@ -527,7 +532,7 @@ export class HashlineMismatchError extends Error {
 			const text = fileLines[lineNum - 1] ?? "";
 			const hash = computeLineHash(lineNum, text);
 			const marker = mismatchSet.has(lineNum) ? "*" : " ";
-			lines.push(`${marker}${lineNum}${hash}${HASHLINE_CONTENT_SEPARATOR}${text}`);
+			lines.push(`${marker}${lineNum}${hash}${HL_BODY_SEP}${text}`);
 		}
 		return lines.join("\n");
 	}
@@ -585,13 +590,13 @@ export function buildCompactHashlineDiffPreview(
 		switch (kind) {
 			case "+":
 				addedLines++;
-				return `+${lineNumber}${computeLineHash(lineNumber, content)}${HASHLINE_CONTENT_SEPARATOR}${content}`;
+				return `+${lineNumber}${computeLineHash(lineNumber, content)}${HL_BODY_SEP}${content}`;
 			case "-":
 				removedLines++;
-				return `-${lineNumber}--${HASHLINE_CONTENT_SEPARATOR}${content}`;
+				return `-${lineNumber}--${HL_BODY_SEP}${content}`;
 			default: {
 				const newLineNumber = lineNumber + addedLines - removedLines;
-				return ` ${newLineNumber}${computeLineHash(newLineNumber, content)}${HASHLINE_CONTENT_SEPARATOR}${content}`;
+				return ` ${newLineNumber}${computeLineHash(newLineNumber, content)}${HL_BODY_SEP}${content}`;
 			}
 		}
 	});
@@ -603,9 +608,9 @@ export function buildCompactHashlineDiffPreview(
 // 10. Edit DSL parsing
 //
 // Grammar (one op per "block"):
-//   "+ ANCHOR"   followed by 1+ "|TEXT" payload lines           — insert
+//   "+ ANCHOR"   followed by 1+ "<sep>TEXT" payload lines        — insert
 //   "- A..B"     no payload                                     — delete range
-//   "= A..B"     followed by 1+ "|TEXT" payload lines           — replace
+//   "= A..B"     followed by 1+ "<sep>TEXT" payload lines        — replace
 //
 // ANCHOR is `LINE<hash>`, e.g. `160ab`. BOF / EOF are also valid insert targets.
 // ───────────────────────────────────────────────────────────────────────────
@@ -614,6 +619,8 @@ const INSERT_BEFORE_OP_RE = /^<\s*(\S+)$/;
 const INSERT_AFTER_OP_RE = /^\+\s*(\S+)$/;
 const DELETE_OP_RE = /^-\s*(\S+)$/;
 const REPLACE_OP_RE = /^=\s*(\S+)$/;
+const INLINE_BEFORE_OP_RE = new RegExp(`^<\\s*${HL_HASH_CAPTURE_RE_RAW}${HL_EDIT_SEPARATOR_RE}(.*)$`);
+const INLINE_AFTER_OP_RE = new RegExp(`^\\+\\s*${HL_HASH_CAPTURE_RE_RAW}${HL_EDIT_SEPARATOR_RE}(.*)$`);
 
 function cloneCursor(cursor: HashlineCursor): HashlineCursor {
 	if (cursor.kind === "before_anchor") return { kind: "before_anchor", anchor: { ...cursor.anchor } };
@@ -631,12 +638,12 @@ function collectPayload(
 	let index = startIndex;
 	while (index < lines.length) {
 		const line = stripTrailingCarriageReturn(lines[index]);
-		if (!line.startsWith("|")) break;
+		if (!line.startsWith(HL_EDIT_SEP)) break;
 		payload.push(line.slice(1));
 		index++;
 	}
 	if (payload.length === 0 && requirePayload) {
-		throw new Error(`line ${opLineNum}: + and < operations require at least one |TEXT payload line.`);
+		throw new Error(`line ${opLineNum}: + and < operations require at least one ${HL_EDIT_SEP}TEXT payload line.`);
 	}
 	return { payload, nextIndex: index };
 }
@@ -647,6 +654,7 @@ export function parseHashline(diff: string): HashlineEdit[] {
 
 export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]; warnings: string[] } {
 	const edits: HashlineEdit[] = [];
+	const warnings: string[] = [];
 	const lines = diff.split("\n");
 	let editIndex = 0;
 
@@ -662,10 +670,46 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 			i++;
 			continue;
 		}
-		if (line.startsWith("|")) {
+		if (line.startsWith(HL_EDIT_SEP)) {
 			throw new Error(`line ${lineNum}: payload line has no preceding +, <, or = operation.`);
 		}
 
+		const inlineBeforeMatch = INLINE_BEFORE_OP_RE.exec(line);
+		if (inlineBeforeMatch) {
+			const anchor = parseLid(`${inlineBeforeMatch[1]}${inlineBeforeMatch[2]}`, lineNum);
+			edits.push({
+				kind: "modify",
+				anchor,
+				prefix: inlineBeforeMatch[3],
+				suffix: "",
+				lineNum,
+				index: editIndex++,
+			});
+			const cursor: HashlineCursor = { kind: "before_anchor", anchor };
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
+			for (const text of payload) pushInsert(cursor, text, lineNum);
+			i = nextIndex;
+			continue;
+		}
+
+		const inlineAfterMatch = INLINE_AFTER_OP_RE.exec(line);
+		if (inlineAfterMatch) {
+			const anchor = parseLid(`${inlineAfterMatch[1]}${inlineAfterMatch[2]}`, lineNum);
+			edits.push({
+				kind: "modify",
+				anchor,
+				prefix: "",
+				suffix: inlineAfterMatch[3],
+				lineNum,
+				index: editIndex++,
+			});
+			const cursor: HashlineCursor = { kind: "after_anchor", anchor };
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
+			for (const text of payload) pushInsert(cursor, text, lineNum);
+			i = nextIndex;
+			continue;
+		}
+
 		const insertBeforeMatch = INSERT_BEFORE_OP_RE.exec(line);
 		if (insertBeforeMatch) {
 			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
@@ -716,12 +760,12 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		}
 
 		throw new Error(
-			`line ${lineNum}: unrecognized op. Use < ANCHOR (insert before), + ANCHOR (insert after), - A..B (delete), = A..B (replace), or |TEXT payload lines. ` +
+			`line ${lineNum}: unrecognized op. Use < ANCHOR (insert before), + ANCHOR (insert after), - A..B (delete), = A..B (replace), or "${HL_EDIT_SEP}TEXT" payload lines. ` +
 				`Got ${JSON.stringify(line)}.`,
 		);
 	}
 
-	return { edits, warnings: [] };
+	return { edits, warnings };
 }
 
 // ───────────────────────────────────────────────────────────────────────────
@@ -751,6 +795,7 @@ interface IndexedEdit {
 
 function getHashlineEditAnchors(edit: HashlineEdit): Anchor[] {
 	if (edit.kind === "delete") return [edit.anchor];
+	if (edit.kind === "modify") return [edit.anchor];
 	if (edit.cursor.kind === "before_anchor") return [edit.cursor.anchor];
 	if (edit.cursor.kind === "after_anchor") return [edit.cursor.anchor];
 	return [];
@@ -850,9 +895,11 @@ function bucketAnchorEditsByLine(edits: IndexedEdit[]): Map<number, IndexedEdit[
 		const line =
 			entry.edit.kind === "delete"
 				? entry.edit.anchor.line
-				: entry.edit.cursor.kind === "before_anchor"
-					? entry.edit.cursor.anchor.line
-					: 0;
+				: entry.edit.kind === "modify"
+					? entry.edit.anchor.line
+					: entry.edit.cursor.kind === "before_anchor"
+						? entry.edit.cursor.anchor.line
+						: 0;
 		const bucket = byLine.get(line);
 		if (bucket) bucket.push(entry);
 		else byLine.set(line, [entry]);
@@ -918,16 +965,34 @@ export function applyHashlineEdits(text: string, edits: HashlineEdit[]): Hashlin
 		const currentLine = fileLines[idx] ?? "";
 		const beforeLines: string[] = [];
 		let deleteLine = false;
+		let prefix = "";
+		let suffix = "";
+		let modified = false;
 
 		for (const { edit } of bucket) {
-			if (edit.kind === "insert") beforeLines.push(edit.text);
-			else deleteLine = true;
+			if (edit.kind === "insert") {
+				beforeLines.push(edit.text);
+			} else if (edit.kind === "delete") {
+				deleteLine = true;
+			} else if (edit.kind === "modify") {
+				prefix = edit.prefix + prefix;
+				suffix = suffix + edit.suffix;
+				modified = true;
+			}
+		}
+		if (beforeLines.length === 0 && !deleteLine && !modified) continue;
+		if (deleteLine && modified) {
+			throw new Error(
+				`line ${line}: cannot combine inline modify ("< ${line}${HL_EDIT_SEP}…" or "+ ${line}${HL_EDIT_SEP}…") with a delete or replace targeting the same line.`,
+			);
 		}
-		if (beforeLines.length === 0 && !deleteLine) continue;
 
-		const replacement = deleteLine ? beforeLines : [...beforeLines, currentLine];
+		const effectiveLine = modified ? prefix + currentLine + suffix : currentLine;
+		const replacement = deleteLine ? beforeLines : [...beforeLines, effectiveLine];
 		const origins = replacement.map((): HashlineLineOrigin => (deleteLine ? "replacement" : "insert"));
-		if (!deleteLine) origins[origins.length - 1] = lineOrigins[idx] ?? "original";
+		if (!deleteLine) {
+			origins[origins.length - 1] = modified ? "replacement" : (lineOrigins[idx] ?? "original");
+		}
 
 		fileLines.splice(idx, 1, ...replacement);
 		lineOrigins.splice(idx, 1, ...origins);
@@ -1000,7 +1065,7 @@ function stripLeadingBlankLines(input: string): string {
 function containsRecognizableHashlineOperations(input: string): boolean {
 	for (const rawLine of input.split("\n")) {
 		const line = stripTrailingCarriageReturn(rawLine);
-		if (/^[+<=-]\s+/.test(line) || line.startsWith("|")) return true;
+		if (/^[+<=-]\s+/.test(line) || line.startsWith(HL_EDIT_SEP)) return true;
 	}
 	return false;
 }
@@ -1119,6 +1184,7 @@ async function readHashlineFile(absolutePath: string): Promise<ReadHashlineFileR
 function hasAnchorScopedEdit(edits: HashlineEdit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
+		if (edit.kind === "modify") return true;
 		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 	});
 }

package/src/edit/renderer.ts

@@ -309,7 +309,7 @@ function getCallPreview(
 }
 
 const MISSING_APPLY_PATCH_END_ERROR = "The last line of the patch must be '*** End Patch'";
-const HASHLINE_INPUT_HEADER_PREFIX = "@";
+const HL_INPUT_HEADER_PREFIX = "@";
 
 function normalizeHashlineInputPreviewPath(rawPath: string): string {
 	const trimmed = rawPath.trim();
@@ -323,8 +323,8 @@ function normalizeHashlineInputPreviewPath(rawPath: string): string {
 }
 
 function parseHashlineInputPreviewHeader(line: string): string | null {
-	if (!line.startsWith(HASHLINE_INPUT_HEADER_PREFIX)) return null;
-	const body = line.slice(HASHLINE_INPUT_HEADER_PREFIX.length).trim();
+	if (!line.startsWith(HL_INPUT_HEADER_PREFIX)) return null;
+	const body = line.slice(HL_INPUT_HEADER_PREFIX.length).trim();
 	const previewPath = normalizeHashlineInputPreviewPath(body);
 	return previewPath.length > 0 ? previewPath : null;
 }