@oh-my-pi/pi-coding-agent 13.0.0 → 13.0.2

package/src/patch/shared.ts

@@ -22,6 +22,7 @@ import {
 	truncateDiffByHunk,
 } from "../tools/render-utils";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+import type { HashlineToolEdit } from "./index";
 import type { DiffError, DiffResult, Operation } from "./types";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -58,7 +59,7 @@ export interface EditToolDetails {
 	/** Operation type (patch mode only) */
 	op?: Operation;
 	/** New path after move/rename (patch mode only) */
-	rename?: string;
+	move?: string;
 	/** Structured output metadata */
 	meta?: OutputMeta;
 }
@@ -70,6 +71,7 @@ export interface EditToolDetails {
 interface EditRenderArgs {
 	path?: string;
 	file_path?: string;
+	file?: string;
 	oldText?: string;
 	newText?: string;
 	patch?: string;
@@ -83,16 +85,9 @@ interface EditRenderArgs {
 	 */
 	previewDiff?: string;
 	// Hashline mode fields
-	edits?: HashlineEditPreview[];
+	edits?: Partial<HashlineToolEdit>[];
 }
 
-type HashlineEditPreview =
-	| { op: "replace"; tag: string; content: string[] }
-	| { op: "replace"; first: string; last: string; content: string[] }
-	| { op: "append"; after?: string; content: string[] }
-	| { op: "prepend"; before?: string; content: string[] }
-	| { op: "insert"; before: string; after: string; content: string[] };
-
 /** Extended context for edit tool rendering */
 export interface EditRenderContext {
 	/** Pre-computed diff preview (computed before tool executes) */
@@ -123,7 +118,7 @@ function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, labe
 	return text;
 }
 
-function formatStreamingHashlineEdits(edits: unknown[], uiTheme: Theme): string {
+function formatStreamingHashlineEdits(edits: Partial<HashlineToolEdit>[], uiTheme: Theme): string {
 	const MAX_EDITS = 4;
 	const MAX_DST_LINES = 8;
 	let text = "\n\n";
@@ -158,34 +153,25 @@ function formatStreamingHashlineEdits(edits: unknown[], uiTheme: Theme): string
 	}
 
 	return text.trimEnd();
-	function formatHashlineEdit(edit: unknown): { srcLabel: string; dst: string } {
-		const editRecord = typeof edit === "object" && edit !== null ? (edit as Record<string, unknown>) : undefined;
-		if (!editRecord) {
+	function formatHashlineEdit(edit: Partial<HashlineToolEdit>): { srcLabel: string; dst: string } {
+		if (typeof edit !== "object" || !edit) {
 			return { srcLabel: "• (incomplete edit)", dst: "" };
 		}
 
-		const contentLines = Array.isArray(editRecord.content) ? (editRecord.content as string[]).join("\n") : "";
+		const contentLines = Array.isArray(edit.lines) ? (edit.lines as string[]).join("\n") : "";
 
-		// replace with tag (single line)
-		if ("tag" in editRecord && !("first" in editRecord)) {
-			const tag = typeof editRecord.tag === "string" ? editRecord.tag : "…";
-			return { srcLabel: `• line ${tag}`, dst: contentLines };
-		}
-		// replace with first..last (range)
-		if ("first" in editRecord || "last" in editRecord) {
-			const first = typeof editRecord.first === "string" ? editRecord.first : "…";
-			const last = typeof editRecord.last === "string" ? editRecord.last : "…";
-			return { srcLabel: `• range ${first}..${last}`, dst: contentLines };
+		const op = typeof edit.op === "string" ? edit.op : "?";
+		const pos = typeof edit.pos === "string" ? edit.pos : undefined;
+		const end = typeof edit.end === "string" ? edit.end : undefined;
+
+		if (pos && end && pos !== end) {
+			return { srcLabel: `• ${op} ${pos}…${end}`, dst: contentLines };
 		}
-		// append/prepend/insert
-		if ("before" in editRecord || "after" in editRecord) {
-			const after = typeof editRecord.after === "string" ? editRecord.after : undefined;
-			const before = typeof editRecord.before === "string" ? editRecord.before : undefined;
-			const refs = [after, before].filter(Boolean).join("..") || "…";
-			return { srcLabel: `• insert ${refs}`, dst: contentLines };
+		const anchor = pos ?? end;
+		if (anchor) {
+			return { srcLabel: `\u2022 ${op} ${anchor}`, dst: contentLines };
 		}
-
-		return { srcLabel: "• (incomplete edit)", dst: "" };
+		return { srcLabel: `\u2022 ${op} (file-level)`, dst: contentLines };
 	}
 }
 function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
@@ -234,7 +220,7 @@ export const editToolRenderer = {
 	mergeCallAndResult: true,
 
 	renderCall(args: EditRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
-		const rawPath = args.file_path || args.path || "";
+		const rawPath = args.file_path || args.path || args.file || "";
 		const filePath = shortenPath(rawPath);
 		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
 		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
@@ -289,13 +275,13 @@ export const editToolRenderer = {
 		uiTheme: Theme,
 		args?: EditRenderArgs,
 	): Component {
-		const rawPath = args?.file_path || args?.path || "";
+		const rawPath = args?.file_path || args?.path || args?.file || "";
 		const filePath = shortenPath(rawPath);
 		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
 		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
 
 		const op = args?.op || result.details?.op;
-		const rename = args?.rename || result.details?.rename;
+		const rename = args?.rename || result.details?.move;
 		const opTitle = op === "create" ? "Create" : op === "delete" ? "Delete" : "Edit";
 
 		// Pre-compute metadata line (static across renders)

package/src/prompts/compaction/compaction-short-summary.md

@@ -5,5 +5,5 @@ Rules:
 - MUST describe the changes made, not the process
 - MUST NOT mention running tests, builds, or other validation steps
 - MUST NOT explain what the user asked for
-- MUST write in first person (I added..., I fixed...)
+- MUST write in first person (I added…, I fixed…)
 - MUST NOT ask questions

package/src/prompts/system/agent-creation-architect.md

@@ -33,25 +33,25 @@ When a user describes what they want an agent to do, you will:
       <function call omitted for brevity only for this example>
       <commentary>
       Since a significant piece of code was written, use the {{TASK_TOOL_NAME}} tool to launch the test-runner agent to run the tests.
-</commentary>
+      </commentary>
       assistant: "Now let me use the test-runner agent to run the tests"
-</example>
+      </example>
     - <example>
       Context: User is creating an agent to respond to the word "hello" with a friendly jok.
       user: "Hello"
       assistant: "I'm going to use the {{TASK_TOOL_NAME}} tool to launch the greeting-responder agent to respond with a friendly joke"
       <commentary>
       Since the user is greeting, use the greeting-responder agent to respond with a friendly joke.
-</commentary>
-</example>
+      </commentary>
+      </example>
   - If the user mentioned or implied that the agent should be used proactively, you SHOULD include examples of this.
 - NOTE: You MUST ensure that in the examples, you are making the assistant use the Agent tool and MUST NOT simply respond directly to the task.
 
 Your output MUST be a valid JSON object with exactly these fields:
 {
   "identifier": "A unique, descriptive identifier using lowercase letters, numbers, and hyphens (e.g., 'test-runner', 'api-docs-writer', 'code-formatter')",
-  "whenToUse": "A precise, actionable description starting with 'Use this agent when...' that clearly defines the triggering conditions and use cases. Ensure you include examples as described above.",
-  "systemPrompt": "The complete system prompt that will govern the agent's behavior, written in second person ('You are...', 'You will...') and structured for maximum clarity and effectiveness"
+  "whenToUse": "A precise, actionable description starting with 'Use this agent when…' that clearly defines the triggering conditions and use cases. Ensure you include examples as described above.",
+  "systemPrompt": "The complete system prompt that will govern the agent's behavior, written in second person ('You are…', 'You will…') and structured for maximum clarity and effectiveness"
 }
 
 Key principles for your system prompts:

package/src/prompts/system/system-prompt.md

@@ -90,7 +90,7 @@ Semantic questions MUST be answered with semantic tools.
 {{#has tools "ssh"}}
 ### SSH: match commands to host shell
 Commands MUST match the host shell. linux/bash, macos/zsh: Unix. windows/cmd: dir, type, findstr. windows/powershell: Get-ChildItem, Get-Content.
-Remote filesystems: `~/.omp/remote/<hostname>/`. Windows paths need colons: `C:/Users/...`
+Remote filesystems: `~/.omp/remote/<hostname>/`. Windows paths need colons: `C:/Users/…`
 {{/has}}
 
 {{#ifAny (includes tools "grep") (includes tools "find")}}

package/src/prompts/tools/bash.md

@@ -3,7 +3,7 @@
 Executes bash command in shell session for terminal operations like git, bun, cargo, python.
 
 <instruction>
-- You MUST use `cwd` parameter to set working directory instead of `cd dir && ...`
+- You MUST use `cwd` parameter to set working directory instead of `cd dir && …`
 - PTY mode is opt-in: set `pty: true` only when command expects a real terminal (for example `sudo`, `ssh` where you need input from the user); default is `false`
 - You MUST use `;` only when later commands should run regardless of earlier failures
 - `skill://` URIs are auto-resolved to filesystem paths before execution

package/src/prompts/tools/find.md

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

package/src/prompts/tools/hashline.md

@@ -1,96 +1,115 @@
 # Edit
 
-Apply precise file edits using `LINE#ID` tags, anchoring to the file content.
+Apply precise file edits using `LINE#ID` tags from `read` output.
 
 <workflow>
-1. You MUST `read` the target range to capture current `LINE#ID` tags.
-2. You MUST pick the smallest operation per change site (line/range/insert/content-replace).
-3. You MUST direction-lock every edit: exact current text → intended text.
-4. You MUST submit one `edit` call per file containing all operations.
-5. If another edit is needed in that file, you MUST re-read first (hashes changed).
-6. You MUST output tool calls only; no prose.
+1. You SHOULD issue a `read` call before editing if you have no tagged context for a file.
+2. You MUST pick the smallest operation per change site.
+3. You MUST submit one `edit` call per file with all operations, think your changes through before submitting.
 </workflow>
 
 <operations>
-- **Line or range replace/delete**
-  - `{ op: "replace", tag: "N#ID", content: […] }`
-  - `{ op: "replace", first: "N#ID", last: "N#ID", content: […] }`
-  - Use for swaps, block rewrites, or deleting a full span (`content: null`).
-- **Insert** (new content)
-  - `{ op: "prepend", before: "N#ID", content: […] }` or `{ op: "prepend", content: […] }` (no `before` = insert at beginning of file)
-  - `{ op: "append", after: "N#ID", content: […] }` or `{ op: "append", content: […] }` (no `after` = insert at end of file)
-  - `{ op: "insert", after: "N#ID", before: "N#ID", content: […] }` (between adjacent anchors; safest for blocks)
-- **File-level controls**
-  - `{ delete: true, edits: [] }` deletes the file (cannot be combined with `rename`).
-  - `{ rename: "new/path.ts", edits: […] }` writes result to new path and removes old path.
-**Atomicity:** all ops validate against the same pre-edit file snapshot; refs are interpreted against last `read`; applicator applies bottom-up.
+Every edit has `op`, `pos`, and `lines`. Range replaces also have `end`. Both `pos` and `end` use `"N#ID"` format (e.g. `"23#XY"`).
+**`pos`** — the anchor line. Meaning depends on `op`:
+- `replace`: start of range (or the single line to replace)
+- `prepend`: insert new lines **before** this line; omit for beginning of file
+- `append`: insert new lines **after** this line; omit for end of file
+**`end`** — range replace only. The last line of the range (inclusive). Omit for single-line replace.
+**`lines`** — the replacement content:
+- `["line1", "line2"]` — replace with these lines (array of strings)
+- `"line1"` — shorthand for `["line1"]` (single-line replace)
+- `[""]` — replace content with a blank line (line preserved, content cleared)
+- `null` or `[]` — **delete** the line(s) entirely
+
+### Line or range replace/delete
+- `{ file: "…", edits: [{ op: "replace", pos: "N#ID", lines: null }] }` — delete one line
+- `{ file: "…", edits: [{ op: "replace", pos: "N#ID", end: "M#ID", lines: null }] }` — delete a range
+- `{ file: "…", edits: [{ op: "replace", pos: "N#ID", lines: […] }] }` — replace one line
+- `{ file: "…", edits: [{ op: "replace", pos: "N#ID", end: "M#ID", lines: […] }] }` — replace a range
+
+### Insert new lines
+- `{ file: "…", edits: [{ op: "prepend", pos: "N#ID", lines: […] }] }` — insert before tagged line
+- `{ file: "…", edits: [{ op: "prepend", lines: […] }] }` — insert at beginning of file (no tag)
+- `{ file: "…", edits: [{ op: "append", pos: "N#ID", lines: […] }] }` — insert after tagged line
+- `{ file: "…", edits: [{ op: "append", lines: […] }] }` — insert at end of file (no tag)
+
+### File-level controls
+- `{ file: "…", delete: true, edits: [] }` — delete the file
+- `{ file: "…", move: "new/path.ts", edits: […] }` — move file to new path (edits applied first)
+**Atomicity:** all ops in one call validate against the same pre-edit snapshot; tags reference the last `read`. Edits are applied bottom-up, so earlier tags stay valid even when later ops add or remove lines.
 </operations>
 
 <rules>
-1. **Minimize scope:** You MUST use one logical mutation site per operation.
-2. **Preserve formatting:** You MUST keep indentation, punctuation, line breaks, trailing commas, brace style.
-3. **Prefer insertion over neighbor rewrites:** You SHOULD anchor on structural boundaries (`}`, `]`, `},`) not interior property lines.
-4. **No no-ops:** replacement content MUST differ from current content.
-5. **Touch only requested code:** You MUST NOT make incidental edits.
-6. **Use exact current tokens:** You MUST NOT rewrite approximately; mutate the token that exists now.
-7. **For swaps/moves:** You SHOULD prefer one range operation over multiple single-line operations.
+1. **Minimize scope:** You MUST use one logical mutation per operation.
+2. **No no-ops:** replacement MUST differ from current.
+3. **Prefer insertion over neighbor rewrites:** You SHOULD anchor on structural boundaries (`}`, `]`, `},`), not interior lines.
+4. **For swaps/moves:** You SHOULD prefer one range op over multiple single-line ops.
 </rules>
 
-<op-choice>
-- One wrong line → MUST use `set`
-- Adjacent block changed → MUST use `insert`
-- Missing line/block → MUST use `append`/`prepend`
-</op-choice>
-
-<tag-choice>
-- You MUST copy tags exactly from the prefix of the `read` or error output.
-- You MUST NOT guess tags.
-- For inserts, you SHOULD prefer `insert` > `append`/`prepend` when both boundaries are known.
-- You MUST re-read after each successful edit call before issuing another on same file.
-</tag-choice>
-
 <recovery>
-**Tag mismatch (`>>>`)**
-- You MUST retry with the updated tags shown in error output.
-- You MUST re-read only if required tags are missing from error snippet.
-- If mismatch repeats, you MUST stop and re-read the exact block.
+**Tag mismatch (`>>>`):** You MUST retry using fresh tags from the error snippet. Re-read only if snippet lacks context.
+**No-op (`identical`):** You MUST NOT resubmit. Re-read target lines and adjust the edit.
 </recovery>
 
-<example name="fix a value or type">
+<example name="single-line replace">
 ```ts
 {{hlinefull 23 "  const timeout: number = 5000;"}}
 ```
 ```
-op: "replace"
-tag: "{{hlineref 23 "  const timeout: number = 5000;"}}"
-content: ["  const timeout: number = 30_000;"]
+{
+  file: "…",
+  edits: [{
+    op: "replace",
+    pos: "{{hlineref 23 "  const timeout: number = 5000;"}}",
+    lines: ["  const timeout: number = 30_000;"]
+  }]
+}
 ```
 </example>
 
-<example name="remove a line entirely">
-```ts
-{{hlinefull 7 "// @ts-ignore"}}
-{{hlinefull 8 "const data = fetchSync(url);"}}
-```
-```
-op: "replace"
-tag: "{{hlineref 7 "// @ts-ignore"}}"
-content: null
+<example name="delete lines">
+Single line — `lines: null` deletes entirely:
+```
+{
+  file: "…",
+  edits: [{
+    op: "replace",
+    pos: "{{hlineref 7 "// @ts-ignore"}}",
+    lines: null
+  }]
+}
+```
+Range — add `end`:
+```
+{
+  file: "…",
+  edits: [{
+    op: "replace",
+    pos: "{{hlineref 80 "  // TODO: remove after migration"}}",
+    end: "{{hlineref 83 "  }"}}",
+    lines: null
+  }]
+}
 ```
 </example>
 
-<example name="clear content but keep the line break">
+<example name="clear text but keep the line break">
 ```ts
 {{hlinefull 14 "  placeholder: \"DO NOT SHIP\","}}
 ```
 ```
-op: "replace"
-tag: "{{hlineref 14 "  placeholder: \"DO NOT SHIP\","}}"
-content: [""]
+{
+  file: "…",
+  edits: [{
+    op: "replace",
+    pos: "{{hlineref 14 "  placeholder: \"DO NOT SHIP\","}}",
+    lines: [""]
+  }]
+}
 ```
 </example>
 
-<example name="rewrite a block of logic">
+<example name="rewrite a block">
 ```ts
 {{hlinefull 60 "    } catch (err) {"}}
 {{hlinefull 61 "      console.error(err);"}}
@@ -98,117 +117,74 @@ content: [""]
 {{hlinefull 63 "    }"}}
 ```
 ```
-op: "replace"
-first: "{{hlineref 60 "    } catch (err) {"}}"
-last: "{{hlineref 63 "    }"}}"
-content: ["    } catch (err) {", "      if (isEnoent(err)) return null;", "      throw err;", "    }"]
-```
-</example>
-
-<example name="remove a full block">
-```ts
-{{hlinefull 80 "  // TODO: remove after migration"}}
-{{hlinefull 81 "  if (legacy) {"}}
-{{hlinefull 82 "    legacyHandler(req);"}}
-{{hlinefull 83 "  }"}}
-```
-```
-op: "replace"
-first: "{{hlineref 80 "  // TODO: remove after migration"}}"
-last: "{{hlineref 83 "  }"}}"
-content: null
+{
+  file: "…",
+  edits: [{
+    op: "replace",
+    pos: "{{hlineref 60 "    } catch (err) {"}}",
+    end: "{{hlineref 63 "    }"}}",
+    lines: [
+      "    } catch (err) {",
+      "      if (isEnoent(err)) return null;",
+      "      throw err;",
+      "    }"
+    ]
+  }]
+}
 ```
 </example>
 
-<example name="add an import above the first import">
+<example name="insert between siblings">
 ```ts
-{{hlinefull 1 "import * as fs from \"node:fs/promises\";"}}
-{{hlinefull 2 "import * as path from \"node:path\";"}}
-```
-```
-op: "prepend"
-before: "{{hlineref 1 "import * as fs from \"node:fs/promises\";"}}"
-content: ["import * as os from \"node:os\";"]
-```
-Use `before` for anchored insertion before a specific line. Omit `before` to prepend at BOF.
-</example>
-
-<example name="append at end of file">
-```ts
-{{hlinefull 260 "export { serialize, deserialize };"}}
+{{hlinefull 44 "  \"build\": \"bun run compile\","}}
+{{hlinefull 45 "  \"test\": \"bun test\""}}
 ```
 ```
-op: "append"
-after: "{{hlineref 260 "export { serialize, deserialize };"}}"
-content: ["export { validate };"]
+{
+  file: "…",
+  edits: [{
+    op: "prepend",
+    pos: "{{hlineref 45 "  \"test\": \"bun test\""}}",
+    lines: ["  \"lint\": \"biome check\","]
+  }]
+}
 ```
-Use `after` for anchored insertion after a specific line. Omit `after` to append at EOF.
-</example>
-
-<example name="add an entry between known siblings">
+Result:
 ```ts
 {{hlinefull 44 "  \"build\": \"bun run compile\","}}
-{{hlinefull 45 "  \"test\": \"bun test\""}}
-```
-```
-op: "insert"
-after: "{{hlineref 44 "  \"build\": \"bun run compile\","}}"
-before: "{{hlineref 45 "  \"test\": \"bun test\""}}"
-content: ["  \"lint\": \"biome check\","]
+{{hlinefull 45 "  \"lint\": \"biome check\","}}
+{{hlinefull 46 "  \"test\": \"bun test\""}}
 ```
-Dual anchors pin the insert to exactly one gap, preventing drift from edits elsewhere in the file. **Always prefer dual anchors when both boundaries are content lines.**
 </example>
 
-<example name="insert a function before another function">
+<example name="anchor to structure, not whitespace">
+Trailing `""` in `lines` preserves blank-line separators. Anchor to the structural line, not the blank line above — blank lines are ambiguous and shift.
 ```ts
