@oh-my-pi/pi-coding-agent 15.2.3 → 15.3.0

package/src/config/settings-schema.ts

@@ -81,7 +81,8 @@ export type StatusLineSegmentId =
 	| "hostname"
 	| "cache_read"
 	| "cache_write"
-	| "session_name";
+	| "session_name"
+	| "usage";
 
 /** Submenu choice metadata. */
 export type SubmenuOption<V extends string = string> = {
@@ -836,6 +837,16 @@ export const SETTINGS_SCHEMA = {
 	},
 
 	"retry.baseDelayMs": { type: "number", default: 2000 },
+	"retry.maxDelayMs": {
+		type: "number",
+		default: 5 * 60 * 1000,
+		ui: {
+			tab: "model",
+			label: "Max Retry Delay",
+			description:
+				"Maximum wait between retries, in ms. When the provider asks us to wait longer than this and no credential or model fallback succeeds, the request fails fast instead of sleeping (e.g. 3-hour Anthropic rate-limit windows).",
+		},
+	},
 	"retry.fallbackChains": { type: "record", default: {} as Record<string, string[]> },
 	"retry.fallbackRevertPolicy": {
 		type: "enum",
@@ -2612,6 +2623,22 @@ export const SETTINGS_SCHEMA = {
 			description: "Use Parallel extract API for URL fetching when credentials are available",
 		},
 	},
+	"provider.appendOnlyContext": {
+		type: "enum",
+		values: ["auto", "on", "off"] as const,
+		default: "auto",
+		ui: {
+			tab: "providers",
+			label: "Append-Only Context",
+			description:
+				"Cache system prompt + tool specs and keep an append-only message log so provider prefix caches (DeepSeek, Anthropic) hit at maximum rate. Auto enables for DeepSeek.",
+			options: [
+				{ value: "auto", label: "Auto", description: "Enable for DeepSeek (recommended)" },
+				{ value: "on", label: "On", description: "Always enable append-only context" },
+				{ value: "off", label: "Off", description: "Disable append-only context" },
+			],
+		},
+	},
 
 	// Exa
 	"exa.enabled": {
@@ -2843,6 +2870,7 @@ export interface RetrySettings {
 	enabled: boolean;
 	maxRetries: number;
 	baseDelayMs: number;
+	maxDelayMs: number;
 }
 
 export interface MemoriesSettings {

package/src/config/settings.ts

@@ -856,7 +856,26 @@ const SETTING_HOOKS: Partial<Record<SettingPath, SettingHook<any>>> = {
 			setDefaultTabWidth(value);
 		}
 	},
+	"provider.appendOnlyContext": value => {
+		if (typeof value === "string") {
+			for (const cb of appendOnlyModeCallbacks) cb(value);
+		}
+	},
 };
+/** Callbacks invoked when `provider.appendOnlyContext` changes at runtime. */
+const appendOnlyModeCallbacks = new Set<(value: string) => void>();
+
+/**
+ * Subscribe to append-only mode setting changes.
+ * Returns an unsubscribe function. Multiple sessions (main + subagents)
+ * can register independently without overwriting each other.
+ */
+export function onAppendOnlyModeChanged(cb: (value: string) => void): () => void {
+	appendOnlyModeCallbacks.add(cb);
+	return () => {
+		appendOnlyModeCallbacks.delete(cb);
+	};
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Global Singleton

package/src/discovery/helpers.ts

@@ -211,6 +211,7 @@ export interface ParsedAgentFields {
 	model?: string[];
 	output?: unknown;
 	thinkingLevel?: ThinkingLevel;
+	autoloadSkills?: string[];
 	blocking?: boolean;
 }
 
@@ -264,7 +265,10 @@ export function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAg
 	const thinkingLevel = parseThinkingLevel(rawThinkingLevel);
 	const model = parseModelList(frontmatter.model);
 	const blocking = parseBoolean(frontmatter.blocking);
-	return { name, description, tools, spawns, model, output, thinkingLevel, blocking };
+	const autoloadSkills = parseArrayOrCSV(frontmatter.autoloadSkills)
+		?.map(s => s.trim())
+		.filter(Boolean);
+	return { name, description, tools, spawns, model, output, thinkingLevel, blocking, autoloadSkills };
 }
 
 async function globIf(

package/src/edit/index.ts

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

package/src/edit/renderer.ts

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

package/src/edit/streaming.ts

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

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -98,7 +98,16 @@ function rewriteLegacyPiImports(source: string): string {
 				return match;
 			}
 
-			return `${prefix}${toImportSpecifier(getResolvedSpecifier(remappedSpecifier))}${suffix}`;
+			try {
+				return `${prefix}${toImportSpecifier(getResolvedSpecifier(remappedSpecifier))}${suffix}`;
+			} catch {
+				// Resolution failed — typically in compiled binary mode where
+				// Bun.resolveSync cannot walk up from /$bunfs/root to find the
+				// bundled node_modules. Return the original specifier unchanged so
+				// rewriteBareImportsForLegacyExtension can resolve it against the
+				// plugin's own installed peer deps instead.
+				return match;
+			}
 		},
 	);
 }
