@oh-my-pi/pi-coding-agent 14.4.0 → 14.4.1

package/CHANGELOG.md

@@ -1,19 +1,33 @@
 # Changelog
 
 ## [Unreleased]
+
+## [14.4.1] - 2026-04-26
 ### Breaking Changes
 
 - Replaced the legacy `gh_repo_view`, `gh_issue_view`, `gh_pr_view`, `gh_pr_diff`, `gh_pr_checkout`, `gh_pr_push`, `gh_run_watch`, `gh_search_issues`, and `gh_search_prs` tool names with only `github`, which requires updating existing callers that invoked the old `gh_*` tools
 
 ### Added
 
+- Added a `sed` verb to the `atom` edit tool for line-local substitutions using sed-style syntax (`s/pattern/replacement/`) with `g`, `i`, and `F` flags and model-tolerant delimiter choices
 - Added the unified `github` tool with op-based dispatch for repository, issue, pull request, search, checkout, push, and Actions watch workflows
 - Added `op` routing so callers can select `repo_view`, `issue_view`, `pr_view`, `pr_diff`, `pr_checkout`, `pr_push`, `search_issues`, `search_prs`, or `run_watch` through a single tool entry point
 
 ### Changed
 
+- Changed hashline-based read and match output formatting to use `LINE+ID|content` as the anchor/content separator, and updated match/context markers to `>` for matches and `:` for context
 - Updated GitHub CLI render output to show `GitHub <op>` for tool calls dispatched through `github` operations
 
+### Removed
+
+- Removed the built-in `taplo` Language Server entry from default LSP settings, so TOML files no longer have default TOML server startup
+
+### Fixed
+
+- Fixed `atom` `loc` parsing so path-qualified anchors like `path:263ti| ...` and single-anchor locs containing hyphens no longer mis-parse as ranges
+- Fixed hashline anchor handling in `atom` edits so a provided content hint after the anchor (`|` or `:` suffix) can rebond a stale hash to the intended line
+- Fixed `atom` `sed` execution to tolerate common model-emitted forms such as `/pat/rep/`, and to apply safe literal fallbacks for regex failures or metacharacter-heavy patterns while still erroring when no match is possible
+
 ## [14.4.0] - 2026-04-26
 
 ### Breaking Changes

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.4.0",
+	"version": "14.4.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.20.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.4.0",
-		"@oh-my-pi/pi-agent-core": "14.4.0",
-		"@oh-my-pi/pi-ai": "14.4.0",
-		"@oh-my-pi/pi-natives": "14.4.0",
-		"@oh-my-pi/pi-tui": "14.4.0",
-		"@oh-my-pi/pi-utils": "14.4.0",
+		"@oh-my-pi/omp-stats": "14.4.1",
+		"@oh-my-pi/pi-agent-core": "14.4.1",
+		"@oh-my-pi/pi-ai": "14.4.1",
+		"@oh-my-pi/pi-natives": "14.4.1",
+		"@oh-my-pi/pi-tui": "14.4.1",
+		"@oh-my-pi/pi-utils": "14.4.1",
 		"@sinclair/typebox": "^0.34.49",
 		"@xterm/headless": "^6.0.0",
 		"ajv": "^8.20.0",

package/src/config/prompt-templates.ts