-{{hlinefull 100 "  return buf.toString(\"hex\");"}}
 {{hlinefull 101 "}"}}
 {{hlinefull 102 ""}}
 {{hlinefull 103 "export function serialize(data: unknown): string {"}}
 ```
-```
-op: "insert"
-before: "{{hlineref 103 "export function serialize(data: unknown): string {"}}"
-content: ["function validate(data: unknown): boolean {", "  return data != null && typeof data === \"object\";", "}", ""]
-```
-The trailing `""` in `content` preserves the blank-line separator. **Anchor to the structural line (`export function ...`), not the blank line above it** — blank lines are ambiguous and may be added or removed by other edits.
-</example>
-
-<example name="file delete">
-```
-path: "src/deprecated/legacy.ts"
-delete: true
-```
-</example>
-
-<example name="file rename with edits">
-```
-path: "src/utils.ts"
-rename: "src/helpers/utils.ts"
-edits: […]
-```
-</example>
-
-<example name="anti-pattern: anchoring to whitespace">
-Bad — tags to a blank line; fragile if blank lines shift:
-```
-after: "{{hlineref 102 ""}}"
-content: ["function validate() {", …, "}"]
-```
-
-Good — anchors to the structural target:
-
-```
-before: "{{hlineref 103 "export function serialize(data: unknown): string {"}}"
-content: ["function validate() {", …, "}"]
+Bad — append after "}"
+Good — anchors to structural line:
+```
+{
+  file: "…",
+  edits: [{
+    op: "prepend",
+    pos: "{{hlineref 103 "export function serialize(data: unknown): string {"}}",
+    lines: [
+      "function validate(data: unknown): boolean {",
+      "  return data != null && typeof data === \"object\";",
+      "}",
+      ""
+    ]
+  }]
+}
 ```
 </example>
 
 <critical>
-You MUST ensure:
-- Payload shape is `{ "path": string, "edits": [operation, …], "delete"?: boolean, "rename"?: string }`
-- Every edit MUST match exactly one variant
-- Every tag MUST be copied EXACTLY from a tool result as `N#ID`
-- Scope MUST be minimal and formatting MUST be preserved except targeted token changes
-</critical>
-**Final reminder:** tags are immutable references to the last read snapshot. You MUST re-read when state changes, then edit.
+- Edit payload: `{ file, edits[] }`. Each entry: `op`, `lines`, optional `pos`/`end`. No extra keys.
+- Every tag MUST be copied exactly from fresh tool result as `N#ID`.
+- You MUST re-read after each edit call before issuing another on same file.
+</critical>

package/src/prompts/tools/patch.md

@@ -60,7 +60,7 @@ edit {"path":"src/app.py","op":"update","diff":"@@ def greet():\n def greet():\n
 </example>
 
 <example name="rename">
-edit {"path":"src/app.py","op":"update","rename":"src/main.py","diff":"@@\n ...\n"}
+edit {"path":"src/app.py","op":"update","rename":"src/main.py","diff":"@@\n …\n"}
 </example>
 
 <example name="delete">

package/src/prompts/tools/python.md

@@ -36,8 +36,8 @@ All helpers auto-print results and return values for chaining.
 <output>
 User sees output like Jupyter notebook; rich displays render fully:
 - `display(JSON(data))` → interactive JSON tree
-- `display(HTML(...))` → rendered HTML
-- `display(Markdown(...))` → formatted markdown
+- `display(HTML(…))` → rendered HTML
+- `display(Markdown(…))` → formatted markdown
 - `plt.show()` → inline figures
   **You will see object repr** (e.g., `<IPython.core.display.JSON object>`). Trust `display()`; you MUST NOT assume user sees only repr.
 </output>

package/src/prompts/tools/replace.md

@@ -24,7 +24,7 @@ For position-addressed or pattern-addressed changes, bash more efficient:
 
 |Operation|Command|
 |---|---|
-|Append to file|`cat >> file <<'EOF'`...`EOF`|
+|Append to file|`cat >> file <<'EOF'`…`EOF`|
 |Prepend to file|`{ cat - file; } <<'EOF' > tmp && mv tmp file`|
 |Delete lines N-M|`sed -i 'N,Md' file`|
 |Insert after line N|`sed -i 'Na\text' file`|