@@ -232,15 +241,28 @@ function getLoader(path: string): "js" | "jsx" | "ts" | "tsx" {
 	return "js";
 }
 
-function resolveLegacyPiSpecifier(args: { path: string }): { path: string } | undefined {
+function resolveLegacyPiSpecifier(args: { path: string; importer: string }): { path: string } | undefined {
 	const remappedSpecifier = remapLegacyPiSpecifier(args.path);
 	if (!remappedSpecifier) {
 		return undefined;
 	}
 
-	return {
-		path: getResolvedSpecifier(remappedSpecifier),
-	};
+	// Primary: resolve the canonical @oh-my-pi/* specifier from the host binary
+	// location. Works in dev mode and in source-link installs.
+	try {
+		return { path: getResolvedSpecifier(remappedSpecifier) };
+	} catch {
+		// Fallback for compiled binary mode: the bundled packages live inside
+		// /$bunfs/root and aren't reachable by filesystem resolution. Try the
+		// original (pre-remap) specifier against the importing file's directory,
+		// which resolves to the plugin's installed peer dep.
+		const importerDir = path.dirname(args.importer);
+		try {
+			return { path: Bun.resolveSync(args.path, importerDir) };
+		} catch {
+			return undefined;
+		}
+	}
 }
 
 function resolveTypeBoxSpecifier(): { path: string } {

package/src/goals/runtime.ts

@@ -373,6 +373,21 @@ export class GoalRuntime {
 		await this.#withAccounting(() => this.#flushUsageLocked(steering, currentUsage));
 	}
 
+	#createGoalState(objective: string, tokenBudget: number | undefined): GoalModeState {
+		const now = this.#now();
+		const goal: Goal = {
+			id: String(Snowflake.next()),
+			objective,
+			status: "active",
+			tokenBudget,
+			tokensUsed: 0,
+			timeUsedSeconds: 0,
+			createdAt: now,
+			updatedAt: now,
+		};
+		return { enabled: true, mode: "active", goal };
+	}
+
 	async createGoal(input: { objective: string; tokenBudget?: number }): Promise<GoalModeState> {
 		const objective = input.objective.trim();
 		if (!objective) throw new Error("objective is required when op=create");
@@ -382,20 +397,27 @@ export class GoalRuntime {
 			if (existing?.goal && existing.goal.status !== "dropped" && existing.goal.status !== "complete") {
 				throw new Error("cannot create a new goal because this session already has a goal");
 			}
-			const now = this.#now();
-			const goal: Goal = {
-				id: String(Snowflake.next()),
-				objective,
-				status: "active",
-				tokenBudget: input.tokenBudget,
-				tokensUsed: 0,
-				timeUsedSeconds: 0,
-				createdAt: now,
-				updatedAt: now,
-			};
-			const state: GoalModeState = { enabled: true, mode: "active", goal };
+			const state = this.#createGoalState(objective, input.tokenBudget);
 			this.#budgetReportedFor = undefined;
-			this.#markActiveAccounting(goal);
+			this.#markActiveAccounting(state.goal);
+			await this.#commitState(state, { persist: "goal" });
+			return state;
+		});
+	}
+
+	async replaceGoal(input: { objective: string; tokenBudget?: number }): Promise<GoalModeState> {
+		const objective = input.objective.trim();
+		if (!objective) throw new Error("objective is required when op=replace");
+		validateTokenBudget(input.tokenBudget);
+		return await this.#withAccounting(async () => {
+			const existing = this.#host.getState();
+			if (!existing?.enabled || !isAccountingStatus(existing.goal)) {
+				throw new Error("cannot replace goal because no goal is active");
+			}
+			await this.#flushUsageLocked("suppressed");
+			const state = this.#createGoalState(objective, input.tokenBudget);
+			this.#budgetReportedFor = undefined;
+			this.#markActiveAccounting(state.goal);
 			await this.#commitState(state, { persist: "goal" });
 			return state;
 		});

package/src/hashline/constants.ts

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

package/src/hashline/diff.ts

