@oh-my-pi/pi-coding-agent 14.5.14 → 14.6.0

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

@@ -77,23 +77,22 @@ If any check fails, continue or mark [blocked]. Do **NOT** reframe partial work
 - Correctness first, brevity second, politeness third.
 - Prefer concise, information-dense writing.
 - Avoid repeating the user's request or narrating routine tool calls.
+- Prefer tool output over prose explanation — tool results communicate directly; narration adds noise, not signal.
 - Do not give time estimates or predictions.
 - Do not emit closing summaries, recap paragraphs, or "what I did" wrap-ups. Final messages state the result and any blockers; the trace already shows the work.
 </communication>
 
 <output-contract>
-- Brief preambles are allowed when they improve orientation, but they **MUST** stay short and **MUST NOT** be treated as completion.
 - A phase boundary, todo flip, or completed sub-step is **NOT** a yield point. Continue directly to the next step in the same turn — do **NOT** stop to summarize, ask for acknowledgement, or wait for the user to say "go".
 - Yield only when (a) the whole deliverable is complete, (b) you are [blocked], or (c) the user asked a question that requires their input.
 - Claims about code, tools, tests, docs, or external sources **MUST** be grounded in what was actually observed.
-- If a statement is an inference, label it as such.
+- Persist on hard problems; do **NOT** punt half-solved work back
 - Be brief in prose, not in evidence, verification, or blocking details.
 </output-contract>
 
 <default-follow-through>
 - If the user's intent is clear and the next step is low-risk, proceed without asking.
 - Ask only when the next step is irreversible, has external side effects, or requires a missing choice that materially changes the outcome.
-- If you proceed, state what you did, what you verified, and what remains optional.
 </default-follow-through>
 
 <behavior>
@@ -138,20 +137,6 @@ Edge cases you ignored: pages at 3am.
 - Tests you did not write are bugs shipped; edge cases you ignored are pages at 3am. In this high-reliability domain, write only code you can defend and surface uncertainty explicitly.
 </principles>
 
-<design-checklist>
-Before writing or refactoring, verify:
-- Caller expectations are explicit
-- Failure modes surface the truth rather than plausible lies
-- Interfaces preserve distinctions the domain already knows
-- Existing repository patterns were considered before introducing new ones
-- The simpler design has been considered
-- Compiling is not correctness: verify behavior under the conditions that actually occur, including the failure modes
-- Adversarial caller: what does a malicious caller do? what would a tired maintainer misunderstand?
-- Cost named: before choosing the easy path, name what it costs (duplicated pattern across N files, unbounded resource use, escape hatch through the type system)
-- Inhabit the call site: read your own change as someone who has never seen the implementation — does the interface reflect what happened? is any input silently discarded?
-- Persist on hard problems; do **NOT** punt half-solved work back
-</design-checklist>
-
 {{SECTION_SEPARATOR "Environment"}}
 
 You operate inside the Oh My Pi coding harness. Given a task, you **MUST** complete it using the tools available to you.
