@oh-my-pi/hashline 16.1.22 → 16.1.23

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [16.1.23] - 2026-06-26
+
+### Added
+
+- Updated prompt documentation to include support for Markdown section operations
+
+### Fixed
+
+- Improved file path recovery to correctly handle read-only or incorrectly typed paths
+
 ## [16.1.14] - 2026-06-22
 
 ### Fixed

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "16.1.22",
+	"version": "16.1.23",
 	"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/patcher.ts

@@ -256,13 +256,15 @@ export class Patcher {
 
 		let target = section;
 		let canonicalPath = this.fs.canonicalPath(target.path);
-		await this.fs.preflightWrite(target.path);
 		let read = await this.#tryRead(target.path);
 
 		// Path recovery: the authored path doesn't exist on disk, but its
 		// filename + snapshot tag may name a file the model read this session
 		// (it supplied a bare filename, or the wrong directory). Rebind to that
-		// file so the edit lands where the tag points, and warn.
+		// file so the edit lands where the tag points, and warn. This runs
+		// before the write gate so a recoverable bare/mis-typed path is rebound
+		// to its real (writable) location instead of being rejected against the
+		// literal — possibly read-only — path it was authored as.
 		if (!read.exists) {
 			const recovered = this.#recoverSectionPathFromTag(target, canonicalPath);
 			if (recovered && this.fs.allowTagPathRecovery(target.path, recovered.section.path)) {
@@ -271,10 +273,15 @@ export class Patcher {
 				);
 				target = recovered.section;
 				canonicalPath = recovered.canonicalPath;
-				await this.fs.preflightWrite(target.path);
 				read = await this.#tryRead(target.path);
 			}
 		}
+
+		// Gate the final (possibly recovered) target before any write work, so
+		// an unrecoverable read-only target (e.g. a plan-mode working-tree path)
+		// fails with the write guard rather than a misleading "file not found".
+		await this.fs.preflightWrite(target.path);
+
 		if (!read.exists) {
 			throw new Error(`File not found: ${target.path}. Use the write tool to create new files.`);
 		}

package/src/prompt.md

@@ -34,6 +34,7 @@ Body rows appear only under a `:` header. Every body row is `+TEXT` — add a li
 - 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, last line, or a bare inner statement. Anchoring one statement resolves to ONE line and is REJECTED: use the plain op (`SWAP N.=N` / `DEL N` / `INS.POST N`), or point N at the real opener. Saw the closer? Use plain `INS.POST M:`.
+- Markdown: a heading line IS a block opener — `SWAP.BLK`/`DEL.BLK`/`INS.BLK.POST` on a `##`/`###` heading resolves its WHOLE section (heading through every nested deeper heading, up to the next same-or-higher heading). So `DEL.BLK` drops the section, `SWAP.BLK` rewrites it, `INS.BLK.POST` lands after it (end the inserted body with a blank line to keep the next heading separated).
 - Non-adjacent changes = separate hunks; untouched lines stay out of every range.
 - 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 past the range is auto-dropped as an off-by-one keeper with a warning — issue the payload for the range only; never lean on the repair.)
 - NEVER format/restyle code with this tool; run the project formatter instead.