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

package/src/prompts/tools/atom.md

@@ -0,0 +1,87 @@
+Applies precise file edits using full anchors from `read` output (for example `160sr`).
+
+Read the file first. Copy the full anchors exactly as shown by `read`.
+
+<operations>
+**Top level**: `{ path, edits: […] }` — `path` is shared by all entries. You may still override the file inside `loc` with forms like `other.ts:160sr`.
+
+Each entry has one shared locator plus one or more verbs:
+- `loc: "160sr"` — single anchored line
+- `loc: "^"` — beginning of file (only valid with `pre`)
+- `loc: "$"` — end of file (only valid with `post`)
+- `loc: "a.ts:160sr"` — cross-file override inside the locator
+
+Verbs:
+- `set: ["…"]` — replace the anchor line
+- `pre: ["…"]` — insert before the anchor line (or at BOF when `loc:"^"`)
+- `post: ["…"]` — insert after the anchor line (or at EOF when `loc:"$"`)
+- `sed: "s/foo/bar/"` — sed-style substitution applied to the anchor line. **Prefer this over `set` for token-level changes**
+Flags: `g` (all occurrences), `i` (case-insensitive), `F` (literal/fixed-string, no regex).
+Delimiter is whatever character follows `s`.
+You **MUST** keep the pattern as short as possible.
+
+Combination rules:
+- On a single-anchor `loc`, you may combine `pre`, `set`, and `post` in the same entry.
+- `set: []` on a single-anchor `loc` deletes that line.
+- `set:[""]` is **not** delete — it replaces the line with a blank line.
+</operations>
+
+<examples>
+All examples below reference the same file:
+
+```ts title="a.ts"
+{{hline 1 "const tag = \"BAD\";"}}
+{{hline 2 ""}}
+{{hline 3 "function beta(x) {"}}
+{{hline 4 "\tif (x) {"}}
+{{hline 5 "\t\treturn parse(data) || fallback;"}}
+{{hline 6 "\t}"}}
+{{hline 7 "\treturn null;"}}
+{{hline 8 "}"}}
+```
+
+# Replace a line with `set`
+`{path:"a.ts",edits:[{loc:{{href 1 "const tag = \"BAD\";"}},set:["const tag = \"OK\";"]}]}`
+
+# Combine `pre` + `set` + `post` in one entry
+`{path:"a.ts",edits:[{loc:{{href 4 "\tif (x) {"}},pre:["\tvalidate();"],set:["\tif (!x) {"],post:["\t\tlog();"]}]}`
+
+# Delete a line with `set: []`
+`{path:"a.ts",edits:[{loc:{{href 7 "\treturn null;"}},set:[]}]}`
+
+# Preserve a blank line with `set:[""]`
+`{path:"a.ts",edits:[{loc:{{href 2 ""}},set:[""]}]}`
+
+# Insert before / after a line
+`{path:"a.ts",edits:[{loc:{{href 3 "function beta(x) {"}},pre:["function gamma() {","\tvalidate();","}",""]}]}`
+
+# Substitute one token with `sed` (regex) — preferred for token-level edits
+Use the smallest pattern that uniquely identifies the change.
+`{path:"a.ts",edits:[{loc:{{href 5 "\t\treturn parse(data) || fallback;"}},sed:"s/\\|\\|/??/"}]}`
+
+# Substitute every occurrence with `sed` (literal/fixed-string)
+Use the `F` flag to disable regex; the delimiter can be any non-alphanumeric char.
+`{path:"a.ts",edits:[{loc:{{href 5 "\t\treturn parse(data) || fallback;"}},sed:"s|data|input|gF"}]}`
+
+# Prepend / append at file edges
+`{path:"a.ts",edits:[{loc:"^",pre:["// Copyright (c) 2026",""]}]}`
+`{path:"a.ts",edits:[{loc:"$",post:["","export const VERSION = \"1.0.0\";"]}]}`
+
+# Cross-file override inside `loc`
+`{path:"a.ts",edits:[{loc:"b.ts:{{href 1 "const tag = \"BAD\";"}}",set:["const tag = \"OK\";"]}]}`
+</examples>
+
+<critical>
+- Make the minimum exact edit.
+- Copy the full anchors exactly as shown by `read/grep` (for example `160sr`, not just `sr`).
+- `loc` chooses the target. Verbs describe what to do there.
+- On a single-anchor `loc`, you may combine `pre`, `set`, and `post`.
+- `loc:"^"` only supports `pre`. `loc:"$"` only supports `post`.
+- `set: []` deletes the anchored line. `set:[""]` preserves a blank line.
+- Within a single request you may submit edits in any order — the runtime applies them bottom-up so they don't shift each other. After any request that mutates a file, anchors below the mutation are stale on disk; re-read before issuing more edits to that file.
+- `set` operations target the current file content only. Do not try to reference old line text after the file has changed.
+- For token-level edits, prefer `sed` over `set`. The `loc` anchor already pins the line — repeating the entire line in a `set` array invites hallucinated content. Use the smallest `sed` pattern that uniquely identifies the change on that line; do not pad it with surrounding text just to feel safe.
+- When you do use `set`, re-read the anchored line first and copy it verbatim, changing only the required token(s). Anchor identity does not verify line content, so a hallucinated replacement will silently corrupt the file.
+- Text content must be literal file content with matching indentation. If the file uses tabs, use real tabs.
+- You **MUST NOT** use this tool to reformat or clean up unrelated code.
+</critical>