@@ -30,7 +30,7 @@ export async function computeHashlineSectionDiff(
 		const rawContent = await readHashlineFileText(Bun.file(absolutePath), absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		const result = applyHashlineEdits(normalized, parseHashline(section.diff, { path: section.path }), options);
+		const result = applyHashlineEdits(normalized, parseHashline(section.diff), options);
 		if (normalized === result.lines) return { error: `No changes would be made to ${section.path}.` };
 		return generateDiffString(normalized, result.lines);
 	} catch (err) {

package/src/hashline/execute.ts

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

package/src/hashline/grammar.lark

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

package/src/hashline/hash.ts

@@ -75,7 +75,13 @@ export function describeAnchorExamples(linePrefix = ""): string {
  * pass through unchanged.
  */
 export function resolveHashlineGrammarPlaceholders(grammar: string): string {
-	return grammar.replaceAll("$HFMT$", "[a-z]{2}").replaceAll("$HSEP$", JSON.stringify(HL_EDIT_SEP));
+	return grammar
+		.replaceAll("$HFMT$", "[a-z]{2}")
+		.replaceAll("$HOP_INSERT_BEFORE$", HL_OP_INSERT_BEFORE)
+		.replaceAll("$HOP_INSERT_AFTER$", HL_OP_INSERT_AFTER)
+		.replaceAll("$HOP_REPLACE$", HL_OP_REPLACE)
+		.replaceAll("$HOP_CHARS$", HL_OP_CHARS)
+		.replaceAll("$HFILE$", HL_FILE_PREFIX);
 }
 
 /** @deprecated Use {@link resolveHashlineGrammarPlaceholders}. */
@@ -84,51 +90,23 @@ export const resolveLarkLidPlaceholders = resolveHashlineGrammarPlaceholders;
 const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 /**
- * Single source of truth for the hashline edit payload separator. This is the
- * configured separator that starts inserted/replacement payload lines in
- * hashline edit input (`<separator>TEXT`) and separates inline modify ops from
- * their appended/prepended text.
+ * Hashline edit input markers. File section headers start with {@link HL_FILE_PREFIX};
+ * op lines start with a direction/action sigil: {@link HL_OP_INSERT_BEFORE},
+ * {@link HL_OP_INSERT_AFTER}, or {@link HL_OP_REPLACE}. Payload lines are
+ * verbatim file content and have no per-line marker.
  *
- * Override at runtime with the `PI_HL_SEP` env var (e.g.
- * `PI_HL_SEP=">"`, `PI_HL_SEP="\\"`). The value is read once at module load;
- * the edit grammar, prompt helper, and edit parser derive from it.
- *
- * Default is `~`, chosen empirically. Benchmark across 8 candidate separators
- * x 3 models (glm-4.7:nitro, gpt-5.4-nano, claude-sonnet-4-6), 24-48 runs per
- * cell, hashline variant, 12 sampled tasks per run:
- *
- *   sep | task ✓ | edit ✓ | patch fail      | tok/run
- *   ----|--------|--------|-----------------|--------
- *    +  | 70.8%  | 78.0%  | 27/125 (21.6%)  | 32,127
- *    ÷  | 70.7%  | 90.6%  | 22/211 (10.4%)  | 31,666
- *    ~  | 69.4%  | 94.9%  |  6/107 ( 5.6%)  | 30,529   <-- default
- *    >  | 69.2%  | 91.5%  | 21/219 ( 9.6%)  | 30,777
- *    :  | 66.7%  | 86.4%  | 20/126 (15.9%)  | 33,900
- *    |  | 65.9%  | 86.9%  | 20/127 (15.7%)  | 34,589
- *    \  | 65.5%  | 89.8%  | 16/124 (12.9%)  | 36,010
- *    %  | 63.9%  | 92.8%  | 11/125 ( 8.8%)  | 36,530
- *
- * `~` wins because:
- *   - highest edit-tool success rate (94.9%) of any tested separator
- *   - lowest patch-failure rate (5.6%) — model rarely emits a malformed payload
- *   - cheapest in tokens alongside `>` (no retry overhead from format collisions)
- *   - no line-leading role in any mainstream language, markdown, diff, regex,
- *     or shell, so payload lines are unambiguous to both the parser and models
- *   - task-success is statistically tied with `>` and `÷` (within run-to-run
- *     noise), so the edit-reliability win is free
- *
- * `+` and `÷` lead on raw task-success but at the cost of ~2-4x more patch
- * failures (the model retries until it lands a valid edit). `:`, `|`, `\`
- * collide with line-leading syntax (label/object-key, body separator, escape)
- * and degrade both edit reliability and intent-match.
+ * These constants are the single source of truth for the edit parser, grammar,
+ * renderer, and prompt.
  */
-export const HL_EDIT_SEP = (() => {
-	const sep = process.env.PI_HL_SEP?.trim();
-	return sep?.length === 1 ? sep : "~";
-})();
+export const HL_OP_INSERT_BEFORE = "«";
+export const HL_OP_INSERT_AFTER = "»";
+export const HL_OP_REPLACE = "≔";
+
+/** All hashline edit op sigils, concatenated for fast membership tests. */
+export const HL_OP_CHARS = `${HL_OP_INSERT_BEFORE}${HL_OP_INSERT_AFTER}${HL_OP_REPLACE}`;
 
-/** Regex-escaped form of {@link HL_EDIT_SEP}, safe for regexes. */
-export const HL_EDIT_SEP_RE_RAW = regexEscape(HL_EDIT_SEP);
+/** Hashline edit file section header marker. */
+export const HL_FILE_PREFIX = "§";
 
 /** Stable separator for read/search/hashline display output. Intentionally not configurable. */
 export const HL_BODY_SEP = "|";

package/src/hashline/input.ts

@@ -1,8 +1,11 @@
 import * as path from "node:path";
-import { ABORT_MARKER, BEGIN_PATCH_MARKER, END_PATCH_MARKER, FILE_HEADER_PREFIX } from "./constants";
-import { HL_EDIT_SEP } from "./hash";
+import { ABORT_MARKER, BEGIN_PATCH_MARKER, END_PATCH_MARKER } from "./constants";
+import { HL_FILE_PREFIX, HL_OP_CHARS } from "./hash";
 import type { SplitHashlineOptions } from "./types";
 
+const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const HASHLINE_OP_LINE_RE = new RegExp(`^[${regexEscape(HL_OP_CHARS)}]`);
+
 export interface HashlineInputSection {
 	path: string;
 	diff: string;
@@ -26,19 +29,18 @@ function normalizeHashlinePath(rawPath: string, cwd?: string): string {
 
 function parseHashlineHeaderLine(line: string, cwd?: string): HashlineInputSection | null {
 	const trimmed = line.trimEnd();
-	if (!trimmed.startsWith(FILE_HEADER_PREFIX)) return null;
-	// Some models occasionally emit unified-diff-style "@@ path" (or even longer
-	// runs of "@"). Strip every leading "@" before resolving the path so those
-	// stray headers still route to the right file.
+	if (!trimmed.startsWith(HL_FILE_PREFIX)) return null;
+	// Strip a run of leading header markers so canonical `§PATH` and
+	// runaway-prefix forms like `§§PATH` / `§§§PATH` route to the same file.
 	let prefixEnd = 0;
-	while (prefixEnd < trimmed.length && trimmed[prefixEnd] === FILE_HEADER_PREFIX) prefixEnd++;
+	while (prefixEnd < trimmed.length && trimmed[prefixEnd] === HL_FILE_PREFIX) prefixEnd++;
 	const rest = trimmed.slice(prefixEnd);
 	if (rest.trim().length === 0) {
-		throw new Error(`Input header "${FILE_HEADER_PREFIX}" is empty; provide a file path.`);
+		throw new Error(`Input header "${HL_FILE_PREFIX}" is empty; provide a file path.`);
 	}
 	const parsedPath = normalizeHashlinePath(rest, cwd);
 	if (parsedPath.length === 0) {
-		throw new Error(`Input header "${FILE_HEADER_PREFIX}" is empty; provide a file path.`);
+		throw new Error(`Input header "${HL_FILE_PREFIX}" is empty; provide a file path.`);
 	}
 	return { path: parsedPath, diff: "" };
 }
@@ -64,7 +66,7 @@ function stripLeadingBlankLines(input: string): string {
 
 export function containsRecognizableHashlineOperations(input: string): boolean {
 	for (const line of input.split(/\r?\n/)) {
-		if (/^[+<=-]\s+/.test(line) || line.startsWith(HL_EDIT_SEP)) return true;
+		if (HASHLINE_OP_LINE_RE.test(line)) return true;
 	}
 	return false;
 }
@@ -79,7 +81,7 @@ function normalizeFallbackInput(input: string, options: SplitHashlineOptions): s
 	if (!options.path || !containsRecognizableHashlineOperations(input)) return input;
 	const fallbackPath = normalizeHashlinePath(options.path, options.cwd);
 	if (fallbackPath.length === 0) return input;
-	return `${FILE_HEADER_PREFIX} ${fallbackPath}\n${input}`;
+	return `${HL_FILE_PREFIX}${fallbackPath}\n${input}`;
 }
 
 export function splitHashlineInput(input: string, options: SplitHashlineOptions = {}): { path: string; diff: string } {
@@ -95,8 +97,8 @@ export function splitHashlineInputs(input: string, options: SplitHashlineOptions
 	if (parseHashlineHeaderLine(firstLine, options.cwd) === null) {
 		const preview = JSON.stringify(firstLine.slice(0, 120));
 		throw new Error(
-			`input must begin with "@@ PATH" on the first non-blank line; got: ${preview}. ` +
-				`Example: "@@ src/foo.ts" then edit ops.`,
+			`input must begin with "${HL_FILE_PREFIX}PATH" on the first non-blank line; got: ${preview}. ` +
+				`Example: "${HL_FILE_PREFIX}src/foo.ts" then edit ops.`,
 		);
 	}