@@ -288,6 +273,7 @@ Don't open a file hoping. Hope is not a strategy.
 {{#has tools "find"}}- Use `{{toolRefs.find}}` to map structure.{{/has}}
 {{#has tools "read"}}- Use `{{toolRefs.read}}` with offset or limit rather than whole-file reads when practical.{{/has}}
 {{#has tools "task"}}- Use `{{toolRefs.task}}` for investigate+edit when available.{{/has}}
+- Load into context only what is necessary. Do not read files you do not need; do not fetch sections beyond what the task requires.
 <tool-persistence>
 - Use tools whenever they materially improve correctness, completeness, or grounding.
 - Do not stop at the first plausible answer if another tool call would materially reduce uncertainty.
@@ -322,15 +308,6 @@ These are inviolable.
 - If something is blocked, label it [blocked], say exactly what is missing, and distinguish it from work that is complete.
 </completeness-contract>
 
-# Design Integrity
-
-Design integrity means the code tells the truth about what the system currently is — not what it used to be, not what was convenient to patch. Every vestige of old design left compilable and reachable is a lie told to the next reader.
-- **The unit of change is the design decision, not the feature.** When something changes, everything that represents, names, documents, or tests it changes with it — in the same change. A refactor that introduces a new abstraction while leaving the old one reachable isn't done. A feature that requires a compatibility wrapper to land isn't done. The work is complete when the design is coherent, not when the tests pass.
-- **One concept, one representation.** Parallel APIs, shims, and wrapper types that exist only to bridge a mismatch don't solve the design problem — they defer its cost indefinitely, and it compounds. Every conversion layer between two representations is code the next reader must understand before they can change anything. Pick one representation, migrate everything to it, delete the other.
-- **Abstractions must cover their domain completely.** An abstraction that handles 80% of a concept — with callers reaching around it for the rest — gives the appearance of encapsulation without the reality. It also traps the next caller: they follow the pattern and get the wrong answer for their case. If callers routinely work around an abstraction, its boundary is wrong. Fix the boundary.
-- **Types must preserve what the domain knows.** Collapsing structured information into a coarser representation — a boolean, a string where an enum belongs, a nullable where a tagged union belongs — discards distinctions the type system could have enforced. Downstream code that needed those distinctions now reconstructs them heuristically or silently operates on impoverished data. The right type is the one that can represent everything the domain requires, not the one most convenient for the current caller.
-- **Optimize for the next edit, not the current diff.** After any change, ask: what does the person who touches this next have to understand? If they have to decode why two representations coexist, what a "temporary" bridge is doing, or which of two APIs is canonical — the work isn't done.
-
 # Procedure
 ## 1. Scope
 {{#if skills.length}}- You **MUST** read skills that match the task domain before starting.{{/if}}
@@ -353,6 +330,7 @@ Design integrity means the code tells the truth about what the system currently
 > a. Semantic edits to files that don't import each other or share types being changed
 > b. Investigating multiple subsystems
 > c. Work that decomposes into independent pieces wired together at the end
+- Multiple edits to different sections of the same file are independent — stable hash anchors make them safe to batch. Issue them in one response rather than sequentially.
 - When a plan feels too large for a single turn, parallelize aggressively — do **NOT** abandon phases, silently drop them, or narrate scope cuts. Scope pressure is a signal to delegate, not to shrink the work.
 {{/has}}
 - Justify sequential work; default parallel. If you cannot articulate why B depends on A, it doesn't.
@@ -362,18 +340,16 @@ Design integrity means the code tells the truth about what the system currently
 - Marking a todo done is a transition, not a stop: in the same turn, start the next pending todo. Acceptable inter-phase text is one short line ("phase 1 done, starting phase 2") — not a recap, not a question.
 
 ## 5. While working
-You are not making code that works. You are making code that communicates — to callers, to the system it lives in, to whoever changes it next.
-- **One job, one level of abstraction.** If you need "and" to describe what something does, it should be two things. Code that mixes levels — orchestrating a flow while also handling parsing, formatting, or low-level manipulation — has no coherent owner and no coherent test. Each piece operates at one level and delegates everything else.
-- **Fix where the invariant is violated, not where the violation is observed.** If a function returns the wrong thing, fix the function — not the caller's workaround. If a type is wrong, fix the type — not the cast. The right fix location is always where the contract is broken.
-- **New code makes old code obsolete. Remove it.** When you introduce an abstraction, find what it replaces: old helpers, compatibility branches, stale tests, documentation describing removed behavior. Remove them in the same change.
-- **No forwarding addresses.** Deleted or moved code leaves no trace — no `// moved to X` comments, no re-exports from the old location, no aliases kept "for now," no renaming unused parameters to `_var`, no `// removed` tombstones. If something is unused, delete it completely.
-- **Prefer editing over creating.** Do not create new files unless they are necessary to achieve the goal. Editing an existing file prevents file bloat and builds on existing work. A new file must earn its existence.
-- **After writing, inhabit the call site.** Read your own code as someone who has never seen the implementation. Does the interface honestly reflect what happened? Is any accepted input silently discarded? Does any pattern exist in more than one place? Fix it.
-- When a tool call fails, read the full error before doing anything else. If a file changed since you last read it, re-read before editing.
-{{#has tools "ask"}}- Ask before destructive commands like `git checkout/restore/reset`, overwriting changes, or deleting code you did not write.{{else}}- Do **NOT** run destructive git commands like `git checkout/restore/reset`, overwrite changes, or delete code you did not write.{{/has}}
-{{#has tools "web_search"}}- If stuck or uncertain, gather more information. Do **NOT** pivot approaches without cause.{{/has}}
-- If others may be editing concurrently, re-read changed files and adapt.
-- If blocked, exhaust tools and context first.
+Focus on clarity and correctness. Make code easy to understand now and in the future.
+- Fix problems at their source, not at their symptoms.
+- Remove obsolete or unused code — no leftover comments, aliases, or re-exports.
+- Prefer updating existing files over creating new ones, unless a new file is necessary.
+- After editing, review from a user's perspective. Make sure your changes are clear and the interface matches behavior.
+- If a tool fails or a file changes, re-read before acting.
+{{#has tools "ask"}}- Ask before running destructive commands or deleting code you did not write.{{else}}- Do **NOT** run destructive git commands or delete code you did not write.{{/has}}
+{{#has tools "web_search"}}- If unsure, search for more information instead of guessing.{{/has}}
+- Adapt to concurrent edits by re-reading changed files.
+- Use all available tools and context before declaring a blocker.
 
 ## 6. Verification
 - Test rigorously. Prefer unit or end-to-end tests, you **MUST NOT** rely on mocks.

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

@@ -2,8 +2,8 @@ Performs structural AST-aware rewrites via native ast-grep.
 
 <instruction>
 - Use for codemods and structural rewrites where plain text replace is unsafe
-- `path` is required and accepts a file, directory, glob, comma-separated path list, or internal URL
-- Language is inferred from `path`; narrow `path` to one language for deterministic rewrites
+- `paths` is required and accepts an array of files, directories, globs, or internal URLs
+- Language is inferred from `paths`; narrow each call to one language for deterministic rewrites
 - Metavariables captured in `pat` (`$A`, `$$$ARGS`) are substituted into that entry's `out` template
 - **Patterns match AST structure, not text.** `$NAME` = one node (captured); `$_` = one without binding; `$$$NAME` = zero-or-more (lazy — stops at next matchable element); `$$$` = zero-or-more without binding. Use `$$$NAME`, **NOT** `$$NAME` — the two-dollar form is invalid. Metavariable names are UPPERCASE and **MUST** be the whole AST node — partial text like `prefix$VAR` or `"hello $NAME"` does NOT work
 - When the same metavariable appears twice, both occurrences **MUST** match identical code (`$A == $A` matches `x == x`, not `x == y`)
@@ -20,17 +20,17 @@ Performs structural AST-aware rewrites via native ast-grep.
 
 <examples>
 # Rename a call site across TypeScript files
-`{"ops":[{"pat":"oldApi($$$ARGS)","out":"newApi($$$ARGS)"}],"path":"src/**/*.ts"}`
+`{"ops":[{"pat":"oldApi($$$ARGS)","out":"newApi($$$ARGS)"}],"paths":["src/**/*.ts"]}`
 # Delete matching calls
-`{"ops":[{"pat":"console.log($$$ARGS)","out":""}],"path":"src/**/*.ts"}`
+`{"ops":[{"pat":"console.log($$$ARGS)","out":""}],"paths":["src/**/*.ts"]}`
 # Rewrite import source path
-`{"ops":[{"pat":"import { $$$IMPORTS } from \"old-package\"","out":"import { $$$IMPORTS } from \"new-package\""}],"path":"src/**/*.ts"}`
+`{"ops":[{"pat":"import { $$$IMPORTS } from \"old-package\"","out":"import { $$$IMPORTS } from \"new-package\""}],"paths":["src/**/*.ts"]}`
 # Modernize to optional chaining (same metavariable enforces identity)
-`{"ops":[{"pat":"$A && $A()","out":"$A?.()"}],"path":"src/**/*.ts"}`
+`{"ops":[{"pat":"$A && $A()","out":"$A?.()"}],"paths":["src/**/*.ts"]}`
 # Swap two arguments using captures
-`{"ops":[{"pat":"assertEqual($A, $B)","out":"assertEqual($B, $A)"}],"path":"tests/**/*.ts"}`
+`{"ops":[{"pat":"assertEqual($A, $B)","out":"assertEqual($B, $A)"}],"paths":["tests/**/*.ts"]}`
 # Python — convert print calls to logging
-`{"ops":[{"pat":"print($$$ARGS)","out":"logger.info($$$ARGS)"}],"path":"src/**/*.py"}`
+`{"ops":[{"pat":"print($$$ARGS)","out":"logger.info($$$ARGS)"}],"paths":["src/**/*.py"]}`
 </examples>
 
 <critical>

package/src/prompts/tools/ast-grep.md

@@ -2,8 +2,8 @@ Performs structural code search using AST matching via native ast-grep.
 
 <instruction>
 - Use when syntax shape matters more than raw text (calls, declarations, specific language constructs)
-- `path` is required and accepts a file, directory, glob, comma-separated path list, or internal URL
-- Language is inferred from `path`; narrow `path` to one language when mixed-language trees could cause parse noise
+- `paths` is required and accepts an array of files, directories, globs, or internal URLs
+- Language is inferred from `paths`; narrow each call to one language when mixed-language trees could cause parse noise
 - `pat` is a single AST pattern. Run separate calls for distinct unrelated patterns
 - **Patterns match AST structure, not text** — whitespace/formatting is ignored
 - `$NAME` captures one node; `$_` matches one without binding; `$$$NAME` captures zero-or-more (lazy — stops at next matchable element); `$$$` matches zero-or-more without binding. Use `$$$NAME`, **NOT** `$$NAME` — the two-dollar form is invalid and produces a parse error
@@ -13,7 +13,7 @@ Performs structural code search using AST matching via native ast-grep.
 - C++ qualified calls used as expression statements need the statement semicolon in the pattern: use `ns::doThing($ARG);`, `$CALLEE($ARG);`, or wrap a statement snippet. Without `;`, tree-sitter-cpp may parse `ns::doThing($ARG)` as declaration-like syntax and return no matches
 - For TS declarations/methods, tolerate unknown annotations: `async function $NAME($$$ARGS): $_ { $$$BODY }` or `class $_ { method($ARG: $_): $_ { $$$BODY } }`
 - Declaration forms are structurally distinct — top-level `function foo`, class method `foo()`, and `const foo = () => {}` are different AST shapes; search the right form before concluding absence
-- Loosest existence check: `pat: "executeBash"` with a narrow `path`
+- Loosest existence check: `pat: "executeBash"` with narrow `paths`
 </instruction>
 
 <output>
@@ -24,19 +24,19 @@ Performs structural code search using AST matching via native ast-grep.
 
 <examples>
 # Search TypeScript files under src
-`{"pat":"console.log($$$)","path":"src/**/*.ts"}`
+`{"pat":"console.log($$$)","paths":["src/**/*.ts"]}`
 # Named imports from a specific package
-`{"pat":"import { $$$IMPORTS } from \"react\"","path":"src/**/*.ts"}`
+`{"pat":"import { $$$IMPORTS } from \"react\"","paths":["src/**/*.ts"]}`
 # Arrow functions assigned to a const
-`{"pat":"const $NAME = ($$$ARGS) => $BODY","path":"src/utils/**/*.ts"}`
+`{"pat":"const $NAME = ($$$ARGS) => $BODY","paths":["src/utils/**/*.ts"]}`
 # Method call on any object, ignoring method name with `$_`
-`{"pat":"logger.$_($$$ARGS)","path":"src/**/*.ts"}`
+`{"pat":"logger.$_($$$ARGS)","paths":["src/**/*.ts"]}`
 # Loosest existence check for a symbol in one file
-`{"pat":"processItems","path":"src/worker.ts"}`
+`{"pat":"processItems","paths":["src/worker.ts"]}`
 </examples>
 
 <critical>
-- Avoid repo-root scans — narrow `path` first
-- Parse issues are query failure, not evidence of absence: repair the pattern or tighten `path` before concluding "no matches"
+- Avoid repo-root scans — narrow `paths` first
+- Parse issues are query failure, not evidence of absence: repair the pattern or tighten `paths` before concluding "no matches"
 - For broad/open-ended exploration across subsystems, use Task tool with explore subagent first
 </critical>

package/src/prompts/tools/eval.md

@@ -1,17 +1,19 @@
 Run code in a persistent kernel, using a series of codeblocks acting as cells.
 
 <instruction>
-Each cell is a markdown fenced code block. The opening fence's info string carries metadata:
+Each cell is introduced by a header line of the form:
 
 ```
-<lang>? <duration>? (title-fragment | key=value)*
+===== <info> =====
 ```
-- **Language**: {{#if py}}`py`/`python` for Python{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`js`/`javascript`/`ts`/`typescript` for JavaScript{{/if}}.{{#ifAll py js}} Omitted → inherit the previous cell's language (the first cell defaults to Python, falling back to JavaScript when Python is unavailable).{{else}} Omitted → inherit the previous cell's language.{{/ifAll}}
-- **Positional duration**: `15s`, `500ms`, `2m`, or a bare integer (seconds). Default 30s.
+
+where each side is at least 5 equal signs. Everything between one header and the next (or end of input) is the cell's code, verbatim. The info is space-separated tokens, all optional, in any order:
+- **Language**: {{#if py}}`py` for Python{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`js` / `ts` for JavaScript{{/if}}.{{#ifAll py js}} Omitted → inherit the previous cell's language (the first cell defaults to Python, falling back to JavaScript when Python is unavailable).{{else}} Omitted → inherit the previous cell's language.{{/ifAll}}
+- **Title shorthand**: `py:"…"`, `js:"…"`, `ts:"…"` set the language and the cell title together.
 - **Attributes**:
-  - `id="…"` — cell id (shown as the title in the transcript).
-  - `t=<duration>` — overrides the positional duration.
-  - `rst=true` — wipe **this cell's own language kernel** before running.{{#ifAll py js}} Other languages are untouched.{{/ifAll}}
+  - `id:"…"` — cell title (when language is unchanged or already set).
+  - `t:<duration>` — per-cell timeout. Duration is digits with optional `ms` / `s` / `m` units (e.g. `t:500ms`, `t:15s`, `t:2m`). Default 30s.
+  - `rst` — wipe **this cell's own language kernel** before running.{{#ifAll py js}} Other languages are untouched.{{/ifAll}}
 
 **Work incrementally:** one logical step per cell (imports, define, test, use). Pass multiple small cells in one call. Define small reusable functions you can debug individually. You **MUST** put workflow explanations in the assistant message or cell title — never inside cell code.
 
@@ -31,18 +33,6 @@ write(path, content) → str
     Write content to a file (creates parent directories). Returns the resolved path.
 append(path, content) → str
     Append content to a file. Returns the resolved path.
-stat(path) → {path, size, is_file, is_dir, mtime}
-    File or directory metadata. mtime is an ISO-8601 string.
-find(pattern, path?=".", type?="file", limit?=1000, hidden?=False, sort_by_mtime?=False, maxdepth?=None, mindepth?=None) → list[path]
-    Recursive glob find. Respects .gitignore.
-glob(pattern, path?=".", hidden?=False) → list[path]
-    Non-recursive glob. Use find() for recursive walks. Respects .gitignore.
-grep(pattern, path, ignore_case?=False, literal?=False, context?=0) → list[{line, text}]
-    Search a single file.
-rgrep(pattern, path?=".", glob_pattern?="*", ignore_case?=False, literal?=False, limit?=100, hidden?=False) → list[{file, line, text}]
-    Search recursively across files. Respects .gitignore.
-sed(path, pattern, repl, flags?=0) → int
-    Regex replace in a file (like sed -i). Returns replacement count.
 tree(path?=".", max_depth?=3, show_hidden?=False) → str
     Render a directory tree.
 diff(a, b) → str
@@ -63,30 +53,22 @@ Cells render like a Jupyter notebook. Pass any value to `display(value)`; non-pr
 </output>
 
 <caution>
-- In session mode, use `rst=true` on a cell to wipe its language's kernel before running.{{#ifAll py js}} Reset is per-language: a python cell's `rst=true` does not touch the JavaScript kernel and vice versa.{{/ifAll}}
+- In session mode, use `rst` on a cell to wipe its language's kernel before running.{{#ifAll py js}} Reset is per-language: a python cell's `rst` does not touch the JavaScript kernel and vice versa.{{/ifAll}}
 {{#if js}}- **js**: the VM exposes a selective `process` subset, Web APIs, `Buffer`, `fs/promises`.
 {{/if}}</caution>
 
 <example>
-{{#if py}}```py id="imports" t="10s"
+{{#if py}}===== py:"imports" t:10s =====
 import json
 from pathlib import Path
-```
 
-```py id="load config"
+===== py:"load config" =====
 data = json.loads(read('package.json'))
 display(data)
-```
 {{/if}}{{#ifAll py js}}
-
-{{/ifAll}}{{#if js}}```js id="js summary" rst=true
+{{/ifAll}}{{#if js}}===== js:"js summary" rst =====
 const data = JSON.parse(await read('package.json'));
 display(data);
 return data.name;
-```
-
-```
-return 'still JavaScript';
-```
 {{/if}}
 </example>

package/src/prompts/tools/find.md

@@ -1,6 +1,7 @@
 Finds files using fast pattern matching that works with any codebase size.
 
 <instruction>
+- `paths` is required and accepts an array of globs, files, or directories
 - You **SHOULD** perform multiple searches in parallel when potentially useful
 </instruction>
 
@@ -10,7 +11,7 @@ Matching file paths sorted by modification time (most recent first). Truncated a
 
 <examples>
 # Find files
-`{"pattern": "src/**/*.ts", "limit": 1000}`
+`{"paths": ["src/**/*.ts"], "limit": 1000}`
 </examples>
 
 <avoid>

package/src/prompts/tools/hashline.md

@@ -1,69 +1,78 @@
-Applies precise file edits using full anchors from `read` output (for example `160sr`).
+Your patch language is a compact, line-anchored edit format.
 
-Read the file first. Copy the full anchors exactly as shown by `read`.
+A patch contains one or more file sections. The first non-blank line of every edit section **MUST** be `@PATH`.
+Operations reference lines in the file by their line number and hash, called "Anchors", e.g. `5th`, `123ab`.
+You **MUST** copy them verbatim from the latest output for the file you're editing.
 
-<operations>
-**Top level**
-- `edits` — array of edit entries
-- `path` (required) — file path for all edits in this request
+This format is purely textual. The tool has NO awareness of language, indentation, brackets, fences, or table widths. You are responsible for emitting valid syntax in your replacements/insertions.
 
-**Edit entry**: `{ loc, content }`
-- `loc` — where to apply the edit (see below)
-- `content` — replacement/inserted lines (`string[]`, one element per line; `null` to delete)
+<ops>
+@PATH            header: subsequent ops apply to PATH
+< ANCHOR         insert lines BEFORE the anchored line (or BOF); payload follows as `|TEXT` lines
++ ANCHOR         insert lines AFTER  the anchored line (or EOF); payload follows as `|TEXT` lines
+- A..B           delete the line range (inclusive); `- A` for one line
+= A..B           replace the range with payload `|TEXT` lines, or with one blank line if no payload follows
+</ops>
 
-**`loc` values**
-- `"append"` / `"prepend"` — insert at end/start of file
-- `{ 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>
+<rules>
+- Every line of inserted/replacement content **MUST** be emitted as a payload line starting with `|`.
+- `|` is syntax, not content. The inserted text begins after the first `|`; use a bare `|` to insert a blank line.
+- `< A` inserts before line A; `+ A` inserts after line A. `< BOF` / `+ BOF` both prepend; `< EOF` / `+ EOF` both append.
+- `= A..B` replaces the inclusive range with the following payload lines. `= A` (or `= A..B`) with no payload blanks the range to a single empty line.
+- `- A..B` deletes the inclusive range; omit `..B` for one line.
+</rules>
+
+<case file="a.ts">
+{{hline 1 "const DEF = \"guest\";"}}
+{{hline 2 ""}}
+{{hline 3 "export function label(name) {"}}
+{{hline 4 "\tconst clean = name || DEF;"}}
+{{hline 5 "\treturn clean.trim();"}}
+{{hline 6 "}"}}
+</case>
 
 <examples>
-All examples below reference the same file:
+# Replace one line (preserve the leading tab from the original)
+@a.ts
+= {{hrefr 5}}
+|	return clean.trim().toUpperCase();
+
+# Replace a contiguous range with multiple lines
+@a.ts
+= {{hrefr 3}}..{{hrefr 6}}
+|export function label(name: string): string {
+|	const clean = (name || DEF).trim();
+|	return clean.length === 0 ? DEF : clean.toUpperCase();
+|}
+
+# Insert BEFORE a line
+@a.ts
+< {{hrefr 5}}
+|	const debug = false;
+
+# Insert AFTER a line
+@a.ts
++ {{hrefr 4}}
+|	if (clean.length === 0) return DEF;
+
+# Append to end of file
+@a.ts
++ EOF
+|export const done = true;
 
-```ts title="a.ts"
-{{hline  1 "// @ts-ignore"}}
-{{hline  2 "const timeout = 5000;"}}
-{{hline  3 "const tag = \"DO NOT SHIP\";"}}
-{{hline  4 ""}}
-{{hline  5 "function alpha() {"}}
-{{hline  6 "\tlog();"}}
-{{hline  7 "}"}}
-{{hline  8 ""}}
-{{hline  9 "function beta() {"}}
-{{hline 10 "\t// TODO: remove after migration"}}
-{{hline 11 "\tlegacy();"}}
-{{hline 12 "\ttry {"}}
-{{hline 13 "\t\treturn parse(data);"}}
-{{hline 14 "\t} catch (err) {"}}
-{{hline 15 "\t\tconsole.error(err);"}}
-{{hline 16 "\t\treturn null;"}}
-{{hline 17 "\t}"}}
-{{hline 18 "}"}}
-```
+# Delete a single line
+@a.ts
+- {{hrefr 2}}
 
-# Replace a block body
-Replace only the catch body. Do not target the shared boundary line `} catch (err) {`.
-`{path:"a.ts",edits:[{loc:{range:{pos:{{href 15}},end:{{href 16}}}},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 `}`.
-`{path:"a.ts",edits:[{loc:{range:{pos:{{href 6}},end:{{href 7}}}},content:["\tvalidate();","\tlog();","}"]}]}`
-**Wrong**: `end: {{href 6}}` — line 7 (`}`) survives AND content emits `}`, producing two closing braces.
-# Replace one line
-Single-line replace uses `pos == end`.
-`{path:"a.ts",edits:[{loc:{range:{pos:{{href 2}},end:{{href 2}}}},content:["const timeout = 30_000;"]}]}`
-# Delete a range
-`{path:"a.ts",edits:[{loc:{range:{pos:{{href 10}},end:{{href 11}}}},content:null}]}`
-# Insert before a sibling
-When adding a sibling declaration, prefer `prepend` on the next declaration.
-`{path:"a.ts",edits:[{loc:{prepend:{{href 9}}},content:["function gamma() {","\tvalidate();","}",""]}]}`
+# Blank a line in place (no payload required)
+@a.ts
+= {{hrefr 2}}
 </examples>
 
 <critical>
-- Make the minimum exact edit.
-- Copy the full anchors exactly as shown by `read/search` (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.
-- `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 — use project-specific linters or code formatters instead.
+- Always copy anchors exactly from tool output, but **NEVER** include line content after the `|` separator in the op line.
+- Only emit changed lines. Do not restate unchanged context as payload.
+- Every inserted/replacement content line **MUST** start with `|`; raw content lines are invalid.
+- Do not write unified diff syntax (`@@`, `-OLD`, `+NEW`).
+- To replace a block, use one `= A..B` op followed by all replacement `|TEXT` payload lines.
 </critical>

package/src/prompts/tools/search.md

@@ -2,13 +2,13 @@ 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` is required and accepts a file, directory, glob, comma-separated path list, or internal URL
+- `paths` is required and accepts an array of files, directories, globs, or internal URLs
 - Cross-line patterns are detected from literal `\n` or escaped `\\n` in `pattern`
 </instruction>
 
 <output>
 {{#if IS_HASHLINE_MODE}}
-- Text output is anchor-prefixed: `*123th|content` (match) or ` 123th|content` (context, leading space). The 2-letter ID is a content fingerprint.
+- Text output is anchor-prefixed: `*5th|content` (match) or ` 9x}|content` (context, leading space). The 2-char suffix is a content fingerprint.
 {{else}}
 {{#if IS_LINE_NUMBER_MODE}}
 - Text output is line-number-prefixed

package/src/session/session-manager.ts

@@ -870,8 +870,8 @@ function sanitizeSessionName(value: string | undefined): string | undefined {
 
 class RecentSessionInfo {
 	#fullName: string | undefined;
-	#name: string | undefined;
 	#timeAgo: string | undefined;
+	readonly #headerTimestamp: string | undefined;
 
 	constructor(
 		readonly path: string,
@@ -879,27 +879,31 @@ class RecentSessionInfo {
 		header: Record<string, unknown>,
 		firstPrompt?: string,
 	) {
-		// Extract title from session header, falling back to first user prompt, then id
+		// Prefer an explicit title, then the first user prompt. The raw UUID `id` is
+		// intentionally not used as a fallback: showing it as a "name" is unfriendly and
+		// indistinguishable from neighboring sessions in the UI. The friendly fallback is
+		// derived lazily in `fullName` from the session timestamp.
 		const trystr = (v: unknown) => (typeof v === "string" ? v : undefined);
-		this.#fullName =
-			sanitizeSessionName(trystr(header.title)) ??
-			sanitizeSessionName(firstPrompt) ??
-			sanitizeSessionName(trystr(header.id));
+		this.#fullName = sanitizeSessionName(trystr(header.title)) ?? sanitizeSessionName(firstPrompt);
+		this.#headerTimestamp = trystr(header.timestamp);
 	}
 
-	/** Full session name from header, or filename without extension as fallback */
+	/** Display name. Falls back to a timestamp-based label, never the raw UUID. */
 	get fullName(): string {
 		if (this.#fullName) return this.#fullName;
-		this.#fullName = this.path.split("/").pop()?.replace(".jsonl", "") ?? "Unknown";
+		const ts = this.#headerTimestamp ? Date.parse(this.#headerTimestamp) : Number.NaN;
+		const date = new Date(Number.isFinite(ts) ? ts : this.mtime);
+		const time = date.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" });
+		this.#fullName = `Untitled · ${time}`;
 		return this.#fullName;
 	}
 
-	/** Truncated name for display (max 40 chars) */
+	/**
+	 * Display name without an arbitrary length cap. The renderer is responsible for
+	 * width-aware truncation so adjacent fields (e.g. the relative time) stay visible.
+	 */
 	get name(): string {
-		if (this.#name) return this.#name;
-		const fullName = this.fullName;
-		this.#name = fullName.length <= 40 ? fullName : `${fullName.slice(0, 39)}…`;
-		return this.#name;
+		return this.fullName;
 	}
 
 	/** Human-readable relative time (e.g., "2 hours ago") */