package/src/prompts/tools/chunk-edit.md

@@ -8,7 +8,7 @@ Call format: `{"edits": [{"path": "file:chunk#ID~", "write": "new body"}, …]}`
 
 <rules>
 - **MUST** inspect first with `read`. Never invent chunk paths or IDs. Copy them from the latest `read` output or edit response.
-- `path` format: `file:selector` — e.g. `src/app.ts:fn_foo#ABCD~`. Append `~` for body, `^` for head, or nothing for the whole chunk. Include `#ID` for `write`/`delete`.
+- `path` format: `file:selector` — e.g. `src/app.ts:fn_foo#thth~`. Append `~` for body, `^` for head, or nothing for the whole chunk. Include `#ID` for `write`/`delete`.
 - If the exact chunk path is unclear, run `read(path="file", sel="?")` and copy a selector from that listing.
 {{#if chunkAutoIndent}}
 - Use `\t` for indentation in `content`. Write content at indent-level 0 — the tool re-indents it to match the chunk's position in the file. For example, to replace `~` of a method, write the body starting at column 0:
@@ -75,32 +75,32 @@ Each edit entry has `path` (`file:selector`) plus **exactly one** operation fiel
 <examples>
 Given this `read` output for `counter.rs`:
 ```
-   | counter.rs·62L·rust·#ZRPW
+   | counter.rs·62L·rust·#anth
    |
-@imp#MNHH
+@imp#erhe
  1 |use std::fmt;
    |
-@struct_Counte#QTSX
+@struct_Counte#onat
  3^|/// A simple counter that tracks a value and its history.
  4^|#[derive(Debug, Clone)]
  5^|pub struct Counter {
--@struct_Counte.field_value#MQTW
+-@struct_Counte.field_value#enth
  6 |	/// The current value.
  7 |	value: i32,
--@struct_Counte.field_max#HJMQ
+-@struct_Counte.field_max#seti
  8 |	/// Maximum allowed value.
  9 |	max: i32,
 10 |}
    |
-@impl_Counte#VNPP
+@impl_Counte#reha
 12^|impl Counter {
--@impl_Counte.fn_new#RWZV
+-@impl_Counte.fn_new#ndas
 13^|	/// Creates a new counter starting at zero.
 14^|	pub fn new(max: i32) -> Self {
 15 |		Self { value: 0, max }
 16 |	}
 17 |
--@impl_Counte.fn_increm#MNHV
+-@impl_Counte.fn_increm#ouer
 18^|	/// Increments the counter by one, clamping at max.
 19^|	pub fn increment(&mut self) {
 20 |		if self.value < self.max {
@@ -108,7 +108,7 @@ Given this `read` output for `counter.rs`:
 22 |		}
 23 |	}
 24 |
--@impl_Counte.fn_decrem#TTWB
+-@impl_Counte.fn_decrem#arve
 25^|	/// Decrements the counter by one, clamping at zero.
 26^|	pub fn decrement(&mut self) {
 27 |		if self.value > 0 {
@@ -116,167 +116,43 @@ Given this `read` output for `counter.rs`:
 29 |		}
 30 |	}
 31 |
--@impl_Counte.fn_get#PTNT
+-@impl_Counte.fn_get#arco
 32^|	/// Returns the current value.
 33^|	pub fn get(&self) -> i32 {
 34 |		self.value
 35 |	}
 36 |}
    |
-@impl_Displa#BNJH
+@impl_Displa#meha
 38^|impl fmt::Display for Counter {
--@impl_Displa.fn_fmt#NKRN
+-@impl_Displa.fn_fmt#deri
 39^|	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 40 |		write!(f, "Counter({}/{})", self.value, self.max)
 41 |	}
 42 |}
-   |
-@mod_tests#YWXM
-44^|#[cfg(test)]
-45^|mod tests {
--@mod_tests.chunk#VSMY
-46 |	use super::*;
-47 |
--@mod_tests.fn_test_i#YXQZ
-48^|	#[test]
-49^|	fn test_increment() {
-50 |		let mut c = Counter::new(10);
-51 |		c.increment();
-52 |		assert_eq!(c.get(), 1);
-53 |	}
-54 |
--@mod_tests.fn_test_d#XPBQ
-55^|	#[test]
-56^|	fn test_decrement_at_zero() {
-57 |		let mut c = Counter::new(10);
-58 |		c.decrement();
-59 |		assert_eq!(c.get(), 0);
-60 |	}
-61 |}
-```
-
-**Understanding `^` markers in `read` output:** Lines marked with `^` between the line number and `|` (e.g. ` 3^|`) are **head** lines — doc comments, attributes, and the signature. Lines without `^` (e.g. ` 7 |`) are **body** lines. `~` replaces body lines only, keeping head lines intact.
-
-**Put body** (`~` — the common case):
-```
-{ "path": "counter.rs:impl_Counte.fn_increm#MNHV~", "write": "self.value = (self.value + 1).min(self.max);\n" }
-```
-Result — only the body (non-`^` lines) changes; the doc comment, signature, and closing `}` are all preserved:
-```
-    /// Increments the counter by one, clamping at max.
-    pub fn increment(&mut self) {
-        self.value = (self.value + 1).min(self.max);
-    }
-```
-
-**Write whole chunk** (rewrite signature + doc comment + body):
-```
-{ "path": "counter.rs:impl_Counte.fn_increm#MNHV", "write": "/// Increments by the given step, clamping at max.\npub fn increment(&mut self, step: i32) {\n\tself.value = (self.value + step).min(self.max);\n}\n" }
-```
-Result — **everything** including the doc comment and signature is rewritten. You must include them; omitting them deletes them:
-```
-    /// Increments by the given step, clamping at max.
-    pub fn increment(&mut self, step: i32) {
-        self.value = (self.value + step).min(self.max);
-    }
-```
-
-**Write head** (`^` — attributes, doc comments, signature):
-```
-{ "path": "counter.rs:impl_Counte.fn_get#PTNT^", "write": "/// Returns the current counter value.\n#[inline]\npub fn get(&self) -> i32 {\n" }
-```
-Result — the head (all `^` lines + opening brace) changes, body untouched:
-```
-    /// Returns the current counter value.
-    #[inline]
-    pub fn get(&self) -> i32 {
-        self.value
-    }
-```
-
-**Insert before a chunk** (`prepend`):
-```
-{ "path": "counter.rs:impl_Counte.fn_get", "insert": { "loc": "prepend", "body": "/// Resets the counter to zero.\npub fn reset(&mut self) {\n\tself.value = 0;\n}\n\n" } }
-```
-Result — a new method is inserted before `fn get`:
-```
-    /// Resets the counter to zero.
-    pub fn reset(&mut self) {
-        self.value = 0;
-    }
-
-    /// Returns the current value.
-    pub fn get(&self) -> i32 {
-```
-
-**Insert after a chunk** (`append`):
-```
-{ "path": "counter.rs:struct_Counte", "insert": { "loc": "append", "body": "\nimpl Default for Counter {\n\tfn default() -> Self {\n\t\tSelf { value: 0, max: 100 }\n\t}\n}\n" } }
 ```
-Result — a new impl block appears after the struct:
-```
-}
-
-impl Default for Counter {
-    fn default() -> Self {
-        Self { value: 0, max: 100 }
-    }
-}
-
-impl Counter {
-```
-
-**Insert at start of container body** (`~` + `prepend`):
-```
-{ "path": "counter.rs:impl_Counte~", "insert": { "loc": "prepend", "body": "/// Creates a counter starting at the given value.\npub fn with_value(value: i32, max: i32) -> Self {\n\tSelf { value: value.min(max), max }\n}\n\n" } }
-```
-Result — a new method is added at the top of the impl body, before existing methods:
-```
-impl Counter {
-    /// Creates a counter starting at the given value.
-    pub fn with_value(value: i32, max: i32) -> Self {
-        Self { value: value.min(max), max }
-    }
-
-    /// Creates a new counter starting at zero.
-    pub fn new(max: i32) -> Self {
-```
-
-**Insert at end of container body** (`~` + `append`):
-```
-{ "path": "counter.rs:impl_Counte~", "insert": { "loc": "append", "body": "\n/// Returns true if the counter is at its maximum.\npub fn is_maxed(&self) -> bool {\n\tself.value >= self.max\n}\n" } }
-```
-Result — a new method is added at the end of the impl body, before the closing `}`:
-```
-    pub fn get(&self) -> i32 {
-        self.value
-    }
-
-    /// Returns true if the counter is at its maximum.
-    pub fn is_maxed(&self) -> bool {
-        self.value >= self.max
-    }
-}
-```
-
-**Delete a chunk**:
-```
-{ "path": "counter.rs:impl_Counte.fn_decrem#TTWB", "delete": true }
-```
-Result — the method (including its doc comment and signature) is removed.
-- Indentation rules (important):
-{{#if chunkAutoIndent}}
-  - Use `\t` for each indent level. The tool converts tabs to the file's actual style (2-space, 4-space, etc.).
-{{else}}
-  - Match the file's real indentation characters in your snippet. The tool preserves your literal tabs/spaces after adding the target region's base indent.
-{{/if}}
-  - Do NOT include the chunk's base indentation — only indent relative to the region's opening level.
-  - For `write`, the tool strips common leading whitespace shared by all non-empty lines, then adds the target region's base indent. If lines have mixed relative indentation, write them at column 0 so the common-margin cleanup cannot change the structure.
-  - For `~` of a function: write at column 0, and use `\t` for *relative* nesting. Flat body: `"return x;\n"`. Multiple sibling lines: `"print(a)\nprint(b)\nprint(c)\n"` — all at column 0, the tool adds the function's base indent. Nested body: `"if (cond) {\n\treturn x;\n}\n"` — the `if` is at column 0, the `return` is one tab in. Python example — to replace `~` of `def divide(a, b):`, write: `"if b == 0:\n\treturn None\nreturn a / b\n"` — the `if` and `return a / b` are at column 0, `return None` is one `\t` in.
-  - For `^`: write at column 0 relative to the head region, just like `~`. A class member's head uses `"/// doc\n#[attr]\npub fn start() {"` — do not include the class/member base indentation.
-{{#if chunkAutoIndent}}
-  - For a top-level item: start at zero indent. Write `"fn foo() {\n\treturn 1;\n}\n"`.
-{{else}}
-  - For a top-level item: start at zero indent. Write `"fn foo() {\n  return 1;\n}\n"`.
-{{/if}}
+Lines marked `^` between the line number and `|` are **head** lines (doc comments, attributes, signature). Lines without `^` are **body** lines. `~` replaces body lines only; `^` replaces head lines only.
+
+# Put body (`~` — the common case)
+`{ "path": "counter.rs:impl_Counte.fn_increm#ouer~", "write": "self.value = (self.value + 1).min(self.max);\n" }`
+Only body changes; doc comment, signature, and closing `}` are preserved.
+# Write whole chunk (rewrite signature + doc + body)
+`{ "path": "counter.rs:impl_Counte.fn_increm#ouer", "write": "/// Increments by the given step, clamping at max.\npub fn increment(&mut self, step: i32) {\n\tself.value = (self.value + step).min(self.max);\n}\n" }`
+Everything is rewritten. Omitting the doc comment or signature deletes them.
+# Write head (`^` — attributes, doc comments, signature)
+`{ "path": "counter.rs:impl_Counte.fn_get#arco^", "write": "/// Returns the current counter value.\n#[inline]\npub fn get(&self) → i32 {\n" }`
+Head changes (all `^` lines + opening brace); body untouched.
+# Insert before a chunk (`prepend`)
+`{ "path": "counter.rs:impl_Counte.fn_get", "insert": { "loc": "prepend", "body": "/// Resets the counter to zero.\npub fn reset(&mut self) {\n\tself.value = 0;\n}\n\n" } }`
+# Insert after a chunk (`append`)
+`{ "path": "counter.rs:struct_Counte", "insert": { "loc": "append", "body": "\nimpl Default for Counter {\n\tfn default() → Self {\n\t\tSelf { value: 0, max: 100 }\n\t}\n}\n" } }`
+# Insert at start of container body (`~` + `prepend`)
+`{ "path": "counter.rs:impl_Counte~", "insert": { "loc": "prepend", "body": "/// Creates a counter starting at the given value.\npub fn with_value(value: i32, max: i32) → Self {\n\tSelf { value: value.min(max), max }\n}\n\n" } }`
+Lands at the top of the impl body, before existing methods.
+# Insert at end of container body (`~` + `append`)
+`{ "path": "counter.rs:impl_Counte~", "insert": { "loc": "append", "body": "\n/// Returns true if the counter is at its maximum.\npub fn is_maxed(&self) → bool {\n\tself.value ≥ self.max\n}\n" } }`
+Lands at the end of the impl body, before the closing `}`.
+# Delete a chunk
+`{ "path": "counter.rs:impl_Counte.fn_decrem#arve", "delete": true }`
+Removes the method including its doc comment and signature.
 </examples>

package/src/prompts/tools/debug.md

@@ -16,14 +16,13 @@ Provides debugger access through the Debug Adapter Protocol (DAP). Use this to l
 - Adapter availability depends on local binaries. Common built-ins: `gdb`, `lldb-dap`, `python -m debugpy.adapter`, `dlv dap`.
 </caution>
 
-<example name="launch and inspect hang">
+<examples>
+# Launch and inspect hang
 1. `debug(action: "launch", program: "./my_app")`
 2. `debug(action: "set_breakpoint", file: "src/main.c", line: 42)`
 3. `debug(action: "continue")`
 4. If the program appears hung: `debug(action: "pause")`
 5. Inspect state with `threads`, `stack_trace`, `scopes`, and `variables`
-</example>
-
-<example name="raw debugger command through repl">
+# Raw debugger command through repl
 `debug(action: "evaluate", expression: "info registers", context: "repl")`
-</example>
+</examples>

package/src/prompts/tools/exit-plan-mode.md

@@ -19,15 +19,14 @@ Use when:
 Presents plan to user for approval. If approved, plan mode exits with full tool access restored and the plan is renamed to `local://<title>.md`.
 </output>
 
-<example name="ready">
+<examples>
+# Ready
 Plan complete at local://PLAN.md, no open questions.
 → Call `exit_plan_mode` with `{ "title": "WP_MIGRATION_PLAN" }`
-</example>
-
-<example name="unclear">
+# Unclear
 Unsure about auth method (OAuth vs JWT).
 → Use `ask` first to clarify, then call `exit_plan_mode`
-</example>
+</examples>
 
 <avoid>
 - **MUST NOT** call before plan is written to file

package/src/prompts/tools/find.md

@@ -8,14 +8,10 @@ Finds files using fast pattern matching that works with any codebase size.
 Matching file paths sorted by modification time (most recent first). Truncated at 1000 entries or 50KB (configurable via `limit`).
 </output>
 
-<example name="find files">
-```
-{
-  "pattern": "src/**/*.ts",
-  "limit": 1000
-}
-```
-</example>
+<examples>
+# Find files
+`{"pattern": "src/**/*.ts", "limit": 1000}`
+</examples>
 
 <avoid>
 For open-ended searches requiring multiple rounds of globbing and grepping, you **MUST** use Task tool instead.

package/src/prompts/tools/github.md

@@ -0,0 +1,18 @@
+GitHub CLI tool with a single op-based dispatch. Wraps `gh` for repository, issue, pull request, search, checkout, push, and Actions watch workflows.
+
+<instruction>
+Pick the operation via `op`. Each op uses a subset of the parameters:
+- `repo_view` — Read repository metadata. Optional `repo` (owner/repo) and `branch`. Falls back to the current checkout or default `gh` repo.
+- `issue_view` — Read an issue. Required `issue` (number or URL). Optional `repo`. Set `comments: false` to skip discussion.
+- `pr_view` — Read a pull request, including reviews and inline review comments. Optional `pr` (number, URL, or branch); omitting it targets the current branch's PR. Optional `repo`. Set `comments: false` for a lighter summary.
+- `pr_diff` — Read a pull request diff. Optional `pr`, `repo`. Set `nameOnly: true` for changed file names. Use `exclude` to drop generated paths from the diff.
+- `pr_checkout` — Check a pull request out into a dedicated git worktree. Optional `pr`, `repo`, `branch` (local), `worktree` (path), `force` (reset existing local branch).
+- `pr_push` — Push a checked-out PR branch back to its source branch. Requires the branch to have been checked out via `op: pr_checkout` (carries push metadata). Optional `branch`; defaults to the current checked-out git branch. Optional `forceWithLease`.
+- `search_issues` — Search issues using normal GitHub issue search syntax. Required `query`. Optional `repo`, `limit`.
+- `search_prs` — Search pull requests using normal GitHub PR search syntax. Required `query`. Optional `repo`, `limit`.
+- `run_watch` — Watch a GitHub Actions workflow run. Optional `run` (id or URL). Omitting `run` watches all workflow runs for the current HEAD commit; `branch` falls back to the current branch. Optional `tail` (log lines per failed job). Streams snapshots, fast-fails on the first detected job failure (with a brief grace period to capture concurrent failures), then fetches tailed logs for the failed jobs. The full failed-job logs are saved as a session artifact for on-demand reads.
+</instruction>
+
+<output>
+Returns a concise readable summary tailored to the chosen op (repo/issue/PR metadata, diff text, search results, checkout info, push target, or workflow run snapshot). For `run_watch`, the full failed-job logs are saved as a session artifact when failures occur.
+</output>

package/src/prompts/tools/grep.md

@@ -2,21 +2,20 @@ Searches files using powerful regex matching.
 
 <instruction>
 - Supports full regex syntax (e.g., `log.*Error`, `function\\s+\\w+`); literal braces need escaping (`interface\\{\\}` for `interface{}` in Go)
-- `path` also accepts comma-separated path lists; pair with `glob` when you need a relative file filter in addition to `type`
-- For cross-line patterns like `struct \\{[\\s\\S]*?field`, set `multiline: true`
-- If the pattern contains a literal `\n`, `multiline` defaults to true automatically
+- `path` is required and accepts a file, directory, glob, comma-separated path list, or internal URL
+- Cross-line patterns are detected from literal `\n` or escaped `\\n` in `pattern`
 </instruction>
 
 <output>
 {{#if IS_HASHLINE_MODE}}
-- Text output is CID prefixed: `LINE#ID:content`
+- Text output is anchor-prefixed: `123th>content` (match) or `123th:content` (context). The 2-letter ID is a content fingerprint.
 {{else}}
 {{#if IS_LINE_NUMBER_MODE}}
 - Text output is line-number-prefixed
 {{/if}}
 {{/if}}
 {{#if IS_CHUNK_MODE}}
-- Text output is chunk-path-prefixed: `path:selector>LINE|content`
+- Text output is chunk-path-prefixed: `path:sel>123|content`
 {{/if}}
 </output>
 

package/src/prompts/tools/hashline.md

@@ -1,22 +1,21 @@
-Applies precise file edits using `LINE#ID` anchors from `read` output.
+Applies precise file edits using full anchors from `read` output (for example `160sr`).
 
-Read the file first. Copy anchors exactly from the latest `read` output. After any successful edit, re-read before editing that file again.
+Read the file first. Copy the full anchors exactly as shown by `read`.
 
 <operations>
 **Top level**
 - `edits` — array of edit entries
+- `path` (optional) — default file path used when an entry omits its own `path`. Lets you share the path across many edits in one request.
 
-**Edit entry**: `{ path, loc, content }` or `{ path, delete: true }` or `{ path, move: "new/path" }`
-- `path` — file path
+**Edit entry**: `{ path?, loc, content }`
+- `path` — file path (omit to fall back to the request-level `path`)
 - `loc` — where to apply the edit (see below)
-- `content` — replacement/inserted lines (array of strings preferred, `null` to delete)
-- `delete` — delete the file
-- `move` — move/rename the file
+- `content` — replacement/inserted lines (`string[]`, one element per line; `null` to delete)
 
 **`loc` values**
 - `"append"` / `"prepend"` — insert at end/start of file
-- `{ append: "N#ID" }` / `{ prepend: "N#ID" }` — insert after/before anchored line
-- `{ range: { pos: "N#ID", end: "N#ID" } }` — replace inclusive range `pos..end` with new content (set `pos == end` for single-line replace)
+- `{ append: "123th" }` / `{ prepend: "123th" }` — insert after/before anchored line
+- `{ range: { pos: "123th", end: "123th" } }` — replace inclusive range `pos..end` with new content (set `pos == end` for single-line replace)
 </operations>
 
 <examples>
@@ -43,92 +42,26 @@ All examples below reference the same file:
 {{hline 18 "}"}}
 ```
 
-<example name="replace a block body">
+# Replace a block body
 Replace only the catch body. Do not target the shared boundary line `} catch (err) {`.
-
-```
-{
-  edits: [{
-    path: "a.ts",
-    loc: { range: { pos: {{href 15 "\t\tconsole.error(err);"}}, end: {{href 16 "\t\treturn null;"}} } },
-    content: [
-      "\t\tif (isEnoent(err)) return null;",
-      "\t\tthrow err;"
-    ]
-  }]
-}
-```
-</example>
-
-<example name="replace whole block including closing brace">
-Replace the entire body of `alpha`, including its closing `}`. `end` **MUST** be {{href 7 "}"}} because `content` includes `}`.
-
-```
-{
-  edits: [{
-    path: "a.ts",
-    loc: { range: { pos: {{href 6 "\tlog();"}}, end: {{href 7 "}"}} } },
-    content: [
-      "\tvalidate();",
-      "\tlog();",
-      "}"
-    ]
-  }]
-}
-```
-
-**Wrong**: `end: {{href 6 "\tlog();"}}` with the same content — line 7 (`}`) survives AND content emits `}`, producing two closing braces.
-</example>
-
-<example name="replace one line">
+`{edits:[{path:"a.ts",loc:{range:{pos:{{href 15 "\t\tconsole.error(err);"}},end:{{href 16 "\t\treturn null;"}}}},content:["\t\tif (isEnoent(err)) return null;","\t\tthrow err;"]}]}`
+# Replace whole block including closing brace
+Replace `alpha`'s entire body including the closing `}`. `end` **MUST** be {{href 7 "}"}} because `content` includes `}`.
+`{edits:[{path:"a.ts",loc:{range:{pos:{{href 6 "\tlog();"}},end:{{href 7 "}"}}}},content:["\tvalidate();","\tlog();","}"]}]}`
+**Wrong**: `end: {{href 6 "\tlog();"}}` — line 7 (`}`) survives AND content emits `}`, producing two closing braces.
+# Replace one line
 Single-line replace uses `pos == end`.
-
-```
-{
-  edits: [{
-    path: "a.ts",
-    loc: { range: { pos: {{href 2 "const timeout = 5000;"}}, end: {{href 2 "const timeout = 5000;"}} } },
-    content: ["const timeout = 30_000;"]
-  }]
-}
-```
-</example>
-
-<example name="delete a range">
-```
-{
-  edits: [{
-    path: "a.ts",
-    loc: { range: { pos: {{href 10 "\t// TODO: remove after migration"}}, end: {{href 11 "\tlegacy();"}} } },
-    content: null
-  }]
-}
-```
-</example>
-
-<example name="insert before sibling">
+`{edits:[{path:"a.ts",loc:{range:{pos:{{href 2 "const timeout = 5000;"}},end:{{href 2 "const timeout = 5000;"}}}},content:["const timeout = 30_000;"]}]}`
+# Delete a range
+`{edits:[{path:"a.ts",loc:{range:{pos:{{href 10 "\t// TODO: remove after migration"}},end:{{href 11 "\tlegacy();"}}}},content:null}]}`
+# Insert before a sibling
 When adding a sibling declaration, prefer `prepend` on the next declaration.
-
-```
-{
-  edits: [{
-    path: "a.ts",
-    loc: { prepend: {{href 9 "function beta() {"}} },
-    content: [
-      "function gamma() {",
-      "\tvalidate();",
-      "}",
-      ""
-    ]
-  }]
-}
-```
-</example>
+`{edits:[{path:"a.ts",loc:{prepend:{{href 9 "function beta() {"}}},content:["function gamma() {","\tvalidate();","}",""]}]}`
 </examples>
 
 <critical>
-- Make the minimum exact edit. Do not rewrite nearby code unless the range requires it.
-- Copy anchors exactly as `N#ID` from the latest `read` output.
+- Make the minimum exact edit.
+- Copy the full anchors exactly as shown by `read/grep` (for example `160sr`, not just `sr`).
 - `range` requires both `pos` and `end`.
 - **Closing-delimiter check**: when your replacement `content` ends with a closing delimiter (`}`, `*/`, `)`, `]`), compare it against the line immediately after `end` in the file. If they match, extend `end` to include that line — otherwise the original delimiter survives and `content` adds a second copy.
 - For a range, replace only the body or the whole range — don't split range boundaries.

package/src/prompts/tools/{gemini-image.md → image-gen.md}

@@ -1,4 +1,4 @@
-Generates or edits images using Gemini image models.
+Generates or edits images using the configured image provider.
 
 <instructions>
 - You **MUST** provide a single detailed `subject` prompt for image generation or editing.

package/src/prompts/tools/inspect-image.md

@@ -12,12 +12,12 @@ Inspects an image file with a vision-capable model and returns compact text anal
 </instruction>
 
 <examples>
-- OCR with strict formatting:
-  - `{"path":"screenshots/error.png","question":"Extract all visible text verbatim. Return as bullet list in reading order."}`
-- Screenshot debugging:
-  - `{"path":"screenshots/settings.png","question":"Identify the likely cause of the disabled Save button. Return: (1) observations, (2) likely cause, (3) confidence."}`
-- Scene/object question:
-  - `{"path":"photos/shelf.jpg","question":"List all clearly visible product labels and their shelf positions (top/middle/bottom). If unreadable, say unreadable."}`
+# OCR with strict formatting
+`{"path":"screenshots/error.png","question":"Extract all visible text verbatim. Return as bullet list in reading order."}`
+# Screenshot debugging
+`{"path":"screenshots/settings.png","question":"Identify the likely cause of the disabled Save button. Return: (1) observations, (2) likely cause, (3) confidence."}`
+# Scene/object question
+`{"path":"photos/shelf.jpg","question":"List all clearly visible product labels and their shelf positions (top/middle/bottom). If unreadable, say unreadable."}`
 </examples>
 
 <output>

package/src/prompts/tools/lsp.md

@@ -36,4 +36,4 @@ Interacts with Language Server Protocol servers for code intelligence.
 - You **MUST** use `lsp` for symbol-aware operations (rename, find references, go to definition/implementation, code actions) whenever a language server is available — it is safer and more accurate than text-based alternatives.
 - You **MUST NOT** perform cross-file renames with `ast_edit`, `sed`, `rsed`, or manual edits when `lsp` `rename` can do it. Text-based renames miss shadowing, re-exports, and usages in other files.
 - Prefer `lsp` `code_actions` for imports, quick-fixes, and refactors the language server already knows how to apply.
-</critical>
+</critical>