@oh-my-pi/pi-coding-agent 15.2.2 → 15.2.4

package/src/cli/worktree-cli.ts

@@ -0,0 +1,291 @@
+/**
+ * CLI handler for `omp worktree` — list and clean up agent-managed worktrees.
+ *
+ * Layout under `~/.omp/wt/`:
+ *
+ *   - **PR-checkout worktrees** (`tools/gh.ts`): a regular git worktree dir
+ *     containing a `.git` *file* that points back at
+ *     `<parent-repo>/.git/worktrees/<name>/`.
+ *   - **Task-isolation dirs** (`task/worktree.ts`): a wrapper dir with a
+ *     `merged` subdir mounted/cloned by `natives.isoStart`. These are ephemeral
+ *     — `ensureIsolation` always `rm -rf`s the base before re-creating it, so
+ *     any leftover on disk is a leak from a crashed run.
+ *
+ * Legacy entries from before the encoding change keep working because git still
+ * tracks them by branch name. This command exists to GC them on demand.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getWorktreesDir, isEnoent } from "@oh-my-pi/pi-utils";
+import chalk from "chalk";
+import * as git from "../utils/git";
+
+type WorktreeKind = "pr-checkout" | "task-isolation" | "empty" | "stray";
+
+export interface WorktreeEntry {
+	/** Absolute path to the worktree dir (or stray container) under `~/.omp/wt/`. */
+	path: string;
+	/** Classification of what we found on disk. */
+	kind: WorktreeKind;
+	/** Parent repo root, when this is a registered git worktree. */
+	parentRepo?: string;
+	/** Branch name extracted from the parent's tracking file, when available. */
+	branch?: string;
+	/** When set, the entry is unhealthy and `omp worktree clear` will remove it. */
+	orphanReason?: string;
+}
+
+export interface ListWorktreesOptions {
+	json: boolean;
+}
+
+export interface ClearWorktreesOptions {
+	/** Remove every entry, including live PR-checkout worktrees. */
+	all: boolean;
+	/** Print what would be removed without touching the filesystem. */
+	dryRun: boolean;
+	json: boolean;
+}
+
+export async function listWorktrees(options: ListWorktreesOptions): Promise<void> {
+	const entries = await scanWorktrees();
+	if (options.json) {
+		console.log(JSON.stringify(entries, null, 2));
+		return;
+	}
+	if (entries.length === 0) {
+		console.log(chalk.dim(`No agent-managed worktrees found under ${getWorktreesDir()}.`));
+		return;
+	}
+	let live = 0;
+	let orphaned = 0;
+	for (const entry of entries) {
+		const tag = entry.orphanReason ? chalk.yellow("orphaned") : chalk.green("live    ");
+		const detail = formatEntryDetail(entry);
+		console.log(`${tag}  ${entry.path}`);
+		if (detail) console.log(`          ${chalk.dim(detail)}`);
+		if (entry.orphanReason) orphaned += 1;
+		else live += 1;
+	}
+	console.log(chalk.dim(`\n${live} live · ${orphaned} orphaned · ${entries.length} total`));
+}
+
+export async function clearWorktrees(options: ClearWorktreesOptions): Promise<void> {
+	const entries = await scanWorktrees();
+	const targets = options.all ? entries : entries.filter(entry => entry.orphanReason !== undefined);
+
+	if (targets.length === 0) {
+		if (options.json) {
+			console.log(JSON.stringify({ removed: 0, kept: entries.length }));
+		} else {
+			console.log(chalk.dim(options.all ? "No worktrees to remove." : "No orphaned worktrees to remove."));
+		}
+		return;
+	}
+
+	if (options.dryRun) {
+		if (options.json) {
+			console.log(JSON.stringify({ wouldRemove: targets.map(t => t.path) }, null, 2));
+		} else {
+			for (const target of targets) {
+				console.log(`${chalk.yellow("would remove")}  ${target.path}`);
+			}
+			console.log(chalk.dim(`\n${targets.length} dir${targets.length === 1 ? "" : "s"} would be removed.`));
+		}
+		return;
+	}
+
+	const results: { path: string; ok: boolean; error?: string }[] = [];
+	const parentsToPrune = new Set<string>();
+	for (const target of targets) {
+		try {
+			if (target.kind === "pr-checkout" && target.parentRepo && !target.orphanReason) {
+				// Live worktree: ask git to remove it cleanly. If git refuses (locked,
+				// dirty, etc.), fall back to fs.rm and rely on `worktree prune` to
+				// clean the bookkeeping on the parent side.
+				const removed = await git.worktree.tryRemove(target.parentRepo, target.path, { force: true });
+				if (!removed) {
+					await fs.rm(target.path, { recursive: true, force: true });
+					parentsToPrune.add(target.parentRepo);
+				}
+			} else {
+				await fs.rm(target.path, { recursive: true, force: true });
+				if (target.parentRepo) parentsToPrune.add(target.parentRepo);
+			}
+			results.push({ path: target.path, ok: true });
+		} catch (err) {
+			results.push({ path: target.path, ok: false, error: err instanceof Error ? err.message : String(err) });
+		}
+	}
+
+	// Best-effort: drop stale entries from each affected parent's `.git/worktrees/`.
+	for (const parent of parentsToPrune) {
+		try {
+			await git.worktree.prune(parent);
+		} catch {
+			/* parent repo may already be gone or pruned — ignore */
+		}
+	}
+
+	const succeeded = results.filter(r => r.ok).length;
+	const failed = results.length - succeeded;
+
+	if (options.json) {
+		console.log(JSON.stringify({ removed: succeeded, failed, results }, null, 2));
+		if (failed > 0) process.exitCode = 1;
+		return;
+	}
+
+	for (const result of results) {
+		if (result.ok) {
+			console.log(`${chalk.green("removed")}  ${result.path}`);
+		} else {
+			console.log(`${chalk.red("failed ")}  ${result.path}`);
+			if (result.error) console.log(`          ${chalk.dim(result.error)}`);
+		}
+	}
+	console.log(chalk.dim(`\n${succeeded} removed${failed > 0 ? ` · ${chalk.red(`${failed} failed`)}` : ""}`));
+	if (failed > 0) process.exitCode = 1;
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Scanner
+// ───────────────────────────────────────────────────────────────────────────
+
+async function scanWorktrees(): Promise<WorktreeEntry[]> {
+	const root = getWorktreesDir();
+	let topLevel: string[];
+	try {
+		topLevel = await fs.readdir(root);
+	} catch (err) {
+		if (isEnoent(err)) return [];
+		throw err;
+	}
+
+	const entries: WorktreeEntry[] = [];
+	for (const name of topLevel) {
+		const dir = path.join(root, name);
+		const stat = await fs.stat(dir).catch(() => null);
+		if (!stat?.isDirectory()) continue;
+
+		const direct = await classifyDir(dir);
+		if (direct) {
+			entries.push(direct);
+			continue;
+		}
+
+		// Legacy nesting: ~/.omp/wt/<encoded-project>/<branch-or-id>
+		let children: string[];
+		try {
+			children = await fs.readdir(dir);
+		} catch {
+			continue;
+		}
+		let nested = 0;
+		for (const child of children) {
+			const childDir = path.join(dir, child);
+			const childStat = await fs.stat(childDir).catch(() => null);
+			if (!childStat?.isDirectory()) continue;
+			const childClassified = await classifyDir(childDir);
+			if (childClassified) {
+				entries.push(childClassified);
+				nested += 1;
+			}
+		}
+		if (nested === 0) {
+			entries.push({
+				path: dir,
+				kind: children.length === 0 ? "empty" : "stray",
+				orphanReason: children.length === 0 ? "empty directory" : "no recognizable worktree contents",
+			});
+		}
+	}
+	return entries;
+}
+
+async function classifyDir(dir: string): Promise<WorktreeEntry | null> {
+	const gitEntry = path.join(dir, ".git");
+	const gitStat = await fs.stat(gitEntry).catch(() => null);
+	if (gitStat?.isFile()) {
+		return classifyPrCheckout(dir, gitEntry);
+	}
+	const mergedStat = await fs.stat(path.join(dir, "merged")).catch(() => null);
+	if (mergedStat?.isDirectory()) {
+		return {
+			path: dir,
+			kind: "task-isolation",
+			orphanReason: "task-isolation leftover (no live task owns it)",
+		};
+	}
+	return null;
+}
+
+async function classifyPrCheckout(dir: string, gitEntry: string): Promise<WorktreeEntry> {
+	let contents: string;
+	try {
+		contents = await fs.readFile(gitEntry, "utf8");
+	} catch (err) {
+		return {
+			path: dir,
+			kind: "pr-checkout",
+			orphanReason: `cannot read .git file: ${err instanceof Error ? err.message : String(err)}`,
+		};
+	}
+	const match = /^gitdir:\s*(.+?)\s*$/m.exec(contents);
+	const parentGitDir = match?.[1];
+	if (!parentGitDir) {
+		return { path: dir, kind: "pr-checkout", orphanReason: "malformed .git file (no gitdir line)" };
+	}
+	// parentGitDir is `<parent-repo>/.git/worktrees/<name>`; back out the repo root.
+	const parentRepo = path.dirname(path.dirname(path.dirname(parentGitDir)));
+	const branch = await readWorktreeBranch(path.join(parentGitDir, "HEAD"));
+
+	const parentDirStat = await fs.stat(parentGitDir).catch(() => null);
+	if (!parentDirStat?.isDirectory()) {
+		return {
+			path: dir,
+			kind: "pr-checkout",
+			parentRepo,
+			branch,
+			orphanReason: "parent repo no longer tracks this worktree",
+		};
+	}
+	const parentRepoStat = await fs.stat(parentRepo).catch(() => null);
+	if (!parentRepoStat?.isDirectory()) {
+		return {
+			path: dir,
+			kind: "pr-checkout",
+			parentRepo,
+			branch,
+			orphanReason: "parent repo missing",
+		};
+	}
+	return { path: dir, kind: "pr-checkout", parentRepo, branch };
+}
+
+async function readWorktreeBranch(headFile: string): Promise<string | undefined> {
+	try {
+		const head = (await fs.readFile(headFile, "utf8")).trim();
+		const refMatch = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
+		return refMatch?.[1];
+	} catch {
+		return undefined;
+	}
+}
+
+function formatEntryDetail(entry: WorktreeEntry): string {
+	const parts: string[] = [];
+	if (entry.kind === "pr-checkout") {
+		const repo = entry.parentRepo ? path.basename(entry.parentRepo) : "unknown repo";
+		const branch = entry.branch ?? "unknown branch";
+		parts.push(`${repo} · ${branch}`);
+	} else if (entry.kind === "task-isolation") {
+		parts.push("task-isolation sandbox");
+	} else if (entry.kind === "empty") {
+		parts.push("legacy project shell");
+	} else {
+		parts.push("unrecognized contents");
+	}
+	if (entry.orphanReason) parts.push(entry.orphanReason);
+	return parts.join(" — ");
+}

package/src/cli.ts

@@ -46,6 +46,7 @@ const commands: CommandEntry[] = [
 	{ name: "ssh", load: () => import("./commands/ssh").then(m => m.default) },
 	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
+	{ name: "worktree", load: () => import("./commands/worktree").then(m => m.default), aliases: ["wt"] },
 	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
 ];
 

package/src/commands/worktree.ts

@@ -0,0 +1,56 @@
+/**
+ * List and clean up agent-managed git worktrees under `~/.omp/wt`.
+ */
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { clearWorktrees, listWorktrees } from "../cli/worktree-cli";
+
+export default class Worktree extends Command {
+	static description = "List or clear agent-managed git worktrees (~/.omp/wt)";
+
+	static aliases = ["wt"];
+
+	static args = {
+		// `list` (default) inspects the worktree dir; `clear` removes entries.
+		// A positional action keeps `omp worktree` (the no-arg form) useful.
+		action: Args.string({
+			description: "list (default) or clear",
+			required: false,
+			options: ["list", "clear"],
+			default: "list",
+		}),
+	};
+
+	static flags = {
+		all: Flags.boolean({
+			description: "Clear every entry, including live PR-checkout worktrees (clear)",
+			default: false,
+		}),
+		"dry-run": Flags.boolean({
+			char: "n",
+			description: "Print what would be removed without touching the filesystem (clear)",
+			default: false,
+		}),
+		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
+	};
+
+	static examples = [
+		"omp worktree",
+		"omp worktree list --json",
+		"omp worktree clear",
+		"omp worktree clear --dry-run",
+		"omp worktree clear --all",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Worktree);
+		if (args.action === "clear") {
+			await clearWorktrees({
+				all: flags.all ?? false,
+				dryRun: flags["dry-run"] ?? false,
+				json: flags.json ?? false,
+			});
+			return;
+		}
+		await listWorktrees({ json: flags.json ?? false });
+	}
+}