@@ -55,7 +55,7 @@ prompt.registerHelper("href", (lineNum: unknown, content: unknown): string => {
 
 /**
  * {{hline lineNum "content"}} — format a full read-style line with prefix.
- * Returns `"lineNumBIGRAM:content"` (colon between anchor and content).
+ * Returns `"lineNumBIGRAM|content"` (pipe between anchor and content).
  */
 prompt.registerHelper("hline", (lineNum: unknown, content: unknown): string => {
 	const { ref, text } = formatHashlineRef(lineNum, content);

package/src/config/settings-schema.ts

@@ -1021,7 +1021,7 @@ export const SETTINGS_SCHEMA = {
 		ui: {
 			tab: "editing",
 			label: "Hash Lines",
-			description: "Include line hashes in read output for hashline edit mode (LINE+ID\\tcontent)",
+			description: "Include line hashes in read output for hashline edit mode (LINE+ID|content)",
 		},
 	},
 

package/src/edit/line-hash.ts

@@ -726,7 +726,7 @@ export const CHUNK_BIGRAMS_COUNT = CHUNK_BIGRAMS.length;
  */
 export const HASHLINE_BIGRAM_RE_SRC = `(?:${HASHLINE_BIGRAMS.join("|")})`;
 
-export const HASHLINE_CONTENT_SEPARATOR = ":";
+export const HASHLINE_CONTENT_SEPARATOR = "|";
 
 const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
 
@@ -756,11 +756,19 @@ export function formatLineHash(line: number, lines: string): string {
 	return `${line}${computeLineHash(line, lines)}`;
 }
 
+/**
+ * Formats a single line with a hashline anchor.
+ * Returns `LINE+ID|TEXT` (e.g., `42nd|function hi() {\n2er|  return;\n3in|}`)
+ */
+export function formatHashLine(lineNumber: number, line: string): string {
+	return `${lineNumber}${computeLineHash(lineNumber, line)}${HASHLINE_CONTENT_SEPARATOR}${line}`;
+}
+
 /**
  * Format file text with hashline prefixes for display.
  *
- * Each line becomes `LINE+ID:TEXT` where LINENUM is 1-indexed.
- * No padding on line numbers; colon separator between anchor and content.
+ * Each line becomes `LINE+ID|TEXT` where LINENUM is 1-indexed.
+ * No padding on line numbers; pipe separator between anchor and content.
  *
  * @param text - Raw file text string
  * @param startLine - First line number (1-indexed, defaults to 1)
@@ -769,15 +777,10 @@ export function formatLineHash(line: number, lines: string): string {
  * @example
  * ```
  * formatHashLines("function hi() {\n  return;\n}")
- * // "1th:function hi() {\n2er:  return;\n3in:}"
+ * // "1th|function hi() {\n2er|  return;\n3in|}"
  * ```
  */
 export function formatHashLines(text: string, startLine = 1): string {
 	const lines = text.split("\n");
-	return lines
-		.map((line, i) => {
-			const num = startLine + i;
-			return `${formatLineHash(num, line)}${HASHLINE_CONTENT_SEPARATOR}${line}`;
-		})
-		.join("\n");
+	return lines.map((line, i) => formatHashLine(startLine + i, line)).join("\n");
 }

package/src/edit/modes/atom.ts

@@ -29,7 +29,7 @@ import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
 import { outputMeta } from "../../tools/output-meta";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
 import { generateDiffString } from "../diff";
-import { computeLineHash } from "../line-hash";
+import { computeLineHash, HASHLINE_BIGRAM_RE_SRC, HASHLINE_CONTENT_SEPARATOR } from "../line-hash";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "../normalize";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
 import {
@@ -65,6 +65,12 @@ export const atomEditSchema = Type.Object(
 		set: Type.Optional(textSchema),
 		pre: Type.Optional(textSchema),
 		post: Type.Optional(textSchema),
+		sed: Type.Optional(
+			Type.String({
+				description: "sed-style substitution applied to the anchored line",
+				examples: ["s/foo/bar/", "s|api|API|g", "s/<pat>/<rep>/F"],
+			}),
+		),
 	},
 	{ additionalProperties: false },
 );
@@ -90,16 +96,40 @@ export type AtomEdit =
 	| { op: "post"; pos: Anchor; lines: string[] }
 	| { op: "del"; pos: Anchor }
 	| { op: "append_file"; lines: string[] }
-	| { op: "prepend_file"; lines: string[] };
+	| { op: "prepend_file"; lines: string[] }
+	| { op: "sed"; pos: Anchor; spec: SedSpec; expression: string };
+
+export interface SedSpec {
+	pattern: string;
+	replacement: string;
+	global: boolean;
+	ignoreCase: boolean;
+	literal: boolean;
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Param guards
 // ═══════════════════════════════════════════════════════════════════════════
 
-const ATOM_VERB_KEYS = ["set", "pre", "post"] as const;
+const ATOM_VERB_KEYS = ["set", "pre", "post", "sed"] as const;
 type AtomOptionalKey = "path" | "loc" | (typeof ATOM_VERB_KEYS)[number];
 const ATOM_OPTIONAL_KEYS = ["path", "loc", ...ATOM_VERB_KEYS] as const satisfies readonly AtomOptionalKey[];
 
+// Matches just the LINE+BIGRAM prefix of an anchor reference. Used to detect
+// optional `|content` suffixes (e.g. `82zu|  for (...)`) so the suffix can be
+// captured as a content hint for anchor disambiguation.
+const ANCHOR_PREFIX_RE = new RegExp(`^\\s*[>+-]*\\s*\\d+${HASHLINE_BIGRAM_RE_SRC}`);
+
+// Splits `path:loc` references where the right side starts with a valid anchor
+// (single `\d+<bigram>` or `<anchor>-<anchor>` range, optionally followed by a
+// content suffix using `|` or `:`). The non-greedy `(.+?)` picks the leftmost
+// colon whose RHS is a real anchor, so colons inside the loc's content suffix
+// (TS type annotations, etc.) don't break the split. Drive-letter prefixes like
+// `C:\path\a.ts:160sr` still resolve correctly because the first colon's RHS
+// fails the anchor pattern.
+const ANCHOR_TAG_RE_SRC = `\\s*[>+-]*\\s*\\d+${HASHLINE_BIGRAM_RE_SRC}`;
+const PATH_LOC_SPLIT_RE = new RegExp(`^(.+?):(${ANCHOR_TAG_RE_SRC}(?:-${ANCHOR_TAG_RE_SRC})?(?:[|:].*)?)$`);
+
 function stripNullAtomFields(edit: AtomToolEdit): AtomToolEdit {
 	let next: Record<string, unknown> | undefined;
 	const fields = edit as Record<string, unknown>;
@@ -122,7 +152,7 @@ type ParsedAtomLoc = { kind: "anchor"; pos: Anchor } | { kind: "bof" } | { kind:
  *
  * Tolerant: on a malformed reference we still try to extract a 1-indexed line
  * number from the leading digits so the validator can surface the *correct*
- * `LINEHASH:content` for the user. The bogus hash is preserved in the returned
+ * `LINEHASH|content` for the user. The bogus hash is preserved in the returned
  * anchor so the validator emits a content-rich mismatch error.
  *
  * If we cannot recover even a line number, throw a usage-style error with the
@@ -158,16 +188,6 @@ function tryParseAtomTag(raw: string): Anchor | undefined {
 	}
 }
 
-function isLocSelector(raw: string): boolean {
-	if (raw === "^" || raw === "$") return true;
-	const dash = raw.indexOf("-");
-	if (dash === -1) return tryParseAtomTag(raw) !== undefined;
-	const left = raw.slice(0, dash);
-	const right = raw.slice(dash + 1);
-	if (left.length === 0 || right.length === 0) return false;
-	return tryParseAtomTag(left) !== undefined && tryParseAtomTag(right) !== undefined;
-}
-
 function resolveAtomEntryPath(
 	edit: AtomToolEdit,
 	topLevelPath: string | undefined,
@@ -177,13 +197,10 @@ function resolveAtomEntryPath(
 	let loc = entry.loc;
 	let pathOverride: string | undefined;
 	if (typeof loc === "string") {
-		const colon = loc.lastIndexOf(":");
-		if (colon > 0) {
-			const maybeSelector = loc.slice(colon + 1);
-			if (isLocSelector(maybeSelector)) {
-				pathOverride = loc.slice(0, colon);
-				loc = maybeSelector;
-			}
+		const split = loc.match(PATH_LOC_SPLIT_RE);
+		if (split) {
+			pathOverride = split[1];
+			loc = split[2]!;
 		}
 	}
 	const path = pathOverride || entry.path || topLevelPath;
@@ -205,12 +222,154 @@ export function resolveAtomEntryPaths(
 function parseLoc(raw: string, editIndex: number): ParsedAtomLoc {
 	if (raw === "^") return { kind: "bof" };
 	if (raw === "$") return { kind: "eof" };
-	if (raw.includes("-")) {
+	// Detect range syntax explicitly: "<anchor>-<anchor>". A bare `-` inside the
+	// loc (e.g. line content like `i--`) should not trigger the range error.
+	const dash = raw.indexOf("-");
+	if (dash > 0) {
+		const left = raw.slice(0, dash);
+		const right = raw.slice(dash + 1);
+		if (tryParseAtomTag(left) !== undefined && tryParseAtomTag(right) !== undefined) {
+			throw new Error(
+				`Edit ${editIndex}: atom loc does not support line ranges. Use a single anchor like "160sr", "^", or "$".`,
+			);
+		}
+	}
+	const pos = parseAnchor(raw, "loc");
+	// Capture an optional content suffix after the anchor: `82zu|  for (...)`.
+	// The suffix acts as a hint for anchor disambiguation when the model's hash
+	// is wrong but the content reveals the intended line.
+	const hint = extractAnchorContentHint(raw);
+	if (hint !== undefined) {
+		pos.contentHint = hint;
+	}
+	return { kind: "anchor", pos };
+}
+
+function extractAnchorContentHint(raw: string): string | undefined {
+	const match = raw.match(ANCHOR_PREFIX_RE);
+	if (!match) return undefined;
+	const rest = raw.slice(match[0].length);
+	// Accept either the canonical `|` (HASHLINE_CONTENT_SEPARATOR) or the legacy
+	// `:` separator. Models trained on older docs still emit `82zu:  for (...)`.
+	const sep = rest[0];
+	if (sep !== HASHLINE_CONTENT_SEPARATOR && sep !== ":") return undefined;
+	const hint = rest.slice(1);
+	if (hint.trim().length === 0) return undefined;
+	return hint;
+}
+
+function parseSedExpression(raw: string, editIndex: number): SedSpec {
+	if (typeof raw !== "string" || raw.length < 3) {
 		throw new Error(
-			`Edit ${editIndex}: atom loc does not support line ranges. Use a single anchor like "160sr", "^", or "$".`,
+			`Edit ${editIndex}: sed expression must start with "s" followed by a delimiter, e.g. "s/foo/bar/".`,
 		);
 	}
-	return { kind: "anchor", pos: parseAnchor(raw, "loc") };
+	// Tolerate a missing leading `s`: models occasionally emit `/foo/bar/` directly.
+	// As long as the first character is a valid delimiter, treat the expression as
+	// if `s` was prepended.
+	let bodyStart = 0;
+	if (raw[0] === "s") {
+		bodyStart = 1;
+	}
+	const delim = raw[bodyStart]!;
+	if (/[\sA-Za-z0-9\\]/.test(delim)) {
+		throw new Error(
+			`Edit ${editIndex}: sed delimiter must be a non-alphanumeric, non-whitespace, non-backslash character (got ${JSON.stringify(delim)}).`,
+		);
+	}
+	const parts: [string, string] = ["", ""];
+	let bucket: 0 | 1 = 0;
+	let i = bodyStart + 1;
+	while (i < raw.length) {
+		const c = raw[i]!;
+		if (c === "\\" && raw[i + 1] === delim) {
+			parts[bucket] += delim;
+			i += 2;
+			continue;
+		}
+		if (c === delim) {
+			if (bucket === 0) {
+				bucket = 1;
+				i += 1;
+				continue;
+			}
+			i += 1;
+			break;
+		}
+		parts[bucket] += c;
+		i += 1;
+	}
+	if (bucket !== 1) {
+		throw new Error(
+			`Edit ${editIndex}: malformed sed expression ${JSON.stringify(raw)}. Expected three ${JSON.stringify(delim)} separators.`,
+		);
+	}
+	const flagsStr = raw.slice(i);
+	let global = false;
+	let ignoreCase = false;
+	let literal = false;
+	for (const f of flagsStr) {
+		if (f === "g") global = true;
+		else if (f === "i") ignoreCase = true;
+		else if (f === "F") literal = true;
+		else {
+			throw new Error(
+				`Edit ${editIndex}: unknown sed flag ${JSON.stringify(f)}. Supported flags: g (all), i (case-insensitive), F (literal).`,
+			);
+		}
+	}
+	if (parts[0] === "") {
+		throw new Error(`Edit ${editIndex}: sed expression has empty pattern.`);
+	}
+	return { pattern: parts[0], replacement: parts[1], global, ignoreCase, literal };
+}
+
+function applyLiteralSed(currentLine: string, spec: SedSpec): { result: string; matched: boolean } {
+	const idx = currentLine.indexOf(spec.pattern);
+	if (idx === -1) return { result: currentLine, matched: false };
+	if (spec.global) {
+		return { result: currentLine.split(spec.pattern).join(spec.replacement), matched: true };
+	}
+	return {
+		result: currentLine.slice(0, idx) + spec.replacement + currentLine.slice(idx + spec.pattern.length),
+		matched: true,
+	};
+}
+
+function applySedToLine(
+	currentLine: string,
+	spec: SedSpec,
+): { result: string; matched: boolean; error?: string; literalFallback?: boolean } {
+	if (spec.literal) {
+		return applyLiteralSed(currentLine, spec);
+	}
+	let flags = "";
+	if (spec.global) flags += "g";
+	if (spec.ignoreCase) flags += "i";
+	let re: RegExp | undefined;
+	let compileError: string | undefined;
+	try {
+		re = new RegExp(spec.pattern, flags);
+	} catch (e) {
+		compileError = (e as Error).message;
+	}
+	if (re?.test(currentLine)) {
+		re.lastIndex = 0;
+		return { result: currentLine.replace(re, spec.replacement), matched: true };
+	}
+	// Fall back to literal substring match. Models frequently send sed patterns
+	// containing unescaped regex metacharacters (parentheses, `?`, `.`) that they
+	// intend as literal code. Trying a literal match before reporting failure
+	// recovers the obvious intent without changing semantics for patterns that
+	// already match as regex.
+	const literal = applyLiteralSed(currentLine, spec);
+	if (literal.matched) {
+		return { ...literal, literalFallback: true };
+	}
+	if (compileError !== undefined) {
+		return { result: currentLine, matched: false, error: compileError };
+	}
+	return { result: currentLine, matched: false };
 }
 
 function classifyAtomEdit(edit: AtomToolEdit): string {
@@ -235,7 +394,7 @@ function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
 	const resolved: AtomEdit[] = [];
 
 	if (loc.kind === "bof") {
-		if (entry.set !== undefined || entry.post !== undefined) {
+		if (entry.set !== undefined || entry.post !== undefined || entry.sed !== undefined) {
 			throw new Error(`Edit ${editIndex}: loc "^" only supports pre.`);
 		}
 		if (entry.pre !== undefined) {
@@ -245,7 +404,7 @@ function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
 	}
 
 	if (loc.kind === "eof") {
-		if (entry.set !== undefined || entry.pre !== undefined) {
+		if (entry.set !== undefined || entry.pre !== undefined || entry.sed !== undefined) {
 			throw new Error(`Edit ${editIndex}: loc "$" only supports post.`);
 		}
 		if (entry.post !== undefined) {
@@ -259,7 +418,13 @@ function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
 	}
 	if (entry.set !== undefined) {
 		if (Array.isArray(entry.set) && entry.set.length === 0) {
-			resolved.push({ op: "del", pos: loc.pos });
+			// Models often default `set: []` alongside other verbs (notably `sed`).
+			// Treating that combination as an explicit `del` produces a confusing
+			// `Conflicting ops` error. When another mutating verb is present, drop
+			// the empty `set` instead of treating it as a deletion.
+			if (entry.sed === undefined) {
+				resolved.push({ op: "del", pos: loc.pos });
+			}
 		} else {
 			resolved.push({ op: "set", pos: loc.pos, lines: hashlineParseText(entry.set) });
 		}
@@ -267,6 +432,16 @@ function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
 	if (entry.post !== undefined) {
 		resolved.push({ op: "post", pos: loc.pos, lines: hashlineParseText(entry.post) });
 	}
+	if (entry.sed !== undefined) {
+		const setIsExplicitReplacement = Array.isArray(entry.set) && entry.set.length > 0;
+		// Models often duplicate intent by sending both an explicit `set` and a
+		// matching `sed`. The explicit replacement wins; the redundant `sed` would
+		// otherwise trigger a confusing `Conflicting ops` rejection.
+		if (!setIsExplicitReplacement) {
+			const spec = parseSedExpression(entry.sed, editIndex);
+			resolved.push({ op: "sed", pos: loc.pos, spec, expression: entry.sed });
+		}
+	}
 	return resolved;
 }
 
@@ -280,6 +455,7 @@ function* getAtomAnchors(edit: AtomEdit): Iterable<Anchor> {
 		case "pre":
 		case "post":
 		case "del":
+		case "sed":
 			yield edit.pos;
 			return;
 		default:
@@ -287,6 +463,29 @@ function* getAtomAnchors(edit: AtomEdit): Iterable<Anchor> {
 	}
 }
 
+/**
+ * Search for a line near `anchor.line` whose trimmed content equals the
+ * anchor's content hint. Returns the closest match (preferring lines below the
+ * requested anchor on ties) or `null` when no line matches. Strict equality on
+ * trimmed content keeps this conservative \u2014 we only retarget when there is no
+ * ambiguity about the model's intent.
+ */
+function findLineByContentHint(anchor: Anchor, fileLines: string[]): number | null {
+	const hint = anchor.contentHint?.trim();
+	if (!hint) return null;
+	const lo = Math.max(1, anchor.line - ANCHOR_REBASE_WINDOW);
+	const hi = Math.min(fileLines.length, anchor.line + ANCHOR_REBASE_WINDOW);
+	let best: { line: number; distance: number } | null = null;
+	for (let line = lo; line <= hi; line++) {
+		if (fileLines[line - 1].trim() !== hint) continue;
+		const distance = Math.abs(line - anchor.line);
+		if (best === null || distance < best.distance) {
+			best = { line, distance };
+		}
+	}
+	return best?.line ?? null;
+}
+
 function validateAtomAnchors(edits: AtomEdit[], fileLines: string[], warnings: string[]): HashMismatch[] {
 	const mismatches: HashMismatch[] = [];
 	for (const edit of edits) {
@@ -296,6 +495,22 @@ function validateAtomAnchors(edits: AtomEdit[], fileLines: string[], warnings: s
 			}
 			const actualHash = computeLineHash(anchor.line, fileLines[anchor.line - 1]);
 			if (actualHash === anchor.hash) continue;
+			// When the model supplied a content hint after the anchor (e.g.
+			// `82zu|  for (...)`), prefer rebasing to the line that actually matches
+			// that content. This avoids false positives from hash-only rebasing where
+			// a coincidentally matching hash on a nearby line silently retargets the
+			// edit to the wrong line.
+			const hinted = findLineByContentHint(anchor, fileLines);
+			if (hinted !== null) {
+				const original = `${anchor.line}${anchor.hash}`;
+				const hintedHash = computeLineHash(hinted, fileLines[hinted - 1]);
+				anchor.line = hinted;
+				anchor.hash = hintedHash;
+				warnings.push(
+					`Auto-rebased anchor ${original} → ${hinted}${hintedHash} (matched the content hint provided after the anchor).`,
+				);
+				continue;
+			}
 			const rebased = tryRebaseAnchor(anchor, fileLines);
 			if (rebased !== null) {
 				const original = `${anchor.line}${anchor.hash}`;
@@ -316,12 +531,12 @@ function validateNoConflictingAnchorOps(edits: AtomEdit[]): void {
 	// `pre`/`post` (insert ops) may coexist with them — they don't mutate the anchor line.
 	const mutatingPerLine = new Map<number, string>();
 	for (const edit of edits) {
-		if (edit.op !== "set" && edit.op !== "del") continue;
+		if (edit.op !== "set" && edit.op !== "del" && edit.op !== "sed") continue;
 		const existing = mutatingPerLine.get(edit.pos.line);
 		if (existing) {
 			throw new Error(
 				`Conflicting ops on anchor line ${edit.pos.line}: \`${existing}\` and \`${edit.op}\`. ` +
-					`At most one of set/del is allowed per anchor.`,
+					`At most one of set/del/sed is allowed per anchor.`,
 			);
 		}
 		mutatingPerLine.set(edit.pos.line, edit.op);
@@ -457,6 +672,26 @@ export function applyAtomEdits(
 					replacementSet = true;
 					anchorMutated = true;
 					break;
+				case "sed": {
+					const { result, matched, error, literalFallback } = applySedToLine(currentLine, edit.spec);
+					if (error) {
+						throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} failed to compile: ${error}`);
+					}
+					if (!matched) {
+						throw new Error(
+							`Edit sed expression ${JSON.stringify(edit.expression)} did not match line ${edit.pos.line}: ${JSON.stringify(currentLine)}`,
+						);
+					}
+					if (literalFallback) {
+						warnings.push(
+							`sed expression ${JSON.stringify(edit.expression)} did not match as a regex on line ${edit.pos.line}; applied literal substring substitution instead. Use the \`F\` flag (e.g. \`s/.../.../F\`) for literal patterns or escape regex metacharacters.`,
+						);
+					}
+					replacement = [result];
+					replacementSet = true;
+					anchorMutated = true;
+					break;
+				}
 			}
 		}