@oh-my-pi/hashline 15.13.1 → 15.13.3

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [15.13.3] - 2026-06-15
+
+### Changed
+
+- Changed the recommended hashline range separator from `..` to `.=` (e.g. `SWAP 1.=3:`, `DEL 4.=5`) so the inclusive `<=`-style end is self-evident. `HL_RANGE_SEP` is now `.=`; the prompt, grammar, error messages, and emitted headers all use it. The lenient parser still accepts the legacy `..` (and `-`/`…`/space) forms.
+
+## [15.13.2] - 2026-06-15
+
+### Breaking Changes
+
+- Renamed all hashline DSL operators to concise abbreviated keywords:
+  - `replace` -> `SWAP`
+  - `delete` -> `DEL`
+  - `insert before`/`after`/`head`/`tail` -> `INS.PRE`/`POST`/`HEAD`/`TAIL`
+  - `replace_block` -> `SWAP.BLK`
+  - `delete_block` -> `DEL.BLK`
+  - `insert_after_block` -> `INS.BLK.POST`
+
 ## [15.13.1] - 2026-06-15
 
 ### Breaking Changes

package/README.md

@@ -26,7 +26,7 @@ await fs.writeText("hello.ts", before);
 const tag = snapshots.record("hello.ts", before);
 const patcher = new Patcher({ fs, snapshots });
 const patch = Patch.parse(String.raw`[hello.ts#${tag}]
-replace 1..1:
+SWAP 1.=1:
 +const greeting = "hello";`);
 const result = await patcher.apply(patch);
 
@@ -47,11 +47,11 @@ still matches the recorded content hash, and refusing or attempting
 session-aware recovery on mismatch.
 
 Inside a section:
-- `replace A..B:` — replace lines A..B with following `+TEXT` body rows.
-- `replace block A:` — replace the syntactic block beginning on line A.
-- `delete A..B` / `delete block A` — delete concrete lines or a resolved block.
-- `insert before A:` / `insert after A:` / `insert head:` / `insert tail:` — insert following body rows.
-- `insert after block A:` — insert following body rows after the resolved block's last line.
+- `SWAP A.=B:` — replace lines A.=B with following `+TEXT` body rows.
+- `SWAP.BLK A:` — replace the syntactic block beginning on line A.
+- `DEL A.=B` / `DEL.BLK A` — delete concrete lines or a resolved block.
+- `INS.PRE A:` / `INS.POST A:` / `INS.HEAD:` / `INS.TAIL:` — insert following body rows.
+- `INS.BLK.POST A:` — insert following body rows after the resolved block's last line.
 - `+TEXT` — literal body row (use `+` alone for a blank line).
 
 ## Abstractions

package/dist/types/block.d.ts