package/src/config/prompt-templates.ts

@@ -8,7 +8,7 @@ import {
 	parseFrontmatter,
 	prompt,
 } from "@oh-my-pi/pi-utils";
-import { computeLineHash, HL_BODY_SEP, HL_EDIT_SEP } from "../hashline/hash";
+import { computeLineHash, HL_BODY_SEP } from "../hashline/hash";
 import { jtdToTypeScript } from "../tools/jtd-to-typescript";
 import { parseCommandArgs, substituteArgs } from "../utils/command-args";
 
@@ -154,13 +154,6 @@ prompt.registerHelper("hline", function (this: unknown, ...args: unknown[]): str
 	return `${ref}${HL_BODY_SEP}${text}`;
 });
 
-/**
- * {{hsep}} — emit the configured hashline payload separator character.
- * Stays in sync with {@link HL_EDIT_SEP} so edit prompt templates
- * never have to hardcode the payload separator.
- */
-prompt.registerHelper("hsep", (): string => HL_EDIT_SEP);
-
 const INLINE_ARG_SHELL_PATTERN = /\$(?:ARGUMENTS|@(?:\[\d+(?::\d*)?\])?|\d+)/;
 const INLINE_ARG_TEMPLATE_PATTERN = /\{\{[\s\S]*?(?:\b(?:arguments|ARGUMENTS|args)\b|\barg\s+[^}]+)[\s\S]*?\}\}/;
 

