@oh-my-pi/pi-coding-agent 14.0.3 → 14.0.5

package/src/modes/theme/mermaid-cache.ts

@@ -1,7 +1,6 @@
 import { extractMermaidBlocks, logger, renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils";
 
-const cache = new Map<bigint, string>();
-const failed = new Set<bigint>();
+const cache = new Map<bigint | number, string | null>();
 
 let onRenderNeeded: (() => void) | null = null;
 
@@ -16,7 +15,7 @@ export function setMermaidRenderCallback(callback: (() => void) | null): void {
  * Get a pre-rendered mermaid ASCII diagram by hash.
  * Returns null if not cached or rendering failed.
  */
-export function getMermaidAscii(hash: bigint): string | null {
+export function getMermaidAscii(hash: bigint | number): string | null {
 	return cache.get(hash) ?? null;
 }
 
@@ -31,14 +30,14 @@ export function prerenderMermaid(markdown: string): void {
 	let hasNew = false;
 
 	for (const { source, hash } of blocks) {
-		if (cache.has(hash) || failed.has(hash)) continue;
+		if (cache.has(hash)) continue;
 
 		const ascii = renderMermaidAsciiSafe(source);
 		if (ascii) {
 			cache.set(hash, ascii);
 			hasNew = true;
 		} else {
-			failed.add(hash);
+			cache.set(hash, null);
 		}
 	}
 
@@ -58,7 +57,7 @@ export function prerenderMermaid(markdown: string): void {
  */
 export function hasPendingMermaid(markdown: string): boolean {
 	const blocks = extractMermaidBlocks(markdown);
-	return blocks.some(({ hash }) => !cache.has(hash) && !failed.has(hash));
+	return blocks.some(({ hash }) => !cache.has(hash));
 }
 
 /**
@@ -66,5 +65,4 @@ export function hasPendingMermaid(markdown: string): boolean {
  */
 export function clearMermaidCache(): void {
 	cache.clear();
-	failed.clear();
 }

package/src/modes/theme/theme.ts

@@ -20,6 +20,8 @@ import { defaultThemes } from "./defaults";
 import lightThemeJson from "./light.json" with { type: "json" };
 import { getMermaidAscii } from "./mermaid-cache";
 
+export { getLanguageFromPath } from "../../utils/lang-from-path";
+
 // ============================================================================
 // Symbol Presets
 // ============================================================================
@@ -2305,167 +2307,6 @@ export function highlightCode(code: string, lang?: string): string[] {
 	}
 }
 
-/**
- * Get language identifier from file path extension.
- */
-export function getLanguageFromPath(filePath: string): string | undefined {
-	const baseName = path.basename(filePath).toLowerCase();
-	if (baseName === ".env" || baseName.startsWith(".env.")) return "env";
-	if (
-		baseName === ".gitignore" ||
-		baseName === ".gitattributes" ||
-		baseName === ".gitmodules" ||
-		baseName === ".editorconfig" ||
-		baseName === ".npmrc" ||
-		baseName === ".prettierrc" ||
-		baseName === ".eslintrc"
-	) {
-		return "conf";
-	}
-	if (baseName === "dockerfile" || baseName.startsWith("dockerfile.") || baseName === "containerfile") {
-		return "dockerfile";
-	}
-	if (baseName === "justfile") return "just";
-	if (baseName === "cmakelists.txt") return "cmake";
-
-	const ext = filePath.split(".").pop()?.toLowerCase();
-	if (!ext) return undefined;
-
-	const extToLang: Record<string, string> = {
-		ts: "typescript",
-		cts: "typescript",
-		mts: "typescript",
-		tsx: "tsx",
-		js: "javascript",
-		jsx: "javascript",
-		mjs: "javascript",
-		cjs: "javascript",
-		py: "python",
-		pyi: "python",
-		rb: "ruby",
-		rbw: "ruby",
-		gemspec: "ruby",
-		rs: "rust",
-		go: "go",
-		java: "java",
-		kt: "kotlin",
-		ktm: "kotlin",
-		kts: "kotlin",
-		swift: "swift",
-		c: "c",
-		h: "c",
-		cpp: "cpp",
-		cc: "cpp",
-		cxx: "cpp",
-		hh: "cpp",
-		hpp: "cpp",
-		cu: "cpp",
-		ino: "cpp",
-		cs: "csharp",
-		clj: "clojure",
-		cljc: "clojure",
-		cljs: "clojure",
-		edn: "clojure",
-		php: "php",
-		sh: "bash",
-		bash: "bash",
-		zsh: "bash",
-		ksh: "bash",
-		bats: "bash",
-		tmux: "bash",
-		cgi: "bash",
-		fcgi: "bash",
-		command: "bash",
-		tool: "bash",
-		fish: "fish",
-		ps1: "powershell",
-		psm1: "powershell",
-		sql: "sql",
-		html: "html",
-		htm: "html",
-		xhtml: "html",
-		astro: "astro",
-		vue: "vue",
-		svelte: "svelte",
-		css: "css",
-		scss: "scss",
-		sass: "sass",
-		less: "less",
-		json: "json",
-		ipynb: "ipynb",
-		hbs: "handlebars",
-		hsb: "handlebars",
-		handlebars: "handlebars",
-		yaml: "yaml",
-		yml: "yaml",
-		toml: "toml",
-		xml: "xml",
-		xsl: "xml",
-		xslt: "xml",
-		svg: "xml",
-		plist: "xml",
-		md: "markdown",
-		markdown: "markdown",
-		mdx: "markdown",
-		diff: "diff",
-		patch: "diff",
-		dockerfile: "dockerfile",
-		containerfile: "dockerfile",
-		makefile: "make",
-		justfile: "just",
-		mk: "make",
-		mak: "make",
-		cmake: "cmake",
-		lua: "lua",
-		jl: "julia",
-		pl: "perl",
-		pm: "perl",
-		perl: "perl",
-		r: "r",
-		scala: "scala",
-		sc: "scala",
-		sbt: "scala",
-		ex: "elixir",
-		exs: "elixir",
-		erl: "erlang",
-		hs: "haskell",
-		nix: "nix",
-		odin: "odin",
-		zig: "zig",
-		star: "starlark",
-		bzl: "starlark",
-		sol: "solidity",
-		v: "verilog",
-		sv: "verilog",
-		svh: "verilog",
-		vh: "verilog",
-		m: "objc",
-		mm: "objc",
-		ml: "ocaml",
-		vim: "vim",
-		graphql: "graphql",
-		proto: "protobuf",
-		tf: "hcl",
-		hcl: "hcl",
-		tfvars: "hcl",
-		txt: "text",
-		text: "text",
-		log: "log",
-		csv: "csv",
-		tsv: "tsv",
-		ini: "ini",
-		cfg: "conf",
-		conf: "conf",
-		config: "conf",
-		properties: "conf",
-		tla: "tlaplus",
-		tlaplus: "tlaplus",
-		env: "env",
-	};
-
-	return extToLang[ext];
-}
-
 export function getSymbolTheme(): SymbolTheme {
 	const preset = theme.getSymbolPreset();
 

package/src/priority.json

@@ -25,5 +25,13 @@
 		"opus-4.1",
 		"opus-4-1",
 		"pro"
+	],
+	"designer": [
+		"google-gemini-cli/gemini-3.1-pro",
+		"google-gemini-cli/gemini-3-pro",
+		"gemini-3.1-pro",
+		"gemini-3-1-pro",
+		"gemini-3-pro",
+		"gemini-3"
 	]
 }

package/src/prompts/agents/designer.md

@@ -1,8 +1,7 @@
 ---
 name: designer
 description: UI/UX specialist for design implementation, review, visual refinement
-spawns: explore
-model: google-gemini-cli/gemini-3.1-pro, google-gemini-cli/gemini-3-pro, gemini-3.1-pro, gemini-3-1-pro, gemini-3-pro, gemini-3, pi/default
+model: pi/designer
 ---
 
 You are an expert UI/UX designer implementing and reviewing UI designs.

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

@@ -52,9 +52,29 @@ Push back when warranted: state the downside, propose an alternative, but **MUST
 <communication>
 - No emojis, filler, or ceremony.
 - (1) Correctness first, (2) Brevity second, (3) Politeness third.
-- User-supplied content **MUST** override any other guidelines.
+- Prefer concise, information-dense writing.
+- Avoid repeating the user's request or narrating routine tool calls.
 </communication>
 
+<instruction-priority>
+- User instructions override default style, tone, formatting, and initiative preferences.
+- Higher-priority system constraints about safety, permissions, tool boundaries, and task completion do not yield.
+- If a newer user instruction conflicts with an earlier user instruction, follow the newer one.
+- Preserve earlier instructions that do not conflict.
+</instruction-priority>
+
+<output-contract>
+- Brief preambles are allowed when they improve orientation, but they **MUST** stay short and **MUST NOT** be treated as completion.
+- Claims about code, tools, tests, docs, or external sources **MUST** be grounded in what you actually observed. If a statement is an inference, say so.
+- Apply brevity to prose, not to evidence, verification, or blocking details.
+</output-contract>
+
+<default-follow-through>
+- If the user's intent is clear and the next step is reversible and low-risk, proceed without asking.
+- Ask only when the next step is irreversible, has external side effects, or requires a missing choice that would materially change the outcome.
+- If you proceed, state what you did, what you verified, and what remains optional.
+</default-follow-through>
+
 <behavior>
 You **MUST** guard against the completion reflex — the urge to ship something that compiles before you've understood the problem:
 - Compiling ≠ Correctness. "It works" ≠ "Works in all cases".
@@ -248,6 +268,15 @@ Don't open a file hoping. Hope is not a strategy.
 {{#has tools "task"}}- `task` for investigate+edit in one pass — prefer this over a separate explore→task chain{{/has}}
 {{/ifAny}}
 
+<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, verify a dependency, or improve coverage.
+- Before taking an action, check whether prerequisite discovery, lookup, or memory retrieval is required. Resolve prerequisites first.
+- If a lookup is empty, partial, or suspiciously narrow, retry with a different strategy before concluding nothing exists.
+- When multiple retrieval steps are independent, parallelize them. When one result determines the next step, keep the workflow sequential.
+- After parallel retrieval, pause to synthesize before making more calls.
+</tool-persistence>
+
 {{#if (includes tools "inspect_image")}}
 ### Image inspection
 - For image understanding tasks: **MUST** use `inspect_image` over `read` to avoid overloading main session context.
@@ -262,7 +291,14 @@ These are inviolable. Violation is system failure.
 - You **MUST NOT** suppress tests to make code pass. You **MUST NOT** fabricate outputs not observed.
 - You **MUST NOT** solve the wished-for problem instead of the actual problem.
 - You **MUST NOT** ask for information obtainable from tools, repo context, or files.
-- You **MUST** always design a clean solution. You **MUST NOT** introduce unnecessary backwards compatibiltity layers, no shims, no gradual migration, no bridges to old code unless user explicitly asks for it. Let the errors guide you on what to include in the refactoring. **ALWAYS default to performing full CUTOVER!**
+- You **MUST** always design a clean solution. You **MUST NOT** introduce unnecessary backwards compatibility layers, no shims, no gradual migration, no bridges to old code unless user explicitly asks for it. Let the errors guide you on what to include in the refactoring. **ALWAYS default to performing full CUTOVER!**
+
+<completeness-contract>
+- Treat the task as incomplete until every requested deliverable is done or explicitly marked [blocked].
+- Keep an internal checklist of requested outcomes, implied cleanup, affected callsites, tests, docs, and follow-on edits.
+- For lists, batches, paginated results, or multi-file migrations, determine expected scope when possible and confirm coverage before yielding.
+- If something is blocked, label it [blocked], say exactly what is missing, and distinguish it from work that is complete.
+</completeness-contract>
 
 # Design Integrity
 
@@ -280,6 +316,7 @@ Design integrity means the code tells the truth about what the system currently
 {{#has tools "task"}}- You **MUST** determine if the task is parallelizable via `task` tool.{{/has}}
 - If multi-file or imprecisely scoped, you **MUST** write out a step-by-step plan, phased if it warrants, before touching any file.
 - For new work, you **MUST**: (1) think about architecture, (2) search official docs/papers on best practices, (3) review existing codebase, (4) compare research with codebase, (5) implement the best fit or surface tradeoffs.
+- If required context is missing, do **NOT** guess. Prefer tool-based retrieval first, ask a minimal question only when the answer cannot be recovered from tools, repo context, or files.
 ## 2. Before You Edit
 - Read the relevant section of any file before editing. Don't edit from a grep snippet alone — context above and below the match changes what the correct edit is.
 - You **MUST** grep for existing examples before implementing any pattern, utility, or abstraction. If the codebase already solves it, you **MUST** use that. Inventing a parallel convention is **PROHIBITED**.
@@ -313,6 +350,7 @@ When a tool call fails, read the full error before doing anything else. When a f
 - Test everything rigorously → Future contributor cannot break behavior without failure. Prefer unit/e2e.
 - You **MUST NOT** rely on mocks — they invent behaviors that never happen in production and hide real bugs.
 - You **SHOULD** run only tests you added/modified unless asked otherwise.
+- Before yielding, verify: (1) every requirement is satisfied, (2) claims match files/tool output/source material, (3) the output format matches the ask, and (4) any high-impact action was either verified or explicitly held for permission.
 - You **MUST NOT** yield without proof when non-trivial work, self-assessment is deceptive: tests, linters, type checks, repro steps… exhaust all external verification.
 
 {{#if secretsEnabled}}

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

@@ -3,58 +3,66 @@ Edits files via syntax-aware chunks. Run `read(path="file.ts")` first. The edit
 <rules>
 - **MUST** `read` first. Never invent chunk paths or CRCs. Copy them from the latest `read` output or edit response.
 - `sel` format:
-  - insertions: `chunk` or `chunk@region`
-  - replacements: `chunk#CRC` or `chunk#CRC@region`
-- Without a `@region` it defaults to the entire chunk including leading trivia. Valid regions: `head`, `body`, `tail`, `decl`.
+  - insertions: `chunk`, `chunk~`, or `chunk^`
+  - replacements: `chunk#CRC`, `chunk#CRC~`, or `chunk#CRC^`
+- Without a suffix it defaults to the entire chunk including leading trivia. `~` targets the body, `^` targets the head.
 - If the exact chunk path is unclear, run `read(path="file", sel="?")` and copy a selector from that listing.
-- 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 `@body` of a method, write the body starting at column 0:
+{{#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:
   ```
   content: "if (x) {\n\treturn true;\n}"
   ```
   The tool adds the correct base indent automatically. Never manually pad with the chunk's own indentation.
-- `@region` only works on container chunks (classes, functions, impl blocks, sections). Do **not** use `@head`/`@body`/`@tail` on leaf chunks (enum variants, fields, single statements) — use the whole chunk instead.
+{{else}}
+- Match the file's literal tabs/spaces in `content`. Do not convert indentation to canonical `\t`.
+- Write content at indent-level 0 relative to the target region. For example, to replace `~` of a method, write:
+  ```
+  content: "if (x) {\n  return true;\n}"
+  ```
+  The tool adds the correct base indent automatically, then preserves the tabs/spaces you used inside the snippet. Never manually pad with the chunk's own indentation.
+{{/if}}
+- Region suffixes only apply to container chunks (classes, functions, impl blocks, sections). On leaf chunks (enum variants, fields, single statements, and compound statements like `if`/`for`/`while`/`match`/`try`), `~` and `^` silently fall back to whole-chunk replacement — prefer the unsuffixed form and always supply the complete replacement (condition + body, not just the body) to avoid dropping structural parts.
 - `replace` requires the current CRC. Insertions do not.
-- **CRCs change after every edit.** Always use the selectors/CRCs from the most recent `read` or edit response. Never reuse a CRC from a previous edit.
+- **CRCs change after every edit.** The edit response always carries the new CRCs — use those for the next call or run `read(path="file", sel="?")` to refresh. Never reuse a CRC from before the latest edit.
 </rules>
 
 <critical>
 You **MUST** use the narrowest region that covers your change. Replacing without a region replaces the **entire chunk including leading comments, decorators, and attributes** — omitting them from `content` deletes them.
 
-**`replace` is total, not surgical.** The `content` you supply becomes the *complete* new content for the targeted region. Everything in the original region that you omit from `content` is deleted. Before replacing `@body` on any chunk, verify the chunk does not contain children you intend to keep. If a chunk spans hundreds of lines and your change touches only a few, target a specific child chunk — not the parent.
+**`replace` is total, not surgical.** The `content` you supply becomes the *complete* new content for the targeted region. Everything in the original region that you omit from `content` is deleted. Before replacing `~` on any chunk, verify the chunk does not contain children you intend to keep. If a chunk spans hundreds of lines and your change touches only a few, target a specific child chunk — not the parent.
 
-**Group chunks (`stmts_*`, `imports_*`, `decls_*`) are containers.** They hold many sibling items (test functions, import statements, declarations). Replacing `@body` on a group chunk replaces **all** of its children. To edit one item inside a group, target that item's own chunk path. If no child chunk exists, use the specific child's chunk selector from `read` output — do not replace the parent group.
+**Group chunks (`stmts_*`, `imports_*`, `decls_*`) are containers.** They hold many sibling items (test functions, import statements, declarations). Replacing `~` on a group chunk replaces **all** of its children. To edit one item inside a group, target that item's own chunk path. If no child chunk exists, use the specific child's chunk selector from `read` output — do not replace the parent group.
 </critical>
 
 <regions>
+Given a chunk like:
 ```
-  @head ··· ┊ /// doc comment
-          · ┊ #[attr]
-  @decl ··· ┊ fn foo(x: i32) {
-   @body ·· ┊     body();
-   @tail ·· ┊ }
+/// doc comment      <-- leading trivia
+#[attr]              <-- leading trivia
+fn foo(x: i32) {     <-- signature + opening delimiter
+    body();          <-- body
+}                    <-- closing delimiter
 ```
-- `@body` — the interior only. **Use for most edits.**
-- `@head` — leading trivia + signature + opening delimiter.
-- `@tail` — the closing delimiter.
-- `@decl` — everything except leading trivia (signature + body + closing delimiter).
-- *(no region)* — the entire chunk including leading trivia. Same as `@head` + `@body` + `@tail`.
 
-For leaf chunks (fields, variants, single-line items), `@body` falls back to the full chunk.
+Append `~` to target the body, `^` to target the head (trivia + signature), or nothing for the whole chunk:
+- `fn_foo#CRC~` — body only. **Use for most edits.** On leaf chunks, falls back to whole chunk.
+- `fn_foo#CRC^` — head (decorators, attributes, doc comments, signature, opening delimiter).
+- `fn_foo#CRC` — entire chunk including leading trivia.
+- `chunk~` + `append`/`prepend` inserts *inside* the container. `chunk` + `append`/`prepend` inserts *outside*.
+
+**Note on leading trivia:** whether a decorator/doc comment belongs to `^` depends on the parser. In Rust and Python, attributes and decorators are attached to the function chunk, so `^` covers them. In TypeScript/JavaScript, a `@decorator` + `/** jsdoc */` block immediately above a method often surfaces as a **separate sibling chunk** (shown as `chunk#CRC` in the `?` listing) rather than as part of the function's `^`. If you need to rewrite a decorator, check the `?` listing for a sibling `chunk#CRC` directly above your target.
 
-`append`/`prepend` without a `@region` inserts _outside_ the chunk. To add children _inside_ a class, struct, enum, or function body, use `@body`:
-- `class_Foo@body` + `append` → adds inside the class before `}`
-- `class_Foo@body` + `prepend` → adds inside the class after `{`
-- `class_Foo` + `append` → adds after the entire class (after `}`)
+**Note on non-code formats:** for prose and data formats (markdown, YAML, JSON, fenced code blocks, frontmatter), `^` and `~` fall back to the whole chunk. Always replace the entire chunk and include any delimiter syntax (fence backticks, `---` frontmatter markers, list markers) in your `content` — omitting them deletes them. For markdown sections (`sect_*`), always use unsuffixed whole-chunk replace — `^` and `~` on section containers also fall back to whole-chunk replace. When editing fenced code blocks in markdown, use the exact whitespace from the file (read with `raw` first) — the tool preserves literal indentation inside fenced blocks, but any content you supply is written verbatim. To insert content after a markdown section heading, use `after` on the heading chunk (`sect_*.chunk` or `sect_*.chunk_1`) — not `before`/`prepend` on the section itself, which lands physically before the heading and gets absorbed by the preceding section on reparse.
 </regions>
 
 <ops>
 |op|sel|effect|
 |---|---|---|
-|`replace`|`chunk#CRC(@region)?`|rewrite the addressed region|
-|`before`|`chunk(@region)?`|insert before the region span|
-|`after`|`chunk(@region)?`|insert after the region span|
-|`prepend`|`chunk(@region)?`|insert at the start inside the region|
-|`append`|`chunk(@region)?`|insert at the end inside the region|
+|`replace`|`chunk#CRC`, `chunk#CRC~`, or `chunk#CRC^`|rewrite the addressed region|
+|`before`|`chunk`, `chunk~`, or `chunk^`|insert before the region span|
+|`after`|`chunk`, `chunk~`, or `chunk^`|insert after the region span|
+|`prepend`|`chunk`, `chunk~`, or `chunk^`|insert at the start inside the region|
+|`append`|`chunk`, `chunk~`, or `chunk^`|insert at the end inside the region|
 </ops>
 
 <examples>
@@ -113,7 +121,11 @@ Given this `read` output for `example.ts`:
 
 **Replace a whole chunk** (rename a function):
 ~~~json
+{{#if chunkAutoIndent}}
 { "sel": "fn_createCounter#PQQY", "op": "replace", "content": "function makeCounter(start: number): Counter {\n\tconst c = new Counter();\n\tc.value = start;\n\treturn c;\n}\n" }
+{{else}}
+{ "sel": "fn_createCounter#PQQY", "op": "replace", "content": "function makeCounter(start: number): Counter {\n  const c = new Counter();\n  c.value = start;\n  return c;\n}\n" }
+{{/if}}
 ~~~
 Result — the entire chunk is rewritten:
 ```
@@ -124,9 +136,9 @@ function makeCounter(start: number): Counter {
 }
 ```
 
-**Replace a method body** (`@body`):
+**Replace a method body** (`~`):
 ```
-{ "sel": "class_Counter.fn_increment#NQWY@body", "op": "replace", "content": "this.value += 1;\nconsole.log('incremented to', this.value);\n" }
+{ "sel": "class_Counter.fn_increment#NQWY~", "op": "replace", "content": "this.value += 1;\nconsole.log('incremented to', this.value);\n" }
 ```
 Result — only the body changes, signature and braces are kept:
 ```
@@ -136,9 +148,9 @@ Result — only the body changes, signature and braces are kept:
   }
 ```
 
-**Replace a function header** (`@head` — signature and doc comment):
+**Replace a function header** (`^` — signature and doc comment):
 ```
-{ "sel": "fn_createCounter#PQQY@head", "op": "replace", "content": "/** Creates a counter with the given start value. */\nfunction createCounter(initial: number, label?: string): Counter {\n" }
+{ "sel": "fn_createCounter#PQQY^", "op": "replace", "content": "/** Creates a counter with the given start value. */\nfunction createCounter(initial: number, label?: string): Counter {\n" }
 ```
 Result — adds a doc comment and updates the signature, body untouched:
 ```
@@ -163,7 +175,11 @@ function createCounter(initial: number): Counter {
 
 **Insert after a chunk** (`after`):
 ~~~json
+{{#if chunkAutoIndent}}
 { "sel": "enum_Status", "op": "after", "content": "\nfunction isActive(s: Status): boolean {\n\treturn s === Status.Active;\n}\n" }
+{{else}}
+{ "sel": "enum_Status", "op": "after", "content": "\nfunction isActive(s: Status): boolean {\n  return s === Status.Active;\n}\n" }
+{{/if}}
 ~~~
 Result — a new function appears after the enum:
 ```
@@ -180,9 +196,9 @@ function isActive(s: Status): boolean {
 function createCounter(initial: number): Counter {
 ```
 
-**Prepend inside a container** (`@body` + `prepend`):
+**Prepend inside a container** (`~` + `prepend`):
 ```
-{ "sel": "class_Counter@body", "op": "prepend", "content": "label: string = 'default';\n\n" }
+{ "sel": "class_Counter~", "op": "prepend", "content": "label: string = 'default';\n\n" }
 ```
 Result — a new field is added at the top of the class body, before existing members:
 ```
@@ -192,9 +208,13 @@ class Counter {
   value: number = 0;
 ```
 
-**Append inside a container** (`@body` + `append`):
+**Append inside a container** (`~` + `append`):
 ~~~json
-{ "sel": "class_Counter@body", "op": "append", "content": "\nreset(): void {\n\tthis.value = 0;\n}\n" }
+{{#if chunkAutoIndent}}
+{ "sel": "class_Counter~", "op": "append", "content": "\nreset(): void {\n\tthis.value = 0;\n}\n" }
+{{else}}
+{ "sel": "class_Counter~", "op": "append", "content": "\nreset(): void {\n  this.value = 0;\n}\n" }
+{{/if}}
 ~~~
 Result — a new method is added at the end of the class body, before the closing `}`:
 ```
@@ -214,10 +234,18 @@ Result — a new method is added at the end of the class body, before the closin
 ```
 Result — the method is removed from the class.
 - 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 `@body` of a function: write at column 0, e.g. `"return x;\n"`. The tool adds the correct base indent.
-  - For `@head`: write at the chunk's own depth. A class member's head uses `"/** doc */\nstart(): void {"`.
+  - For `~` of a function: write at column 0, and use `\t` for *relative* nesting. Flat body: `"return x;\n"`. Nested body: `"if (cond) {\n\treturn x;\n}\n"` — the `if` is at column 0, the `return` is one tab in, and the tool adds the method's base indent to both.
+  - For `^`: write at the chunk's own depth. A class member's head uses `"/** doc */\nstart(): void {"`.
+{{#if chunkAutoIndent}}
   - For a top-level item: start at zero indent. Write `"function foo() {\n\treturn 1;\n}\n"`.
+{{else}}
+  - For a top-level item: start at zero indent. Write `"function foo() {\n  return 1;\n}\n"`.
+{{/if}}
   - The tool strips common leading indentation from your content as a safety net, so accidental over-indentation is corrected.
 </examples>

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

@@ -2,16 +2,25 @@ Reads files using syntax-aware chunks.
 
 <instruction>
 - `path` — file path or URL; may include `:selector` suffix
-- `sel` — optional selector: `class_Foo`, `class_Foo.fn_bar#ABCD@body`, `?`, `L50`, `L50-L120`, or `raw`
+- `sel` — optional selector: `class_Foo`, `class_Foo.fn_bar#ABCD~`, `?`, `L50`, `L50-L120`, or `raw`
 - `timeout` — seconds, for URLs only
 
 Each opening anchor `[< full.chunk.path#CCCC ]` in the default output identifies a chunk. Use `full.chunk.path#CCCC` as-is to read truncated chunks.
 If you need a canonical target list, run `read(path="file", sel="?")`. That listing shows chunk paths with CRCs.
 Line numbers in the gutter are absolute file line numbers.
 
+`L20` (single line, no explicit end) is shorthand for `L20` to end-of-file. Use `L20-L20` for a one-line window.
+
+{{#if chunkAutoIndent}}
+Chunk reads normalize leading indentation so copied content round-trips cleanly into chunk edits.
+{{else}}
+Chunk reads preserve literal leading tabs/spaces from the file. When editing, keep the same whitespace characters you see here.
+{{/if}}
+
 Chunk trees: JS, TS, TSX, Python, Rust, Go. Others use blank-line fallback.
 </instruction>
 
 <critical>
 - **MUST** `read` before editing — never invent chunk names or CRCs.
+    - Chunk names are truncated (e.g., `handleRequest` becomes `fn_handleRequ`). Always copy chunk paths from `read` or `?` output — never construct them from source identifiers.
 </critical>

package/src/sdk.ts

@@ -15,6 +15,7 @@ import { SearchDb } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import {
 	$env,
+	$flag,
 	getAgentDbPath,
 	getAgentDir,
 	getProjectDir,
@@ -1262,7 +1263,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	const repeatToolDescriptions = settings.get("repeatToolDescriptions");
 	const eagerTasks = settings.get("task.eager");
-	const intentField = settings.get("tools.intentTracing") || $env.PI_INTENT_TRACING === "1" ? INTENT_FIELD : undefined;
+	const intentField = settings.get("tools.intentTracing") || $flag("PI_INTENT_TRACING") ? INTENT_FIELD : undefined;
 	const rebuildSystemPrompt = async (toolNames: string[], tools: Map<string, AgentTool>): Promise<string> => {
 		toolContextStore.setToolNames(toolNames);
 		const discoverableMCPTools = mcpDiscoveryEnabled ? collectDiscoverableMCPTools(tools.values()) : [];

package/src/session/agent-session.ts

@@ -997,6 +997,16 @@ export class AgentSession {
 			this.#lastAssistantMessage = undefined;
 			if (!msg) return;
 
+			// Invalidate GitHub Copilot credentials on auth failure so stale tokens
+			// aren't reused on the next request
+			if (
+				msg.stopReason === "error" &&
+				msg.provider === "github-copilot" &&
+				msg.errorMessage?.includes("GitHub Copilot authentication failed")
+			) {
+				await this.#modelRegistry.authStorage.remove("github-copilot");
+			}
+
 			if (this.#skipPostTurnMaintenanceAssistantTimestamp === msg.timestamp) {
 				this.#skipPostTurnMaintenanceAssistantTimestamp = undefined;
 				return;

package/src/session/compaction/compaction.ts

@@ -761,7 +761,7 @@ function buildOpenAiNativeHistory(
 					if (!msgId) {
 						msgId = `msg_${msgIndex}`;
 					} else if (msgId.length > 64) {
-						msgId = `msg_${Bun.hash.xxHash64(msgId).toString(36)}`;
+						msgId = `msg_${Bun.hash(msgId).toString(36)}`;
 					}
 					input.push({
 						type: "message",

package/src/tools/ast-edit.ts

@@ -3,7 +3,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { type AstReplaceChange, astEdit } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
+import { $envpos, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { computeLineHash } from "../edit/line-hash";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -103,7 +103,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			if (maxReplacements !== undefined && (!Number.isFinite(maxReplacements) || maxReplacements < 1)) {
 				throw new ToolError("limit must be a positive number");
 			}
-			const maxFiles = parseInt(process.env.PI_MAX_AST_FILES ?? "", 10) || 1000;
+			const maxFiles = $envpos("PI_MAX_AST_FILES", 1000);
 
 			const formatScopePath = (targetPath: string): string => {
 				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");