@@ -6,7 +6,7 @@ export interface ResolveBlockEditsOptions {
      * `blockUnresolvedMessage` error — used by the authoritative apply + final
      * preview paths. `"drop"` silently skips the edit — used by the streaming
      * preview, where a half-written file or transient parse error must not
-     * throw. Unresolvable `insert after block N:` edits never reach this: they
+     * throw. Unresolvable `insert_after_block N:` edits never reach this: they
      * are lowered to plain `insert after N:` with a warning.
      */
     onUnresolved?: "throw" | "drop";
@@ -19,7 +19,7 @@ export interface ResolveBlockEditsOptions {
     onResolved?: (resolution: BlockResolution) => void;
     /**
      * Invoked once per diagnostic produced while resolving — currently the
-     * `insert after block N:` lowerings (closer anchor or unresolvable block).
+     * `insert_after_block N:` lowerings (closer anchor or unresolvable block).
      * Hosts should surface these on the apply result's `warnings`.
      */
     onWarning?: (message: string) => void;

package/dist/types/format.d.ts

@@ -10,27 +10,30 @@ export declare const HL_FILE_SUFFIX = "]";
 /** Payload sigil for literal body rows. */
 export declare const HL_PAYLOAD_REPLACE = "+";
 /** Hunk-header keyword for concrete line replacement. */
-export declare const HL_REPLACE_KEYWORD = "replace";
-/** Hunk-header sub-keyword: `replace block N:` resolves N to a tree-sitter block range. */
-export declare const HL_BLOCK_KEYWORD = "block";
+export declare const HL_REPLACE_KEYWORD = "SWAP";
 /** Hunk-header keyword for concrete line deletion. */
-export declare const HL_DELETE_KEYWORD = "delete";
+export declare const HL_DELETE_KEYWORD = "DEL";
 /** Hunk-header keyword for insertion operations. */
-export declare const HL_INSERT_KEYWORD = "insert";
+export declare const HL_INSERT_KEYWORD = "INS";
 /** Insert position keyword for inserting before a concrete line. */
-export declare const HL_INSERT_BEFORE = "before";
+export declare const HL_INSERT_BEFORE = "PRE";
 /** Insert position keyword for inserting after a concrete line. */
-export declare const HL_INSERT_AFTER = "after";
+export declare const HL_INSERT_AFTER = "POST";
 /** Insert position keyword for inserting at the start of the file. */
-export declare const HL_INSERT_HEAD = "head";
+export declare const HL_INSERT_HEAD = "HEAD";
 /** Insert position keyword for inserting at the end of the file. */
-export declare const HL_INSERT_TAIL = "tail";
-/** Hunk-header terminator for body-bearing operations. */
+export declare const HL_INSERT_TAIL = "TAIL";
+/** Hunk-header keyword: `SWAP.BLK N:` resolves N to a tree-sitter block range and replaces its span. */
+export declare const HL_REPLACE_BLOCK_KEYWORD = "SWAP.BLK";
+/** Hunk-header keyword: `DEL.BLK N` resolves N to a tree-sitter block range and deletes its span. */
+export declare const HL_DELETE_BLOCK_KEYWORD = "DEL.BLK";
+/** Hunk-header keyword: `INS.BLK.POST N:` inserts after the last line of the tree-sitter block at N. */
+export declare const HL_INSERT_AFTER_BLOCK_KEYWORD = "INS.BLK.POST";
 export declare const HL_HEADER_COLON = ":";
 /** Separator between a hashline file path and its opaque snapshot tag. */
 export declare const HL_FILE_HASH_SEP = "#";
-/** Separator between two line numbers in a range, e.g. `5..10`. */
-export declare const HL_RANGE_SEP = "..";
+/** Separator between two line numbers in a range, e.g. `5.=10`. */
+export declare const HL_RANGE_SEP = ".=";
 /** Separator between a line number and displayed line content in hashline mode. */
 export declare const HL_LINE_BODY_SEP = ":";
 /** Bare positive line-number Lid (no decorations, no captures, no anchors). */

package/dist/types/input.d.ts

@@ -50,7 +50,7 @@ export declare class PatchSection {
      * method directly when you've already validated the file content and
      * just want the result.
      *
-     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * `blockResolver` resolves any `replace_block N:` edits against `text`; an
      * unresolvable block throws (this is the final, authoritative preview path).
      */
     applyTo(text: string, blockResolver?: BlockResolver): ApplyResult;
@@ -61,7 +61,7 @@ export declare class PatchSection {
      * empty-payload edit. Intended for incremental diff previews; the writer
      * path should always use {@link applyTo}.
      *
-     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * `blockResolver` resolves any `replace_block N:` edits against `text`; an
      * unresolvable block is silently dropped so a half-written file does not
      * throw mid-stream.
      */

package/dist/types/messages.d.ts

@@ -17,51 +17,49 @@ export declare const END_PATCH_MARKER = "*** End Patch";
  */
 export declare const ABORT_MARKER = "*** Abort";
 /** Two consecutive hunks targeted the exact same concrete range. */
-export declare const REPLACE_PAIR_COALESCED_WARNING = "Two hunks targeted the same range; kept only the second. One `replace N..M:` hunk per range \u2014 the body is the final content, never old+new.";
-/** Bare bodyless hunk followed by an overlapping concrete hunk. */
-export declare const REPLACE_PAIR_COALESCED_OVERLAP_WARNING = "Dropped a bare hunk overlapped by the concrete hunk after it. One `replace N..M:` hunk per range \u2014 the body is the final content, never old+new.";
+export declare const REPLACE_PAIR_COALESCED_WARNING = "Two hunks targeted the same range; kept only the second. One `SWAP N.=M:` hunk per range \u2014 the body is the final content, never old+new.";
 /** Bare body rows auto-converted to literal `+` rows. */
 export declare const BARE_BODY_AUTO_PIPED_WARNING = "Auto-prefixed bare body row(s) with `+`. Body rows must be `+TEXT` literal lines.";
 /** Unified-diff-style `-` row in a hunk body. */
 export declare const MINUS_ROW_REJECTED = "`-` rows are not valid; the range already names the lines being changed. For a literal `-` line, write `+-\u2026`.";
 /** Replace hunk with no body. */
-export declare const EMPTY_REPLACE = "`replace N..M:` needs at least one `+TEXT` body row. To delete lines, use `delete N..M`.";
-/** `replace block N:` hunk with no body. */
-export declare const EMPTY_BLOCK = "`replace block N:` needs at least one `+TEXT` body row. To delete a block, use `delete block N`.";
+export declare const EMPTY_REPLACE = "`SWAP N.=M:` needs at least one `+TEXT` body row. To delete lines, use `DEL N.=M`.";
+/** `replace_block N:` hunk with no body. */
+export declare const EMPTY_BLOCK = "`SWAP.BLK N:` needs at least one `+TEXT` body row. To delete a block, use `DEL.BLK N`.";
 /**
  * Block-anchored replace/delete could not resolve to a syntactic block
  * (unsupported language, blank/out-of-range line, no node beginning on N, or
  * parse error). Appends a {@link formatAnchoredContext} preview when
- * `fileLines` is given. `insert after block N:` never reaches this — it is
+ * `fileLines` is given. `insert_after_block N:` never reaches this — it is
  * lowered to plain `insert after N:` instead (see
  * {@link insertAfterBlockUnresolvedLoweredWarning}).
  */
 export declare function blockUnresolvedMessage(line: number, op?: "replace" | "delete", fileLines?: readonly string[]): string;
 /** Block-anchored edit reached a path with no {@link BlockResolver} wired in — a host-configuration bug. */
-export declare const BLOCK_RESOLVER_UNAVAILABLE = "`replace block`/`delete block`/`insert after block` are not available here (no block resolver configured). Use a concrete line range.";
+export declare const BLOCK_RESOLVER_UNAVAILABLE = "`SWAP.BLK`/`DEL.BLK`/`INS.BLK.POST` are not available here (no block resolver configured). Use a concrete line range.";
 /**
- * `insert after block N:` anchored on a closing-delimiter line, lowered to
+ * `insert_after_block N:` anchored on a closing-delimiter line, lowered to
  * plain `insert after N:` — the closer ends a block, and inserting after it
  * is exactly what the plain form does.
  */
 export declare function insertAfterBlockCloserLoweredWarning(line: number): string;
 /**
- * `insert after block N:` anchor unresolvable (unsupported language, blank
+ * `insert_after_block N:` anchor unresolvable (unsupported language, blank
  * line, parse error, or no resolver), lowered to plain `insert after N:` —
  * applying with a warning beats failing the patch.
  */
 export declare function insertAfterBlockUnresolvedLoweredWarning(line: number): string;
 /**
- * Internal invariant: `applyEdits` received an unresolved `replace block N:`
+ * Internal invariant: `applyEdits` received an unresolved `replace_block N:`
  * edit; `resolveBlockEdits` must run first. Wiring bug, not authored input.
  */
-export declare const UNRESOLVED_BLOCK_INTERNAL = "internal error: unresolved `replace block` edit reached the applier (resolveBlockEdits was not run).";
+export declare const UNRESOLVED_BLOCK_INTERNAL = "internal error: unresolved `SWAP.BLK` edit reached the applier (resolveBlockEdits was not run).";
 /** Delete hunk received a body row. */
-export declare const DELETE_TAKES_NO_BODY = "`delete N..M` does not take body rows. Remove the body, or use `replace N..M:`.";
-/** `delete block N` hunk received a body row. */
-export declare const DELETE_BLOCK_TAKES_NO_BODY = "`delete block N` does not take body rows. Remove the body, or use `replace block N:`.";
+export declare const DELETE_TAKES_NO_BODY = "`DEL N.=M` does not take body rows. Remove the body, or use `SWAP N.=M:`.";
+/** `delete_block N` hunk received a body row. */
+export declare const DELETE_BLOCK_TAKES_NO_BODY = "`DEL.BLK N` does not take body rows. Remove the body, or use `SWAP.BLK N:`.";
 /** Insert hunk with no body. */
-export declare const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
+export declare const EMPTY_INSERT = "`INS` needs at least one `+TEXT` body row.";
 /**
  * `insert after` body indented shallower than the anchor: the landing slid
  * forward past trailing closer lines — the common "anchored on the last line
@@ -69,7 +67,7 @@ export declare const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body ro
  */
 export declare function afterInsertLandingShiftWarning(anchorLine: number, landingLine: number, crossed: number): string;
 /**
- * `insert after block N:` body indented deeper than the block's closer: the
+ * `insert_after_block N:` body indented deeper than the block's closer: the
  * landing was pulled inside the block — a deeper body almost always means
  * "append inside the block's body".
  */
@@ -90,7 +88,7 @@ export declare const RECOVERY_SESSION_REPLAY_WARNING = "Recovered by replaying y
  * Head/tail position is content-independent, so drift is non-fatal: apply
  * onto live content and warn instead of hard-failing.
  */
-export declare const HEADTAIL_DRIFT_WARNING = "Applied the `insert head:`/`insert tail:` edit despite a stale snapshot tag (file changed since your read) \u2014 head/tail position is content-independent. Re-read if the drift was unexpected.";
+export declare const HEADTAIL_DRIFT_WARNING = "Applied the `INS.HEAD:`/`INS.TAIL:` edit despite a stale snapshot tag (file changed since your read) \u2014 head/tail position is content-independent. Re-read if the drift was unexpected.";
 /**
  * Section omitted the mandatory snapshot tag. Shared by the apply
  * ({@link Patcher.prepare}) and preview/diff paths so both stay in lockstep.
@@ -106,7 +104,7 @@ export declare function unseenLinesMessage(sectionPath: string, unseenLines: rea
 /** Op kind of a deferred block edit, for {@link blockSingleLineMessage}. */
 export type BlockOp = "replace" | "delete" | "insert_after";
 /**
- * A `replace block`/`delete block`/`insert after block` anchor resolved to a
+ * A `replace_block`/`delete_block`/`insert_after_block` anchor resolved to a
  * single line — almost always a bare statement the model mis-anchored, not a
  * multi-line construct. The plain op is unambiguous for one line; the block
  * form only earns its keep when it spares counting a closing line you cannot

package/dist/types/patcher.d.ts

@@ -10,8 +10,8 @@ export interface PatcherOptions {
     /** Snapshot store that minted and resolves hashline section tags. Required. */
     snapshots: SnapshotStore;
     /**
-     * Resolves `replace block N:` anchors to concrete line spans via tree-sitter.
-     * Optional: when omitted, any `replace block N:` edit throws on apply (the
+     * Resolves `replace_block N:` anchors to concrete line spans via tree-sitter.
+     * Optional: when omitted, any `replace_block N:` edit throws on apply (the
      * host did not wire a resolver). Plain line-range ops never need it.
      */
     blockResolver?: BlockResolver;
@@ -41,7 +41,7 @@ export interface PatchSectionResult {
     /** Warnings collected by the parser, applier, and (optionally) recovery. */
     warnings: string[];
     /**
-     * Resolved spans for any `replace block`/`delete block` ops, present when the
+     * Resolved spans for any `replace_block`/`delete_block` ops, present when the
      * apply matched the tagged content. Undefined for patches with no block ops
      * (and for resolutions routed through drift recovery, where numbers shift).
      */

package/dist/types/types.d.ts

@@ -34,7 +34,7 @@ export type Edit = {
     index: number;
     mode?: "replacement";
     /**
-     * Present on inserts lowered from `insert after block N:`: the
+     * Present on inserts lowered from `insert_after_block N:`: the
      * resolved block's first line. Lets the applier slide a body that
      * claims a depth inside the block back across the block's trailing
      * closer lines (never above this line).
@@ -48,13 +48,13 @@ export type Edit = {
     oldAssertion?: string;
 } | {
     /**
-     * Deferred block edit (`replace block N:` / `delete block N` /
-     * `insert after block N:`). The exact line span is unknown at parse
+     * Deferred block edit (`replace_block N:` / `delete_block N` /
+     * `insert_after_block N:`). The exact line span is unknown at parse
      * time — it is computed by {@link resolveBlockEdits} once file text +
      * path (→ language) are available, then expanded into concrete edits:
-     * a non-empty `payloads` without `mode` (from `replace block`) becomes
-     * the same `replacement` inserts + deletes that `replace start..end:`
-     * produces; an empty `payloads` (from `delete block`) becomes a pure
+     * a non-empty `payloads` without `mode` (from `replace_block`) becomes
+     * the same `replacement` inserts + deletes that `replace start.=end:`
+     * produces; an empty `payloads` (from `delete_block`) becomes a pure
      * range deletion; `mode: "insert_after"` becomes plain `after_anchor`
      * inserts at the block's last line. `applyEdits` never sees this
      * variant.
@@ -75,14 +75,14 @@ export interface ApplyResult {
     /** Diagnostic warnings collected by the parser, patcher, or recovery. */
     warnings?: string[];
     /**
-     * Resolved spans for each `replace block`/`delete block` op in this apply,
+     * Resolved spans for each `replace_block`/`delete_block` op in this apply,
      * in patch order. Present only when the apply matched the tagged content
      * (the common no-drift path), so the line numbers line up with what the
      * caller read. Absent when there were no block ops.
      */
     blockResolutions?: BlockResolution[];
 }
-/** A parsed `[A..B]` line range. */
+/** A parsed `[A.=B]` line range. */
 export interface ParsedRange {
     start: Anchor;
     end: Anchor;
@@ -121,7 +121,7 @@ export interface CompactDiffOptions {
     maxUnchangedRun?: number;
 }
 /**
- * Resolved 1-indexed inclusive line span of a `replace block N:` target.
+ * Resolved 1-indexed inclusive line span of a `replace_block N:` target.
  */
 export interface BlockSpan {
     /** First line of the block (1-indexed, inclusive). */
@@ -130,9 +130,9 @@ export interface BlockSpan {
     end: number;
 }
 /**
- * One `replace block N:` / `delete block N` / `insert after block N:` anchor
+ * One `replace_block N:` / `delete_block N` / `insert_after_block N:` anchor
  * resolved to its concrete line span. Surfaced on {@link ApplyResult} so the
- * host can echo "block N → lines start..end" and let the model catch a wrong
+ * host can echo "block N → lines start.=end" and let the model catch a wrong
  * opener — e.g. a decorator or doc-comment that sits in a separate node
  * outside the resolved block.
  */
@@ -146,7 +146,7 @@ export interface BlockResolution {
     /** Which block op produced this resolution. */
     op: "replace" | "delete" | "insert_after";
 }
-/** Request handed to a {@link BlockResolver} to resolve one `replace block N:` anchor. */
+/** Request handed to a {@link BlockResolver} to resolve one `replace_block N:` anchor. */
 export interface BlockResolverRequest {
     /** Target file path (used to infer language by extension). */
     path: string;
@@ -156,7 +156,7 @@ export interface BlockResolverRequest {
     line: number;
 }
 /**
- * Resolves a `replace block N:` anchor to the line span of the syntactic block
+ * Resolves a `replace_block N:` anchor to the line span of the syntactic block
  * that begins on line N. Returns `null` when no block can be resolved
  * (unrecognized language, blank/out-of-range line, no node begins there, or the
  * resolved subtree has a syntax error). Pure seam: the hashline core declares

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "15.13.1",
+	"version": "15.13.3",
 	"description": "Hashline: a compact, line-anchored patch language and applier. Pluggable FS/IO so it works over disk, in-memory, or any custom backend.",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",

package/src/apply.ts

@@ -232,7 +232,7 @@ interface ReplacementGroup {
  * Detect a replacement group starting at `start`: a run of `before_anchor`
  * replacement inserts sharing one source op line, immediately followed by the
  * contiguous range deletes for that same op. Mirrors how the parser lowers an
- * `replace N..M:` hunk with a body.
+ * `replace N.=M:` hunk with a body.
  */
 function findReplacementGroup(edits: readonly AppliedEdit[], start: number): ReplacementGroup | undefined {
 	const first = edits[start];
@@ -453,7 +453,7 @@ function describeBoundaryRepair(group: ReplacementGroup, action: string): string
  * by {@link findDuplicateSuffix}/{@link findDuplicatePrefix}.
  *
  * Scoped to multi-line ranges (a construct rewrite) on purpose: a single-line
- * `replace N..N` expanding into several lines is an *expansion* where every
+ * `replace N.=N` expanding into several lines is an *expansion* where every
  * payload line is intentional new content, so a payload line that happens to
  * equal a neighbor stays — only a genuine block rewrite retypes a boundary
  * keeper by mistake. The dropped lines must be delimiter-neutral so removing the
@@ -592,7 +592,7 @@ function repairReplacementBoundaries(
 // content lines are never crossed) places the body at the depth its
 // indentation names.
 //
-// Inward (block-lowered inserts only): `insert after block N:` anchors on the
+// Inward (block-lowered inserts only): `insert_after_block N:` anchors on the
 // resolved block's closing line, but a body indented deeper than that closer
 // claims a depth inside the block — the common misreading of the op as
 // "append at the end of block N's body". Sliding the landing point backward
@@ -630,7 +630,7 @@ interface AfterInsertGroup {
 	anchor: number;
 	/** Indices into the edit list, in patch order. */
 	members: number[];
-	/** First line of the resolved block when lowered from `insert after block N:`. */
+	/** First line of the resolved block when lowered from `insert_after_block N:`. */
 	blockStart?: number;
 }
 
@@ -730,7 +730,7 @@ function resolveInwardLanding(
 /**
  * Slide mis-anchored after-insert hunks to the depth their body indentation
  * claims: outward past the structural closer lines that follow the anchor
- * when the body is shallower, or — for `insert after block N:` lowerings —
+ * when the body is shallower, or — for `insert_after_block N:` lowerings —
  * inward across the block's trailing closers when the body is deeper than
  * the block's closing line. Returns the corrected edit list plus one warning
  * per shifted hunk.

package/src/block.ts

@@ -1,13 +1,13 @@
 /**
- * Expand deferred block edits (`replace block N:` / `delete block N` /
- * `insert after block N:`) into concrete inserts + deletes.
+ * Expand deferred block edits (`replace_block N:` / `delete_block N` /
+ * `insert_after_block N:`) into concrete inserts + deletes.
  *
  * The hashline parser cannot expand a block edit on its own — the line span is
  * unknown until file text + path (→ language) are available. This transform
  * runs at every apply/preview boundary that has text: it calls the injected
  * {@link BlockResolver} to resolve each block's `[start, end]` span, then emits
  * the exact same edits the concrete form produces in the parser: `replace
- * start..end:` inserts + deletes for a replace, a pure range delete for a
+ * start.=end:` inserts + deletes for a replace, a pure range delete for a
  * delete, and plain `after_anchor` inserts at `end` for an insert-after. After
  * it runs, no `block` edits remain, so {@link applyEdits} (and recovery) only
  * ever see resolved edits.
@@ -29,7 +29,7 @@ export interface ResolveBlockEditsOptions {
 	 * `blockUnresolvedMessage` error — used by the authoritative apply + final
 	 * preview paths. `"drop"` silently skips the edit — used by the streaming
 	 * preview, where a half-written file or transient parse error must not
-	 * throw. Unresolvable `insert after block N:` edits never reach this: they
+	 * throw. Unresolvable `insert_after_block N:` edits never reach this: they
 	 * are lowered to plain `insert after N:` with a warning.
 	 */
 	onUnresolved?: "throw" | "drop";
@@ -42,7 +42,7 @@ export interface ResolveBlockEditsOptions {
 	onResolved?: (resolution: BlockResolution) => void;
 	/**
 	 * Invoked once per diagnostic produced while resolving — currently the
-	 * `insert after block N:` lowerings (closer anchor or unresolvable block).
+	 * `insert_after_block N:` lowerings (closer anchor or unresolvable block).
 	 * Hosts should surface these on the apply result's `warnings`.
 	 */
 	onWarning?: (message: string) => void;
@@ -82,7 +82,7 @@ export function resolveBlockEdits(
 		const op = edit.mode === "insert_after" ? "insert_after" : edit.payloads.length === 0 ? "delete" : "replace";
 		const span = resolver ? resolver({ path, text, line: edit.anchor.line }) : null;
 		if (span === null) {
-			// `insert after block N:` never fails the patch — lower it to plain
+			// `insert_after_block N:` never fails the patch — lower it to plain
 			// `insert after N:` with a warning instead. Two flavors:
 			// - anchored on a pure closing-delimiter line: no block begins
 			//   there, but line N IS the end of one, and "after the end of the
@@ -145,10 +145,10 @@ export function resolveBlockEdits(
 			}
 			continue;
 		}
-		// Mirror the parser's `replace start..end:` expansion exactly: one
+		// Mirror the parser's `replace start.=end:` expansion exactly: one
 		// `before_anchor` replacement insert per payload row at `span.start`,
 		// then one delete per line across `[span.start, span.end]`. An empty
-		// `payloads` (from `delete block N`) emits no inserts — a pure deletion.
+		// `payloads` (from `delete_block N`) emits no inserts — a pure deletion.
 		for (const payload of edit.payloads) {
 			const cursor: Cursor = { kind: "before_anchor", anchor: { line: span.start } };
 			resolved.push({

package/src/format.ts

@@ -14,29 +14,32 @@ export const HL_FILE_SUFFIX = "]";
 export const HL_PAYLOAD_REPLACE = "+";
 
 /** Hunk-header keyword for concrete line replacement. */
-export const HL_REPLACE_KEYWORD = "replace";
-/** Hunk-header sub-keyword: `replace block N:` resolves N to a tree-sitter block range. */
-export const HL_BLOCK_KEYWORD = "block";
+export const HL_REPLACE_KEYWORD = "SWAP";
 /** Hunk-header keyword for concrete line deletion. */
-export const HL_DELETE_KEYWORD = "delete";
+export const HL_DELETE_KEYWORD = "DEL";
 /** Hunk-header keyword for insertion operations. */
-export const HL_INSERT_KEYWORD = "insert";
+export const HL_INSERT_KEYWORD = "INS";
 /** Insert position keyword for inserting before a concrete line. */
-export const HL_INSERT_BEFORE = "before";
+export const HL_INSERT_BEFORE = "PRE";
 /** Insert position keyword for inserting after a concrete line. */
-export const HL_INSERT_AFTER = "after";
+export const HL_INSERT_AFTER = "POST";
 /** Insert position keyword for inserting at the start of the file. */
-export const HL_INSERT_HEAD = "head";
+export const HL_INSERT_HEAD = "HEAD";
 /** Insert position keyword for inserting at the end of the file. */
-export const HL_INSERT_TAIL = "tail";
-/** Hunk-header terminator for body-bearing operations. */
+export const HL_INSERT_TAIL = "TAIL";
+/** Hunk-header keyword: `SWAP.BLK N:` resolves N to a tree-sitter block range and replaces its span. */
+export const HL_REPLACE_BLOCK_KEYWORD = "SWAP.BLK";
+/** Hunk-header keyword: `DEL.BLK N` resolves N to a tree-sitter block range and deletes its span. */
+export const HL_DELETE_BLOCK_KEYWORD = "DEL.BLK";
+/** Hunk-header keyword: `INS.BLK.POST N:` inserts after the last line of the tree-sitter block at N. */
+export const HL_INSERT_AFTER_BLOCK_KEYWORD = "INS.BLK.POST";
 export const HL_HEADER_COLON = ":";
 
 /** Separator between a hashline file path and its opaque snapshot tag. */
 export const HL_FILE_HASH_SEP = "#";
 
-/** Separator between two line numbers in a range, e.g. `5..10`. */
-export const HL_RANGE_SEP = "..";
+/** Separator between two line numbers in a range, e.g. `5.=10`. */
+export const HL_RANGE_SEP = ".=";
 
 /** Separator between a line number and displayed line content in hashline mode. */
 export const HL_LINE_BODY_SEP = ":";
@@ -65,13 +68,13 @@ export function formatDeleteHeader(start: number, end = start): string {
 export function formatInsertHeader(cursor: Cursor): string {
 	switch (cursor.kind) {
 		case "before_anchor":
-			return `${HL_INSERT_KEYWORD} ${HL_INSERT_BEFORE} ${cursor.anchor.line}${HL_HEADER_COLON}`;
+			return `${HL_INSERT_KEYWORD}.${HL_INSERT_BEFORE} ${cursor.anchor.line}${HL_HEADER_COLON}`;
 		case "after_anchor":
-			return `${HL_INSERT_KEYWORD} ${HL_INSERT_AFTER} ${cursor.anchor.line}${HL_HEADER_COLON}`;
+			return `${HL_INSERT_KEYWORD}.${HL_INSERT_AFTER} ${cursor.anchor.line}${HL_HEADER_COLON}`;
 		case "bof":
-			return `${HL_INSERT_KEYWORD} ${HL_INSERT_HEAD}${HL_HEADER_COLON}`;
+			return `${HL_INSERT_KEYWORD}.${HL_INSERT_HEAD}${HL_HEADER_COLON}`;
 		case "eof":
-			return `${HL_INSERT_KEYWORD} ${HL_INSERT_TAIL}${HL_HEADER_COLON}`;
+			return `${HL_INSERT_KEYWORD}.${HL_INSERT_TAIL}${HL_HEADER_COLON}`;
 	}
 }
 

package/src/grammar.lark

@@ -12,16 +12,16 @@ replace_hunk: replace_anchor LF emit_op*
 replace_block_hunk: replace_block_anchor LF emit_op+
 insert_hunk: insert_anchor LF emit_op+
 insert_block_hunk: insert_block_anchor LF emit_op+
-delete_hunk: "delete " header_range LF
-delete_block_hunk: "delete block " LID LF
-replace_anchor: "replace " header_range ":"
-replace_block_anchor: "replace block " LID ":"
-insert_anchor:  "insert " insert_pos ":"
-insert_block_anchor: "insert after block " LID ":"
-insert_pos: "before " LID | "after " LID | "head" | "tail"
+delete_hunk: "DEL " header_range LF
+delete_block_hunk: "DEL.BLK " LID LF
+replace_anchor: "SWAP " header_range ":"
+replace_block_anchor: "SWAP.BLK " LID ":"
+insert_anchor:  "INS." insert_pos ":"
+insert_block_anchor: "INS.BLK.POST " LID ":"
+insert_pos: "PRE " LID | "POST " LID | "HEAD" | "TAIL"
 emit_op: "+" /(.*)/ LF
 
-header_range: LID ".." LID
+header_range: LID ".=" LID
 LID: /[1-9]\d*/
 
 %import common.LF

package/src/input.ts

@@ -273,7 +273,7 @@ export class PatchSection {
 	get hasAnchorScopedEdit(): boolean {
 		return this.edits.some(edit => {
 			if (edit.kind === "delete") return true;
-			// A `replace block N:` edit is anchored to concrete content on line N.
+			// A `replace_block N:` edit is anchored to concrete content on line N.
 			if (edit.kind === "block") return true;
 			return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 		});
@@ -305,7 +305,7 @@ export class PatchSection {
 	 * method directly when you've already validated the file content and
 	 * just want the result.
 	 *
-	 * `blockResolver` resolves any `replace block N:` edits against `text`; an
+	 * `blockResolver` resolves any `replace_block N:` edits against `text`; an
 	 * unresolvable block throws (this is the final, authoritative preview path).
 	 */
 	applyTo(text: string, blockResolver?: BlockResolver): ApplyResult {
@@ -331,7 +331,7 @@ export class PatchSection {
 	 * empty-payload edit. Intended for incremental diff previews; the writer
 	 * path should always use {@link applyTo}.
 	 *
-	 * `blockResolver` resolves any `replace block N:` edits against `text`; an
+	 * `blockResolver` resolves any `replace_block N:` edits against `text`; an
 	 * unresolvable block is silently dropped so a half-written file does not
 	 * throw mid-stream.
 	 */

package/src/messages.ts

@@ -1,6 +1,6 @@
 /** Centralized error/warning text for the hashline parser, applier, and patcher. */
 
-import { formatNumberedLine, HL_FILE_HASH_SEP, HL_FILE_PREFIX, HL_FILE_SUFFIX } from "./format";
+import { formatNumberedLine, HL_FILE_HASH_SEP, HL_FILE_PREFIX, HL_FILE_SUFFIX, HL_RANGE_SEP } from "./format";
 
 /** Lines of context shown either side of a hash mismatch. */
 export const MISMATCH_CONTEXT = 2;
@@ -43,12 +43,10 @@ export const END_PATCH_MARKER = "*** End Patch";
 export const ABORT_MARKER = "*** Abort";
 
 /** Two consecutive hunks targeted the exact same concrete range. */
-export const REPLACE_PAIR_COALESCED_WARNING =
-	"Two hunks targeted the same range; kept only the second. One `replace N..M:` hunk per range — the body is the final content, never old+new.";
+export const REPLACE_PAIR_COALESCED_WARNING = `Two hunks targeted the same range; kept only the second. One \`SWAP N${HL_RANGE_SEP}M:\` hunk per range — the body is the final content, never old+new.`;
 
 /** Bare bodyless hunk followed by an overlapping concrete hunk. */
-export const REPLACE_PAIR_COALESCED_OVERLAP_WARNING =
-	"Dropped a bare hunk overlapped by the concrete hunk after it. One `replace N..M:` hunk per range — the body is the final content, never old+new.";
+`Dropped a bare hunk overlapped by the concrete hunk after it. One \`SWAP N${HL_RANGE_SEP}M:\` hunk per range — the body is the final content, never old+new.`;
 
 /** Bare body rows auto-converted to literal `+` rows. */
 export const BARE_BODY_AUTO_PIPED_WARNING =
@@ -59,17 +57,16 @@ export const MINUS_ROW_REJECTED =
 	"`-` rows are not valid; the range already names the lines being changed. For a literal `-` line, write `+-…`.";
 
 /** Replace hunk with no body. */
-export const EMPTY_REPLACE = "`replace N..M:` needs at least one `+TEXT` body row. To delete lines, use `delete N..M`.";
+export const EMPTY_REPLACE = `\`SWAP N${HL_RANGE_SEP}M:\` needs at least one \`+TEXT\` body row. To delete lines, use \`DEL N${HL_RANGE_SEP}M\`.`;
 
-/** `replace block N:` hunk with no body. */
-export const EMPTY_BLOCK =
-	"`replace block N:` needs at least one `+TEXT` body row. To delete a block, use `delete block N`.";
+/** `replace_block N:` hunk with no body. */
+export const EMPTY_BLOCK = "`SWAP.BLK N:` needs at least one `+TEXT` body row. To delete a block, use `DEL.BLK N`.";
 
 /**
  * Block-anchored replace/delete could not resolve to a syntactic block
  * (unsupported language, blank/out-of-range line, no node beginning on N, or
  * parse error). Appends a {@link formatAnchoredContext} preview when
- * `fileLines` is given. `insert after block N:` never reaches this — it is
+ * `fileLines` is given. `insert_after_block N:` never reaches this — it is
  * lowered to plain `insert after N:` instead (see
  * {@link insertAfterBlockUnresolvedLoweredWarning}).
  */
@@ -78,8 +75,8 @@ export function blockUnresolvedMessage(
 	op: "replace" | "delete" = "replace",
 	fileLines?: readonly string[],
 ): string {
-	const phrase = op === "delete" ? `delete block ${line}` : `replace block ${line}:`;
-	const fallback = op === "delete" ? `delete ${line}..M` : `replace ${line}..M:`;
+	const phrase = op === "delete" ? `DEL.BLK ${line}` : `SWAP.BLK ${line}:`;
+	const fallback = op === "delete" ? `DEL ${line}${HL_RANGE_SEP}M` : `SWAP ${line}${HL_RANGE_SEP}M:`;
 	let message =
 		`\`${phrase}\` could not resolve a syntactic block beginning on line ${line} ` +
 		`(unsupported language, blank/closer line, or parse error). Use \`${fallback}\` with explicit lines.`;
@@ -92,42 +89,41 @@ export function blockUnresolvedMessage(
 
 /** Block-anchored edit reached a path with no {@link BlockResolver} wired in — a host-configuration bug. */
 export const BLOCK_RESOLVER_UNAVAILABLE =
-	"`replace block`/`delete block`/`insert after block` are not available here (no block resolver configured). Use a concrete line range.";
+	"`SWAP.BLK`/`DEL.BLK`/`INS.BLK.POST` are not available here (no block resolver configured). Use a concrete line range.";
 
 /**
- * `insert after block N:` anchored on a closing-delimiter line, lowered to
+ * `insert_after_block N:` anchored on a closing-delimiter line, lowered to
  * plain `insert after N:` — the closer ends a block, and inserting after it
  * is exactly what the plain form does.
  */
 export function insertAfterBlockCloserLoweredWarning(line: number): string {
-	return `\`insert after block ${line}:\` anchors on a closing delimiter, so it was applied as plain \`insert after ${line}:\`. Anchor on the line that OPENS the construct.`;
+	return `\`INS.BLK.POST ${line}:\` anchors on a closing delimiter, so it was applied as plain \`INS.POST ${line}:\`. Anchor on the line that OPENS the construct.`;
 }
 
 /**
- * `insert after block N:` anchor unresolvable (unsupported language, blank
+ * `insert_after_block N:` anchor unresolvable (unsupported language, blank
  * line, parse error, or no resolver), lowered to plain `insert after N:` —
  * applying with a warning beats failing the patch.
  */
 export function insertAfterBlockUnresolvedLoweredWarning(line: number): string {
-	return `\`insert after block ${line}:\` could not resolve a syntactic block on line ${line}, so it was applied as plain \`insert after ${line}:\`. Verify the landing line; anchor on a line that OPENS a construct.`;
+	return `\`INS.BLK.POST ${line}:\` could not resolve a syntactic block on line ${line}, so it was applied as plain \`INS.POST ${line}:\`. Verify the landing line; anchor on a line that OPENS a construct.`;
 }
 
 /**
- * Internal invariant: `applyEdits` received an unresolved `replace block N:`
+ * Internal invariant: `applyEdits` received an unresolved `replace_block N:`
  * edit; `resolveBlockEdits` must run first. Wiring bug, not authored input.
  */
 export const UNRESOLVED_BLOCK_INTERNAL =
-	"internal error: unresolved `replace block` edit reached the applier (resolveBlockEdits was not run).";
+	"internal error: unresolved `SWAP.BLK` edit reached the applier (resolveBlockEdits was not run).";
 
 /** Delete hunk received a body row. */
-export const DELETE_TAKES_NO_BODY = "`delete N..M` does not take body rows. Remove the body, or use `replace N..M:`.";
+export const DELETE_TAKES_NO_BODY = `\`DEL N${HL_RANGE_SEP}M\` does not take body rows. Remove the body, or use \`SWAP N${HL_RANGE_SEP}M:\`.`;
 
-/** `delete block N` hunk received a body row. */
-export const DELETE_BLOCK_TAKES_NO_BODY =
-	"`delete block N` does not take body rows. Remove the body, or use `replace block N:`.";
+/** `delete_block N` hunk received a body row. */
+export const DELETE_BLOCK_TAKES_NO_BODY = "`DEL.BLK N` does not take body rows. Remove the body, or use `SWAP.BLK N:`.";
 
 /** Insert hunk with no body. */
-export const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
+export const EMPTY_INSERT = "`INS` needs at least one `+TEXT` body row.";
 
 /**
  * `insert after` body indented shallower than the anchor: the landing slid
@@ -135,16 +131,16 @@ export const EMPTY_INSERT = "`insert` needs at least one `+TEXT` body row.";
  * I read instead of after the block" mistake.
  */
 export function afterInsertLandingShiftWarning(anchorLine: number, landingLine: number, crossed: number): string {
-	return `insert after ${anchorLine}: body indented shallower than the anchor, so the landing moved past ${crossed} closing line${crossed === 1 ? "" : "s"} to after line ${landingLine}. For the deeper position inside the block, re-issue with the body indented to match.`;
+	return `INS.POST ${anchorLine}: body indented shallower than the anchor, so the landing moved past ${crossed} closing line${crossed === 1 ? "" : "s"} to after line ${landingLine}. For the deeper position inside the block, re-issue with the body indented to match.`;
 }
 
 /**
- * `insert after block N:` body indented deeper than the block's closer: the
+ * `insert_after_block N:` body indented deeper than the block's closer: the
  * landing was pulled inside the block — a deeper body almost always means
  * "append inside the block's body".
  */
 export function blockInsertLandingShiftWarning(blockStart: number, closerLine: number, landingLine: number): string {
-	return `insert after block ${blockStart}: body indented deeper than closing line ${closerLine}, so it was placed inside the block, after line ${landingLine}. \`insert after block\` lands AFTER the block at sibling depth — if inside was intended, use plain \`insert after ${closerLine}:\`.`;
+	return `INS.BLK.POST ${blockStart}: body indented deeper than closing line ${closerLine}, so it was placed inside the block, after line ${landingLine}. \`INS.BLK.POST\` lands AFTER the block at sibling depth — if inside was intended, use plain \`INS.POST ${closerLine}:\`.`;
 }
 
 /** `Recovery`: an external write matched a cached snapshot. */
@@ -170,7 +166,7 @@ export const RECOVERY_SESSION_REPLAY_WARNING =
  * onto live content and warn instead of hard-failing.
  */
 export const HEADTAIL_DRIFT_WARNING =
-	"Applied the `insert head:`/`insert tail:` edit despite a stale snapshot tag (file changed since your read) — head/tail position is content-independent. Re-read if the drift was unexpected.";
+	"Applied the `INS.HEAD:`/`INS.TAIL:` edit despite a stale snapshot tag (file changed since your read) — head/tail position is content-independent. Re-read if the drift was unexpected.";
 
 /**
  * Section omitted the mandatory snapshot tag. Shared by the apply
@@ -220,20 +216,20 @@ export function unseenLinesMessage(sectionPath: string, unseenLines: readonly nu
 export type BlockOp = "replace" | "delete" | "insert_after";
 
 /**
- * A `replace block`/`delete block`/`insert after block` anchor resolved to a
+ * A `replace_block`/`delete_block`/`insert_after_block` anchor resolved to a
  * single line — almost always a bare statement the model mis-anchored, not a
  * multi-line construct. The plain op is unambiguous for one line; the block
  * form only earns its keep when it spares counting a closing line you cannot
  * see. Reject and point at both fixes.
  */
 export function blockSingleLineMessage(line: number, op: BlockOp): string {
-	const blockForm = op === "insert_after" ? "insert after block" : op === "delete" ? "delete block" : "replace block";
+	const blockForm = op === "insert_after" ? "INS.BLK.POST" : op === "delete" ? "DEL.BLK" : "SWAP.BLK";
 	const plainForm =
 		op === "insert_after"
-			? `insert after ${line}:`
+			? `INS.POST ${line}:`
 			: op === "delete"
-				? `delete ${line}`
-				: `replace ${line}..${line}:`;
+				? `DEL ${line}`
+				: `SWAP ${line}${HL_RANGE_SEP}${line}:`;
 	return (
 		`\`${blockForm} ${line}\` resolved a single-line block — line ${line} is a bare statement, not the opening line ` +
 		`of a multi-line construct. For that one line use \`${plainForm}\`; to act on an enclosing construct, anchor ${blockForm} ` +

package/src/parser.ts

@@ -3,7 +3,7 @@
  * flat list of {@link Edit}s. Sits between the {@link Tokenizer} and the
  * applier.
  */
-import { HL_PAYLOAD_REPLACE } from "./format";
+import { HL_PAYLOAD_REPLACE, HL_RANGE_SEP } from "./format";
 import {
 	BARE_BODY_AUTO_PIPED_WARNING,
 	DELETE_BLOCK_TAKES_NO_BODY,
@@ -18,7 +18,9 @@ import type { Anchor, Cursor, Edit } from "./types";
 
 function validateRangeOrder(range: ParsedRange, lineNum: number): void {
 	if (range.end.line < range.start.line) {
-		throw new Error(`line ${lineNum}: range ${range.start.line}..${range.end.line} ends before it starts.`);
+		throw new Error(
+			`line ${lineNum}: range ${range.start.line}${HL_RANGE_SEP}${range.end.line} ends before it starts.`,
+		);
 	}
 }
 
@@ -52,33 +54,33 @@ function detectApplyPatchContamination(text: string, _hasPending: boolean): stri
 		return (
 			`apply_patch sentinel ${JSON.stringify(preview)} is not valid in hashline. ` +
 			"File sections start with `[path#HASH]` (no `Update File:` / `Add File:` keyword). " +
-			"Use `replace N..M:`, `delete N..M`, or `insert before|after|head|tail:` ops."
+			`Use \`SWAP N${HL_RANGE_SEP}M:\`, \`DEL N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` ops.`
 		);
 	}
 	if (/^@@\s+[-+]?\d+,\d+\s+[-+]?\d+,\d+\s+@@/.test(trimmed)) {
 		return (
 			"unified-diff hunk header (`@@ -N,M +N,M @@`) is not valid in hashline. " +
-			"Use `replace N..M:`, `delete N..M`, or `insert before|after|head|tail:` ops."
+			`Use \`SWAP N${HL_RANGE_SEP}M:\`, \`DEL N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` ops.`
 		);
 	}
 	if (trimmed.startsWith("@@")) {
 		const preview = trimmed.length > 48 ? `${trimmed.slice(0, 48)}…` : trimmed;
 		return (
 			`\`@@\`-bracketed hunk header ${JSON.stringify(preview)} is not valid in hashline. ` +
-			"Drop the `@@ ... @@` brackets and write a verb header such as `replace N..M:`."
+			`Drop the \`@@ ... @@\` brackets and write a verb header such as \`SWAP N${HL_RANGE_SEP}M:\`.`
 		);
 	}
-	if (/^delete\s+[1-9]\d*(?:\s*(?:\.\.|-|…|\s)\s*[1-9]\d*)?\s*:/.test(trimmed)) {
-		return "`delete N..M` has no colon and no body. Remove the colon and body rows.";
+	if (/^DEL\s+[1-9]\d*(?:\s*(?:\.\.|\.=|-|…|\s)\s*[1-9]\d*)?\s*:/.test(trimmed)) {
+		return `\`DEL N${HL_RANGE_SEP}M\` has no colon and no body. Remove the colon and body rows.`;
 	}
 	if (/^[1-9]\d*\s*$/.test(trimmed)) {
-		return `hunk headers need a verb. Use \`replace ${trimmed}..${trimmed}:\` to replace, or \`delete ${trimmed}\` to delete.`;
+		return `hunk headers need a verb. Use \`SWAP ${trimmed}${HL_RANGE_SEP}${trimmed}:\` to replace, or \`DEL ${trimmed}\` to delete.`;
 	}
-	const bareRange = /^([1-9]\d*)\s*[-. …]+\s*([1-9]\d*)\s*:?$/.exec(trimmed);
+	const bareRange = /^([1-9]\d*)\s*[-. …=]+\s*([1-9]\d*)\s*:?$/.exec(trimmed);
 	if (bareRange !== null) {
 		return (
 			`bare range hunk header ${JSON.stringify(trimmed)} is not valid. ` +
-			`Hunk headers need a verb: write \`replace ${bareRange[1]}..${bareRange[2]}:\` or \`delete ${bareRange[1]}..${bareRange[2]}\`.`
+			`Hunk headers need a verb: write \`SWAP ${bareRange[1]}${HL_RANGE_SEP}${bareRange[2]}:\` or \`DEL ${bareRange[1]}${HL_RANGE_SEP}${bareRange[2]}\`.`
 		);
 	}
 	return null;
@@ -253,7 +255,7 @@ export class Executor {
 		if (text.trim().length === 0) return;
 		throw new Error(
 			`line ${lineNum}: payload line has no preceding hunk header. ` +
-				`Use \`replace N..M:\`, \`delete N..M\`, or \`insert before|after|head|tail:\` above the body. Got ${JSON.stringify(text)}.`,
+				`Use \`SWAP N${HL_RANGE_SEP}M:\`, \`DEL N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` above the body. Got ${JSON.stringify(text)}.`,
 		);
 	}
 

package/src/patcher.ts

@@ -41,8 +41,8 @@ export interface PatcherOptions {
 	/** Snapshot store that minted and resolves hashline section tags. Required. */
 	snapshots: SnapshotStore;
 	/**
-	 * Resolves `replace block N:` anchors to concrete line spans via tree-sitter.
-	 * Optional: when omitted, any `replace block N:` edit throws on apply (the
+	 * Resolves `replace_block N:` anchors to concrete line spans via tree-sitter.
+	 * Optional: when omitted, any `replace_block N:` edit throws on apply (the
 	 * host did not wire a resolver). Plain line-range ops never need it.
 	 */
 	blockResolver?: BlockResolver;
@@ -73,7 +73,7 @@ export interface PatchSectionResult {
 	/** Warnings collected by the parser, applier, and (optionally) recovery. */
 	warnings: string[];
 	/**
-	 * Resolved spans for any `replace block`/`delete block` ops, present when the
+	 * Resolved spans for any `replace_block`/`delete_block` ops, present when the
 	 * apply matched the tagged content. Undefined for patches with no block ops
 	 * (and for resolutions routed through drift recovery, where numbers shift).
 	 */
@@ -112,7 +112,7 @@ export class PreparedSection {
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
-		// A `replace block N:` edit anchors to concrete content on line N.
+		// A `replace_block N:` edit anchors to concrete content on line N.
 		if (edit.kind === "block") return true;
 		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 	});
@@ -386,7 +386,7 @@ export class Patcher {
 		const expected = exists ? section.fileHash : undefined;
 		const liveMatches = expected !== undefined && computeFileHash(normalized) === expected;
 
-		// Resolve `replace block N:` edits to concrete ranges before recovery
+		// Resolve `replace_block N:` edits to concrete ranges before recovery
 		// runs. Block anchors are expressed against the snapshot the section tag
 		// names, so resolve against that exact text:
 		//   - live content matches the tag (or there is no tag) → resolve against

package/src/prompt.md

@@ -1,20 +1,20 @@
-Your patch language names lines to replace, delete, or insert at, then lists the new content. Rule of thumb: a header ending in `:` is followed by `+` body rows; `delete` has no body.
+Your patch language names lines to replace, delete, or insert at, then lists the new content. Rule of thumb: a header ending in `:` is followed by `+` body rows; `DEL` has no body.
 
 <headers>
 Every file section starts with `[PATH#TAG]`. `TAG` is the 4-hex snapshot tag from your latest `read`/`search`, and is REQUIRED on every section — there is no hashless form. To create a new file, use the `write` tool; hashline only edits files that already exist.
 </headers>
 
 <ops>
-`replace N..M:` — replace original lines N..M with the body rows below. INCLUSIVE — line M is consumed too.
-`replace block N:` — replace the whole syntactic block that BEGINS on line N; tree-sitter resolves the closing line. Body rows below.
-`delete N..M` — delete original lines N..M. No body.
-`delete block N` — delete the whole syntactic block that BEGINS on line N.
-`insert before N:` — insert the body rows immediately before line N.
-`insert after N:` — insert the body rows immediately after line N.
-`insert after block N:` — insert the body rows after the END of the block that BEGINS on line N — outside it, at sibling depth. To append inside a block, use `insert after`.
-`insert head:` — insert the body rows at the very start of the file.
-`insert tail:` — insert the body rows at the very end of the file.
-Single line: `replace N..N:` / `delete N`. The range is the ORIGINAL lines you touch; body length is irrelevant (replacing 1 line with 10 is still `replace N..N:`).
+`SWAP N.=M:` — replace original lines N.=M with the body rows below. INCLUSIVE — line M is consumed too.
+`SWAP.BLK N:` — replace the whole syntactic block that BEGINS on line N; tree-sitter resolves the closing line. Body rows below.
+`DEL N.=M` — delete original lines N.=M. No body.
+`DEL.BLK N` — delete the whole syntactic block that BEGINS on line N.
+`INS.PRE N:` — insert the body rows immediately before line N.
+`INS.POST N:` — insert the body rows immediately after line N.
+`INS.BLK.POST N:` — insert the body rows after the END of the block that BEGINS on line N — outside it, at sibling depth. To append inside a block, use `INS.POST`.
+`INS.HEAD:` — insert the body rows at the very start of the file.
+`INS.TAIL:` — insert the body rows at the very end of the file.
+Single line: `SWAP N.=N:` / `DEL N`. The range is the ORIGINAL lines you touch; body length is irrelevant (replacing 1 line with 10 is still `SWAP N.=N:`).
 </ops>
 
 <body-rows>
@@ -34,11 +34,11 @@ There is NO other body row kind. NEVER write `-old` or a bare/context line. To k
 - On a stale-tag rejection or any surprising result: STOP and re-`read` before further edits.
 - One hunk per range; the body is the final content, never an old/new pair.
 - Ranges cover ONLY lines whose content changes. Never widen over unchanged lines — a stale wide range shreds everything it spans.
-- Whole construct → `replace block N` (tree-sitter resolves the end); lines inside it → `replace N..M`.
-- `replace block N` resolves EXACTLY the node at N. Leading decorators/attributes/doc-comments are separate nodes: point N at the FIRST decorator to sweep both; standalone line-comments are never swept — use `replace N..M`.
-- Block ops (`replace block`/`delete block`/`insert after block`) anchor the OPENING line of a MULTI-LINE construct — never its closer, its last line, or a bare statement inside it. Anchoring a single statement resolves to ONE line and is REJECTED: use the plain op (`replace N..N` / `delete N` / `insert after N`) for one line, or point N at the real opener. Saw the closer? Use plain `insert after M:`.
+- Whole construct → `SWAP.BLK N` (tree-sitter resolves the end); lines inside it → `SWAP N.=M`.
+- `SWAP.BLK N` resolves EXACTLY the node at N. Leading decorators/attributes/doc-comments are separate nodes: point N at the FIRST decorator to sweep both; standalone line-comments are never swept — use `SWAP N.=M`.
+- Block ops (`SWAP.BLK`/`DEL.BLK`/`INS.BLK.POST`) anchor the OPENING line of a MULTI-LINE construct — never its closer, its last line, or a bare statement inside it. Anchoring a single statement resolves to ONE line and is REJECTED: use the plain op (`SWAP N.=N` / `DEL N` / `INS.POST N`) for one line, or point N at the real opener. Saw the closer? Use plain `INS.POST M:`.
 - Non-adjacent changes = separate hunks; untouched lines stay out of every range.
-- Pure additions use `insert`, never a widened `replace` — retyped keepers are exactly what gets dropped. A multi-line `replace` whose body restates the line just outside the range is auto-dropped as an off-by-one keeper (with a warning), but issue the payload as the final content for the range only and never lean on the repair.
+- Pure additions use `INS.PRE` / `INS.POST` / `INS.HEAD` / `INS.TAIL`, never a widened `SWAP` — retyped keepers are exactly what gets dropped. A multi-line `SWAP` whose body restates the line just outside the range is auto-dropped as an off-by-one keeper (with a warning), but issue the payload as the final content for the range only and never lean on the repair.
 - NEVER format/restyle code with this tool; run the project formatter instead.
 </rules>
 
@@ -55,14 +55,14 @@ Original (the exact shape `read` returns):
 Insert a guard after line 1:
 ```
 [greet.py#A1B2]
-insert after 1:
+INS.POST 1:
 +    if not name: name = "stranger"
 ```
 
 Replace line 2 with two lines:
 ```
 [greet.py#A1B2]
-replace 2..2:
+SWAP 2.=2:
 +    greeting = "Hi"
 +    msg = f"{greeting}, {name}"
 ```
@@ -70,30 +70,30 @@ replace 2..2:
 Delete line 3:
 ```
 [greet.py#A1B2]
-delete 3
+DEL 3
 ```
 
 Add a header and trailer:
 ```
 [greet.py#A1B2]
-insert head:
+INS.HEAD:
 +# generated header
-insert tail:
+INS.TAIL:
 +greet("everyone")
 ```
 
-Replace the whole `greet` function block — `replace block 1:` resolves lines 1–3 (the `def` header through `print(msg)`); line 4 is a separate statement and stays:
+Replace the whole `greet` function block — `SWAP.BLK 1:` resolves lines 1–3 (the `def` header through `print(msg)`); line 4 is a separate statement and stays:
 ```
 [greet.py#A1B2]
-replace block 1:
+SWAP.BLK 1:
 +def greet(name):
 +    print(f"Hello, {name}")
 ```
 
-A decorator or doc-comment is a SEPARATE block — `replace block` on the `def`/`fn` line keeps it. Point N at the decorator to take both; here line 1 is `@cache`, so anchoring on the `def` (line 2) would resolve only the function and orphan `@cache`:
+A decorator or doc-comment is a SEPARATE block — `SWAP.BLK` on the `def`/`fn` line keeps it. Point N at the decorator to take both; here line 1 is `@cache`, so anchoring on the `def` (line 2) would resolve only the function and orphan `@cache`:
 ```
 [svc.py#C3D4]
-replace block 1:
+SWAP.BLK 1:
 +@cache
 +def load(key):
 +    return store[key]
@@ -101,43 +101,43 @@ replace block 1:
 </example>
 
 <anti-patterns>
-# WRONG — empty `replace` to delete. RIGHT: delete 4
-replace 4..4:
+# WRONG — empty `SWAP` to delete. RIGHT: DEL 4
+SWAP 4.=4:
 
-# WRONG — range describes post-edit size. RIGHT: replace 1..1: (body length is irrelevant)
-replace 1..2:
+# WRONG — range describes post-edit size. RIGHT: SWAP 1.=1: (body length is irrelevant)
+SWAP 1.=2:
 +def greet(name):
 
 # WRONG — `-` rows / bare context lines do not exist. The range deletes; the body is only the new content.
-replace 3..3:
+SWAP 3.=3:
     msg = "Hello, " + name
 -   print(msg)
 +   return msg
 # RIGHT
-replace 3..3:
+SWAP 3.=3:
 +   return msg
 
-# WRONG — a pure insertion done as a widened `replace`: you only want to add one line after 2,
-# but you replace 2..4, retype the keepers in the body, and drop one (here line 4, `greet("world")`).
-replace 2..4:
+# WRONG — a pure insertion done as a widened `SWAP`: you only want to add one line after 2,
+# but you replace 2.=4, retype the keepers in the body, and drop one (here line 4, `greet("world")`).
+SWAP 2.=4:
 +    msg = "Hello, " + name
 +    extra = compute(name)
 +    print(msg)
 # RIGHT — touch nothing you keep; the new line is the whole body.
-insert after 2:
+INS.POST 2:
 +    extra = compute(name)
 
-# WRONG — `insert after block N:` anchored on a closing delimiter / last visible line. RIGHT: plain `insert after M:`
-insert after block 3:
+# WRONG — `INS.BLK.POST N:` anchored on a closing delimiter / last visible line. RIGHT: plain `INS.POST M:`
+INS.BLK.POST 3:
 +after()
 # RIGHT
-insert after 3:
+INS.POST 3:
 +after()
 </anti-patterns>
 
 <critical>
 If you remember nothing else:
 1. RE-GROUND AFTER EVERY EDIT. Every apply mints a fresh `#TAG` and renumbers — take the next edit's numbers from the edit response or a fresh `read`. Stale tag or surprise? STOP, re-`read`.
-2. RANGES ARE TIGHT. Cover only lines that change; a stale wide range shreds everything it spans. Whole construct → `replace block N`.
+2. RANGES ARE TIGHT. Cover only lines that change; a stale wide range shreds everything it spans. Whole construct → `SWAP.BLK N`.
 3. THE BODY IS THE FINAL CONTENT. Only `+TEXT` rows; never `-old`/context lines. The range does the deleting.
 </critical>

package/src/tokenizer.ts

@@ -4,13 +4,13 @@
  * Format shape:
  * ```
  * [path/to/file.ts#1A2B]
- * replace 5..7:
+ * replace 5.=7:
  * +literal new line
  * ```
  */
 import {
 	describeAnchorExamples,
-	HL_BLOCK_KEYWORD,
+	HL_DELETE_BLOCK_KEYWORD,
 	HL_DELETE_KEYWORD,
 	HL_FILE_HASH_LENGTH,
 	HL_FILE_HASH_SEP,
@@ -18,11 +18,13 @@ import {
 	HL_FILE_SUFFIX,
 	HL_HEADER_COLON,
 	HL_INSERT_AFTER,
+	HL_INSERT_AFTER_BLOCK_KEYWORD,
 	HL_INSERT_BEFORE,
 	HL_INSERT_HEAD,
 	HL_INSERT_KEYWORD,
 	HL_INSERT_TAIL,
 	HL_PAYLOAD_REPLACE,
+	HL_REPLACE_BLOCK_KEYWORD,
 	HL_REPLACE_KEYWORD,
 } from "./format";
 import { ABORT_MARKER, BEGIN_PATCH_MARKER, END_PATCH_MARKER } from "./messages";
@@ -38,6 +40,7 @@ const CHAR_SPACE = 32;
 const CHAR_DOT = 46;
 const CHAR_HYPHEN = 45;
 const CHAR_ELLIPSIS = 0x2026;
+const CHAR_EQUALS = 61;
 
 const CHAR_UPPER_A = 65;
 const CHAR_UPPER_F = 70;
@@ -165,7 +168,11 @@ function scanRangeSeparator(line: string, index: number, end: number): number |
 			consumedSeparator = true;
 			continue;
 		}
-		if (code === CHAR_DOT && cursor + 1 < end && line.charCodeAt(cursor + 1) === CHAR_DOT) {
+		if (
+			code === CHAR_DOT &&
+			cursor + 1 < end &&
+			(line.charCodeAt(cursor + 1) === CHAR_DOT || line.charCodeAt(cursor + 1) === CHAR_EQUALS)
+		) {
 			cursor += 2;
 			consumedSeparator = true;
 			continue;
@@ -218,7 +225,7 @@ function scanKeyword(line: string, index: number, end: number, keyword: string):
 	const next = index + keyword.length;
 	if (next < end) {
 		const code = line.charCodeAt(next);
-		if (!isWhitespaceCode(code) && code !== CHAR_COLON) return null;
+		if (!isWhitespaceCode(code) && code !== CHAR_COLON && code !== CHAR_DOT) return null;
 	}
 	return next;
 }
@@ -229,7 +236,8 @@ function consumeOptionalColon(line: string, index: number, end: number): number
 }
 
 function scanInsertTarget(line: string, index: number, end: number): TargetScan | null {
-	const cursor = skipWhitespace(line, index, end);
+	if (index >= end || line.charCodeAt(index) !== CHAR_DOT) return null;
+	const cursor = skipWhitespace(line, index + 1, end);
 	const beforeEnd = scanKeyword(line, cursor, end, HL_INSERT_BEFORE);
 	if (beforeEnd !== null) {
 		const anchor = scanLineNumber(line, skipWhitespace(line, beforeEnd, end), end);
@@ -239,16 +247,6 @@ function scanInsertTarget(line: string, index: number, end: number): TargetScan
 	}
 	const afterEnd = scanKeyword(line, cursor, end, HL_INSERT_AFTER);
 	if (afterEnd !== null) {
-		// `insert after block N:` — resolve N to a tree-sitter block range at
-		// apply time and insert after its last line. Try the `block` sub-keyword
-		// before falling back to a literal `insert after N:` anchor.
-		const blockEnd = scanKeyword(line, skipWhitespace(line, afterEnd, end), end, HL_BLOCK_KEYWORD);
-		if (blockEnd !== null) {
-			const anchor = scanLineNumber(line, skipWhitespace(line, blockEnd, end), end);
-			if (anchor === null) return null;
-			const nextIndex = consumeOptionalColon(line, anchor.nextIndex, end);
-			return { target: { kind: "insert_after_block", anchor: { line: anchor.line } }, nextIndex };
-		}
 		const anchor = scanLineNumber(line, skipWhitespace(line, afterEnd, end), end);
 		if (anchor === null) return null;
 		const nextIndex = consumeOptionalColon(line, anchor.nextIndex, end);
@@ -263,20 +261,19 @@ function scanInsertTarget(line: string, index: number, end: number): TargetScan
 
 function scanHunkAnchor(line: string, start: number, end: number): TargetScan | null {
 	const cursor = skipWhitespace(line, start, end);
+
+	// `replace_block N:` — resolve N to a tree-sitter block range at apply time.
+	const replaceBlockEnd = scanKeyword(line, cursor, end, HL_REPLACE_BLOCK_KEYWORD);
+	if (replaceBlockEnd !== null) {
+		const anchor = scanLineNumber(line, skipWhitespace(line, replaceBlockEnd, end), end);
+		if (anchor === null) return null;
+		return {
+			target: { kind: "block", anchor: { line: anchor.line } },
+			nextIndex: consumeOptionalColon(line, anchor.nextIndex, end),
+		};
+	}
 	const replaceEnd = scanKeyword(line, cursor, end, HL_REPLACE_KEYWORD);
 	if (replaceEnd !== null) {
-		// `replace block N:` — resolve N to a tree-sitter block range at apply
-		// time. Try the `block` sub-keyword before falling back to a literal
-		// `replace N..M:` range.
-		const blockEnd = scanKeyword(line, skipWhitespace(line, replaceEnd, end), end, HL_BLOCK_KEYWORD);
-		if (blockEnd !== null) {
-			const anchor = scanLineNumber(line, skipWhitespace(line, blockEnd, end), end);
-			if (anchor === null) return null;
-			return {
-				target: { kind: "block", anchor: { line: anchor.line } },
-				nextIndex: consumeOptionalColon(line, anchor.nextIndex, end),
-			};
-		}
 		const range = scanHeaderRange(line, replaceEnd, end, true);
 		if (range === null) return null;
 		return {
@@ -284,25 +281,36 @@ function scanHunkAnchor(line: string, start: number, end: number): TargetScan |
 			nextIndex: consumeOptionalColon(line, range.nextIndex, end),
 		};
 	}
+	// `delete_block N` — resolve N to a tree-sitter block range at apply time
+	// and delete its whole span. Like `delete N.=M`, it takes no body and no
+	// trailing colon.
+	const deleteBlockEnd = scanKeyword(line, cursor, end, HL_DELETE_BLOCK_KEYWORD);
+	if (deleteBlockEnd !== null) {
+		const anchor = scanLineNumber(line, skipWhitespace(line, deleteBlockEnd, end), end);
+		if (anchor === null) return null;
+		const next = skipWhitespace(line, anchor.nextIndex, end);
+		if (next < end && line.charCodeAt(next) === CHAR_COLON) return null;
+		return { target: { kind: "delete_block", anchor: { line: anchor.line } }, nextIndex: next };
+	}
 	const deleteEnd = scanKeyword(line, cursor, end, HL_DELETE_KEYWORD);
 	if (deleteEnd !== null) {
-		// `delete block N` — resolve N to a tree-sitter block range at apply
-		// time and delete its whole span. Like `delete N..M`, it takes no body
-		// and no trailing colon.
-		const blockEnd = scanKeyword(line, skipWhitespace(line, deleteEnd, end), end, HL_BLOCK_KEYWORD);
-		if (blockEnd !== null) {
-			const anchor = scanLineNumber(line, skipWhitespace(line, blockEnd, end), end);
-			if (anchor === null) return null;
-			const next = skipWhitespace(line, anchor.nextIndex, end);
-			if (next < end && line.charCodeAt(next) === CHAR_COLON) return null;
-			return { target: { kind: "delete_block", anchor: { line: anchor.line } }, nextIndex: next };
-		}
 		const range = scanHeaderRange(line, deleteEnd, end, true);
 		if (range === null) return null;
 		const next = skipWhitespace(line, range.nextIndex, end);
 		if (next < end && line.charCodeAt(next) === CHAR_COLON) return null;
 		return { target: { kind: "delete", range: range.range }, nextIndex: next };
 	}
+	// `insert_after_block N:` — insert after the last line of the tree-sitter
+	// block at N.
+	const insertAfterBlockEnd = scanKeyword(line, cursor, end, HL_INSERT_AFTER_BLOCK_KEYWORD);
+	if (insertAfterBlockEnd !== null) {
+		const anchor = scanLineNumber(line, skipWhitespace(line, insertAfterBlockEnd, end), end);
+		if (anchor === null) return null;
+		return {
+			target: { kind: "insert_after_block", anchor: { line: anchor.line } },
+			nextIndex: consumeOptionalColon(line, anchor.nextIndex, end),
+		};
+	}
 	const insertEnd = scanKeyword(line, cursor, end, HL_INSERT_KEYWORD);
 	if (insertEnd !== null) return scanInsertTarget(line, insertEnd, end);
 	return null;

package/src/types.ts

@@ -32,7 +32,7 @@ export type Edit =
 			index: number;
 			mode?: "replacement";
 			/**
-			 * Present on inserts lowered from `insert after block N:`: the
+			 * Present on inserts lowered from `insert_after_block N:`: the
 			 * resolved block's first line. Lets the applier slide a body that
 			 * claims a depth inside the block back across the block's trailing
 			 * closer lines (never above this line).
@@ -42,13 +42,13 @@ export type Edit =
 	| { kind: "delete"; anchor: Anchor; lineNum: number; index: number; oldAssertion?: string }
 	| {
 			/**
-			 * Deferred block edit (`replace block N:` / `delete block N` /
-			 * `insert after block N:`). The exact line span is unknown at parse
+			 * Deferred block edit (`replace_block N:` / `delete_block N` /
+			 * `insert_after_block N:`). The exact line span is unknown at parse
 			 * time — it is computed by {@link resolveBlockEdits} once file text +
 			 * path (→ language) are available, then expanded into concrete edits:
-			 * a non-empty `payloads` without `mode` (from `replace block`) becomes
-			 * the same `replacement` inserts + deletes that `replace start..end:`
-			 * produces; an empty `payloads` (from `delete block`) becomes a pure
+			 * a non-empty `payloads` without `mode` (from `replace_block`) becomes
+			 * the same `replacement` inserts + deletes that `replace start.=end:`
+			 * produces; an empty `payloads` (from `delete_block`) becomes a pure
 			 * range deletion; `mode: "insert_after"` becomes plain `after_anchor`
 			 * inserts at the block's last line. `applyEdits` never sees this
 			 * variant.
@@ -70,7 +70,7 @@ export interface ApplyResult {
 	/** Diagnostic warnings collected by the parser, patcher, or recovery. */
 	warnings?: string[];
 	/**
-	 * Resolved spans for each `replace block`/`delete block` op in this apply,
+	 * Resolved spans for each `replace_block`/`delete_block` op in this apply,
 	 * in patch order. Present only when the apply matched the tagged content
 	 * (the common no-drift path), so the line numbers line up with what the
 	 * caller read. Absent when there were no block ops.
@@ -78,7 +78,7 @@ export interface ApplyResult {
 	blockResolutions?: BlockResolution[];
 }
 
-/** A parsed `[A..B]` line range. */
+/** A parsed `[A.=B]` line range. */
 export interface ParsedRange {
 	start: Anchor;
 	end: Anchor;
@@ -122,7 +122,7 @@ export interface CompactDiffOptions {
 }
 
 /**
- * Resolved 1-indexed inclusive line span of a `replace block N:` target.
+ * Resolved 1-indexed inclusive line span of a `replace_block N:` target.
  */
 export interface BlockSpan {
 	/** First line of the block (1-indexed, inclusive). */
@@ -132,9 +132,9 @@ export interface BlockSpan {
 }
 
 /**
- * One `replace block N:` / `delete block N` / `insert after block N:` anchor
+ * One `replace_block N:` / `delete_block N` / `insert_after_block N:` anchor
  * resolved to its concrete line span. Surfaced on {@link ApplyResult} so the
- * host can echo "block N → lines start..end" and let the model catch a wrong
+ * host can echo "block N → lines start.=end" and let the model catch a wrong
  * opener — e.g. a decorator or doc-comment that sits in a separate node
  * outside the resolved block.
  */
@@ -149,7 +149,7 @@ export interface BlockResolution {
 	op: "replace" | "delete" | "insert_after";
 }
 
-/** Request handed to a {@link BlockResolver} to resolve one `replace block N:` anchor. */
+/** Request handed to a {@link BlockResolver} to resolve one `replace_block N:` anchor. */
 export interface BlockResolverRequest {
 	/** Target file path (used to infer language by extension). */
 	path: string;
@@ -160,7 +160,7 @@ export interface BlockResolverRequest {
 }
 
 /**
- * Resolves a `replace block N:` anchor to the line span of the syntactic block
+ * Resolves a `replace_block N:` anchor to the line span of the syntactic block
  * that begins on line N. Returns `null` when no block can be resolved
  * (unrecognized language, blank/out-of-range line, no node begins there, or the
  * resolved subtree has a syntax error). Pure seam: the hashline core declares