package/src/config/settings-schema.ts

@@ -601,6 +601,22 @@ export const SETTINGS_SCHEMA = {
 		default: 3,
 	},
 
+	"display.shimmer": {
+		type: "enum",
+		values: ["classic", "kitt", "disabled"] as const,
+		default: "classic",
+		ui: {
+			tab: "appearance",
+			label: "Shimmer",
+			description: "Animation style for working/loading messages",
+			options: [
+				{ value: "classic", label: "Classic", description: "Soft cosine wave sweeping across the text" },
+				{ value: "kitt", label: "KITT Scanner", description: "Knight Rider 1982 red light bouncing left-right" },
+				{ value: "disabled", label: "Disabled", description: "No animation; static muted text" },
+			],
+		},
+	},
+
 	"display.showTokenUsage": {
 		type: "boolean",
 		default: false,

package/src/edit/index.ts

@@ -35,7 +35,7 @@ export * from "./apply-patch";
 export * from "./diff";
 export * from "./file-read-cache";
 
-// Resolve the `$HFMT$` and `$HSEP$` placeholders in the hashline Lark grammar.
+// Resolve the `$HFMT$`, `$HOP_*$`, `$HOP_CHARS$`, and `$HFILE$` placeholders in the hashline Lark grammar.
 const hashlineGrammar = resolveHashlineGrammarPlaceholders(hashlineGrammarTemplate);
 
 export * from "../hashline";

package/src/edit/renderer.ts

@@ -6,6 +6,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { HL_FILE_PREFIX } from "../hashline/hash";
 import type { FileDiagnosticsResult } from "../lsp";
 import { renderDiff as renderDiffColored } from "../modes/components/diff";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
@@ -328,7 +329,6 @@ function getCallPreview(
 }
 
 const MISSING_APPLY_PATCH_END_ERROR = "The last line of the patch must be '*** End Patch'";
-const HL_INPUT_HEADER_PREFIX = "@";
 
 function normalizeHashlineInputPreviewPath(rawPath: string): string {
 	const trimmed = rawPath.trim();
@@ -342,13 +342,11 @@ function normalizeHashlineInputPreviewPath(rawPath: string): string {
 }
 
 function parseHashlineInputPreviewHeader(line: string): string | null {
-	if (!line.startsWith(HL_INPUT_HEADER_PREFIX)) return null;
-	// The real parser (`parseHashlineHeaderLine` in `hashline/input.ts`) strips
-	// every leading "@" before resolving the path so canonical "@@ PATH" headers
-	// (and stray "@ PATH" / "@@@ PATH" runs) all route to the same file. Mirror
-	// that here so the renderer doesn't surface a literal "@ " in the title.
+	if (!line.startsWith(HL_FILE_PREFIX)) return null;
+	// Mirror hashline/input.ts: strip every leading file marker so canonical
+	// `§ PATH` headers and stray `§§ PATH` / `§§§PATH` runs render clean paths.
 	let prefixEnd = 0;
-	while (prefixEnd < line.length && line[prefixEnd] === HL_INPUT_HEADER_PREFIX) prefixEnd++;
+	while (prefixEnd < line.length && line[prefixEnd] === HL_FILE_PREFIX) prefixEnd++;
 	const body = line.slice(prefixEnd).trim();
 	const previewPath = normalizeHashlineInputPreviewPath(body);
 	return previewPath.length > 0 ? previewPath : null;

package/src/edit/streaming.ts

@@ -22,6 +22,8 @@ import {
 	containsRecognizableHashlineOperations,
 	END_PATCH_MARKER,
 	type HashlineInputSection,
+	HL_FILE_PREFIX,
+	HL_OP_CHARS,
 	splitHashlineInputs,
 } from "../hashline";
 import type { Theme } from "../modes/theme/theme";
@@ -77,8 +79,19 @@ const STREAMING_FALLBACK_LINES = 12;
 const STREAMING_FALLBACK_WIDTH = 80;
 
 function isHashlineHeaderLine(line: string): boolean {
+	return line.trimEnd().startsWith(HL_FILE_PREFIX);
+}
+
+function parseHashlineHeaderPath(line: string): string {
 	const trimmed = line.trimEnd();
-	return trimmed.startsWith("@") && trimmed.length > 1;
+	let prefixEnd = 0;
+	while (prefixEnd < trimmed.length && trimmed[prefixEnd] === HL_FILE_PREFIX) prefixEnd++;
+	return trimmed.slice(prefixEnd).trim();
+}
+
+function isHashlineOpLine(line: string): boolean {
+	const first = line[0];
+	return first !== undefined && HL_OP_CHARS.includes(first);
 }
 
 function isHashlineEnvelopeMarkerLine(line: string): boolean {
@@ -358,11 +371,11 @@ function buildApplyPatchNaturalOrderPreviews(input: string): PerFileDiffPreview[
 }
 
 /**
- * Hashline equivalent: emit each section's `~payload` lines as `+added`
- * lines in the order the model typed them. We deliberately omit op headers
- * and removal targets from the streaming preview because their content
- * lives in the file and would require a costly re-apply per tick; the
- * complete unified diff is shown once streaming finishes.
+ * Hashline equivalent: emit each payload line as a `+added` line in the
+ * order the model typed it. We deliberately omit op headers and removal
+ * targets from the streaming preview because their content lives in the file
+ * and would require a costly re-apply per tick; the complete unified diff is
+ * shown once streaming finishes.
  */
 function buildHashlineNaturalOrderPreviews(
 	input: string,
@@ -382,13 +395,12 @@ function buildHashlineNaturalOrderPreviews(
 	for (const raw of lines) {
 		if (isHashlineEnvelopeMarkerLine(raw)) continue;
 		if (isHashlineHeaderLine(raw)) {
-			currentPath = raw.trimEnd().slice(1).trim();
+			currentPath = parseHashlineHeaderPath(raw);
 			if (currentPath) ensure(currentPath);
 			continue;
 		}
-		if (raw.startsWith("~")) {
-			ensure(currentPath).push(`+${raw.slice(1)}`);
-		}
+		if (isHashlineOpLine(raw) || !currentPath) continue;
+		ensure(currentPath).push(`+${raw}`);
 	}
 	if (groups.size === 0) return null;
 	const previews: PerFileDiffPreview[] = [];
@@ -409,7 +421,7 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		if (input.length === 0) return null;
 		if (ctx.isStreaming) {
 			// Skip the costly per-tick re-apply and avoid `Diff.structuredPatch`
-			// reordering by showing the model's `~payload` lines in input order.
+			// reordering by showing payload lines in input order.
 			return buildHashlineNaturalOrderPreviews(input, args.path);
 		}
 		ctx.signal.throwIfAborted();
@@ -419,7 +431,7 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 			sections = splitHashlineInputs(input, { cwd: ctx.cwd, path: args.path });
 		} catch {
 			// Single-section fallback keeps the original error rendering for the
-			// "haven't typed `@@ PATH` yet" case.
+			// "haven't typed `§ PATH` yet" case.
 			const result = await computeHashlineDiff({ input, path: args.path }, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
 			});

package/src/hashline/constants.ts

@@ -4,9 +4,6 @@ export const MISMATCH_CONTEXT = 2;
 /** Filler hash used for the interior of a multi-line range; not validated. */
 export const RANGE_INTERIOR_HASH = "**";
 
-/** Header marker introducing a new file section in multi-section input. */
-export const FILE_HEADER_PREFIX = "@";
-
 /** Optional patch envelope start marker; silently consumed when present. */
 export const BEGIN_PATCH_MARKER = "*** Begin Patch";
 

package/src/hashline/diff.ts

@@ -30,7 +30,7 @@ export async function computeHashlineSectionDiff(
 		const rawContent = await readHashlineFileText(Bun.file(absolutePath), absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		const result = applyHashlineEdits(normalized, parseHashline(section.diff, { path: section.path }), options);
+		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) {

package/src/hashline/execute.ts

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

package/src/hashline/grammar.lark

@@ -3,20 +3,19 @@ begin_patch: "*** Begin Patch" LF
 end_patch: "*** End Patch" LF?
 
 hunk: update_hunk
-update_hunk: "@@ " filename LF line_op*
+update_hunk: "$HFILE$" filename LF line_op*
 
 filename: /(.+)/
 
-line_op: insert_before | insert_after | replace | delete | blank
-insert_before: ("<" | "< ") anchor LF payload+
-insert_after: ("+" | "+ ") anchor LF payload+
-replace: ("=" | "= ") range LF payload*
-delete: ("-" | "- ") range LF
-payload: $HSEP$ /(.*)/ LF
+line_op: insert_before | insert_after | replace | blank
+insert_before: "$HOP_INSERT_BEFORE$" anchor LF payload+
+insert_after: "$HOP_INSERT_AFTER$" anchor LF payload+
+replace: "$HOP_REPLACE$" range LF payload*
+payload: /[^$HOP_CHARS$$HFILE$\n][^\n]*/ LF | LF
 blank: LF
 
 anchor: LID | "EOF" | "BOF"
-range: LID ".." LID
+range: LID (".." LID)?
 LID: /[1-9]\d*$HFMT$/
 
 %import common.LF