@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.2

package/src/prompts/tools/hashline.md

@@ -4,159 +4,143 @@ A patch contains one or more file sections. The first non-blank line of every ed
 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.
 
-Purely textual format. The tool has NO awareness of language, indentation, brackets, fences, or table widths. Emit valid syntax in replacements/insertions.
+Purely textual format. The tool has NO awareness of language, indentation, brackets, fences, or table widths. You MUST emit valid syntax in replacements/insertions.
 
 <ops>
 @@ PATH          header: subsequent ops apply to PATH
+Each op line is ONE of:
 + ANCHOR         insert lines AFTER  the anchored line (or EOF); payload follows as `{{hsep}}TEXT` lines
 < ANCHOR         insert lines BEFORE the anchored line (or BOF); payload follows as `{{hsep}}TEXT` lines
 - A..B           delete the line range (inclusive).
 = A..B           replace the range with payload `{{hsep}}TEXT` lines, or with one blank line if no payload follows.
 </ops>
 
+<format-reminder>
+Op lines carry no content — payload goes on the next line.
+
+WRONG: + 5pg| some code
+RIGHT: + 5pg
+       {{hsep}} some code
+
+A single `+`/`<`/`=` op accepts MANY `{{hsep}}` payload lines. To insert N consecutive lines, write ONE op followed by N payload lines — NEVER N ops with one payload each.
+
+WRONG (one op per inserted line, with fabricated anchors):
+  + 5pg
+  {{hsep}}first new line
+  + 6xx    ← FABRICATED
+  {{hsep}}second new line
+
+RIGHT (one op, many payload lines):
+  + 5pg
+  {{hsep}}first new line
+  {{hsep}}second new line
+</format-reminder>
+
 <rules>
-- Every line of inserted/replacement content MUST be emitted as a payload line starting with `{{hsep}}`.
-- `{{hsep}}` is syntax, not content. The inserted text begins after the first `{{hsep}}`; use a bare `{{hsep}}` to insert a blank line.
-- Payload is verbatim — don't escape unicode (write `—`, not `\u2014`).
-- `< 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..B` with no payload blanks the range to a single empty line.
-- `- A..B` deletes the inclusive range; `A..A` for one line.
-- **Choose a self-contained syntactic unit first.** If the change touches part of a multiline call, destructuring assignment, control-flow header, wrapper, or other construct, widen the range to include the whole construct before optimizing for size.
-- Only after the range is self-contained, pick the smallest op for the change: pure addition → `+`/`<`; pure deletion → `-`; `= A..B` ONLY when content inside `A..B` is actually being modified or removed.
+- Every payload line MUST start with `{{hsep}}`.
+- Payload is verbatim — NEVER escape unicode.
+- **Payload is only what's NEW relative to your range:**
+  - `=` replaces inside; NEVER include lines outside.
+  - `+`/`<` adds at the anchor; NEVER repeat line A or neighbors.
+  - Payload matching nearby content duplicates — drop it or widen.
+- **Pick a self-contained unit first.** Touching a multiline construct? Widen to the whole thing.
+- Then smallest op: add → `+`/`<`; delete → `-`; `=` ONLY when modifying inside.
 </rules>
 
 <brace-shapes>
-When your edit involves brace boundaries (`{` / `}`), prefer these shapes:
-- **Whole block replace/delete**: pick the range so it spans both halves of the brace pair — start on the line that ends with `{`, end on the matching `}`. For pure removal use `-` with empty payload; for replacement, the payload's first line ends with `{` and last line is the matching `}`.
-- **Signature-only edit**: if you are only changing the line that ends with `{` (function signature, control statement, etc.), use a one-line `=` on that opener; the body and matching `}` are untouched and stay outside the range.
-- **Insert inside a block**: anchor on the opener (`+ ANCHOR` after the `{` line) or just above the closer (`+ ANCHOR` after the last interior line); emit only the new interior lines. Do not include the surrounding `{` or `}` in the payload — they're already there.
-- **Range ending on `}`**: only end on `}` when that `}` is itself part of what you're changing. The line at B+1 should be blank, an opener (next block), or a signature — not another `}`. Otherwise extend B past the closer or stop one line earlier.
+When braces bound your edit, you SHOULD prefer these shapes:
+- **Whole block**: range spans `{` through matching `}`.
+- **Signature only**: one-line `=` on the opener; body untouched.
+- **Insert inside**: anchor on `{` or last interior line; NEVER repeat the braces.
+- **End on `}`**: only when that `}` is part of the change. Otherwise extend or stop earlier.
 </brace-shapes>
 
 <common-failures>
-- **Do not replay the line past your range.** For `= A..B`, never end the payload with content that already exists at B+1. Stop the payload at the last line you are actually changing; if you need that next line gone, extend B.
-- **Do not duplicate chunks inside one payload.** When emitting a long `=` payload, never paste the same multi-line block twice. If you catch yourself re-emitting an earlier run of lines, stop and rewrite the op.
-- **Anchor only inside the visible region.** If the read output around your `=`/`-` end anchor is truncated (you cannot see the line at B+1), issue a fresh `read` before editing — anchoring blind drops or duplicates the boundary line.
-- **Prefer the narrowest self-contained edit.** Once your range cleanly contains the construct you are changing, a `+`/`<` insert plus a small `-` delete is almost always clearer and safer than a single wide `= A..B` that re-emits unchanged context.
-- **Anchors always reference the file as you last read it.** When stacking multiple `+`/`<`/`-`/`=` ops in one patch, NEVER mentally shift line numbers to account for prior ops in the same patch. Every op resolves against the original line numbering.
+- **NEVER replay past your range.** Stop before B+1; extend B if it must go.
+- **NEVER duplicate chunks inside one payload.** Caught re-emitting? Rewrite.
+- **Anchor only inside the visible region.** B+1 truncated? Re-`read` first.
+- **You SHOULD prefer the narrowest self-contained edit.** Small `+`/`-` beats wide `=`.
+- **Anchors reference the file as last read.** NEVER shift for prior ops.
+- **One `+`/`<` op per block, NOT per line.** N lines = ONE op, N payloads. Collapse adjacent ops.
+- **NEVER fabricate anchor hashes.** Missing? Re-`read`.
 </common-failures>
 
-<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>
-
-<case file="b.ts">
-{{hline 1 "const {"}}
-{{hline 2 "\tevents,"}}
-{{hline 3 "\tresponse,"}}
-{{hline 4 "\trequestId,"}}
-{{hline 5 "} = await getStreamResponse("}}
-{{hline 6 "\trequest,"}}
-{{hline 7 "\tsignal,"}}
-{{hline 8 ");"}}
-{{hline 9 "await notify(requestId);"}}
+<case file="mod.ts">
+{{hline 1 "const TITLE = \"Mr\";"}}
+{{hline 2 "export function greet(name) {"}}
+{{hline 3 "\treturn ["}}
+{{hline 4 "\t\tTITLE,"}}
+{{hline 5 "\t\tname?.trim() || \"guest\","}}
+{{hline 6 "\t].join(\" \");"}}
+{{hline 7 "}"}}
 </case>
 
 <examples>
-# Replace one line (preserve the leading tab from the original)
-@@ a.ts
-= {{hrefr 5}}..{{hrefr 5}}
-{{hsep}}	return clean.trim().toUpperCase();
-
-# Replace a contiguous range with multiple lines
-@@ a.ts
-= {{hrefr 4}}..{{hrefr 5}}
-{{hsep}}	const clean = (name || DEF).trim();
-{{hsep}}	return clean.length === 0 ? DEF : clean.toUpperCase();
-
-# Replace a full multiline destructuring/call statement
-@@ b.ts
-= {{hrefr 1}}..{{hrefr 8}}
-{{hsep}}const {
-{{hsep}}	events,
-{{hsep}}	response,
-{{hsep}}	requestId,
-{{hsep}}} = await getStreamResponse(
-{{hsep}}	request,
-{{hsep}}	signal,
-{{hsep}}	onEvent,
-{{hsep}});
-
-# Insert BEFORE a line
-@@ a.ts
-< {{hrefr 5}}
-{{hsep}}	const debug = false;
-
-# Insert AFTER a line
-@@ a.ts
+# Replace one line (the payload must re-emit the original indentation)
+@@ mod.ts
+= {{hrefr 1}}..{{hrefr 1}}
+{{hsep}}const TITLE = "Mrs";
+
+# Replace a full multiline statement (widen to a self-contained boundary)
+@@ mod.ts
+= {{hrefr 3}}..{{hrefr 6}}
+{{hsep}}	return [
+{{hsep}}		"Mrs",
+{{hsep}}		name?.trim() || "guest",
+{{hsep}}	].join(" ");
+
+# Insert AFTER/BEFORE a line
+@@ mod.ts
 + {{hrefr 4}}
-{{hsep}}	if (clean.length === 0) return DEF;
+{{hsep}}		"Dr",
+< {{hrefr 5}}
+{{hsep}}		"Dr",
 
-# Append to end of file
-@@ a.ts
+# Append to file
+@@ mod.ts
 + EOF
 {{hsep}}export const done = true;
 
-# Delete a single line
-@@ a.ts
-- {{hrefr 2}}..{{hrefr 2}}
+# Delete a line
+@@ mod.ts
+- {{hrefr 5}}..{{hrefr 5}}
 
-# Blank a line in place (no payload required)
-@@ a.ts
-= {{hrefr 2}}..{{hrefr 2}}
+# Blank a line (replace with LF)
+@@ mod.ts
+= {{hrefr 5}}..{{hrefr 5}}
 </examples>
 
 <anti-pattern>
-# WRONG — replaces 5 lines just to add one. Use `+` at the boundary instead.
-@@ a.ts
-= {{hrefr 1}}..{{hrefr 5}}
-{{hsep}}const DEF = "guest";
+# WRONG — replaces 2 lines just to add one.
+@@ mod.ts
+= {{hrefr 1}}..{{hrefr 2}}
+{{hsep}}const TITLE = "Mr";
 {{hsep}}const DEBUG = false;
-{{hsep}}
-{{hsep}}export function label(name) {
-{{hsep}}	const clean = name || DEF;
-{{hsep}}	return clean.trim();
-
+{{hsep}}export function greet(name) {
 # RIGHT — same effect, one-line insert
-@@ a.ts
+@@ mod.ts
 + {{hrefr 1}}
 {{hsep}}const DEBUG = false;
 
-# WRONG — continuation-fragment payload from the middle of a larger statement.
-@@ b.ts
-= {{hrefr 5}}..{{hrefr 7}}
-{{hsep}}} = await getStreamResponse(
-{{hsep}}	request,
-{{hsep}}	signal,
-{{hsep}}	onEvent,
-
-# RIGHT — widen to the full statement so the payload starts at a self-contained boundary.
-@@ b.ts
-= {{hrefr 1}}..{{hrefr 8}}
-{{hsep}}const {
-{{hsep}}	events,
-{{hsep}}	response,
-{{hsep}}	requestId,
-{{hsep}}} = await getStreamResponse(
-{{hsep}}	request,
-{{hsep}}	signal,
-{{hsep}}	onEvent,
-{{hsep}});
-
-If your replacement payload would render with even one unchanged line in the diff, or if the first or last payload line is only a continuation fragment from a larger construct (`} =`, `);`, `,`, `.method(`), you have the wrong op or range. Stop and widen to a self-contained boundary before minimizing the edit.
+# WRONG — replace from the middle of a larger statement (error-prone)
+@@ mod.ts
+= {{hrefr 4}}..{{hrefr 5}}
+{{hsep}}		"Dr",
+{{hsep}}		name?.trim() || "guest",
+# RIGHT — widen to the full statement
+@@ mod.ts
+= {{hrefr 3}}..{{hrefr 6}}
+{{hsep}}	return [
+{{hsep}}		"Dr",
+{{hsep}}		name?.trim() || "guest",
+{{hsep}}	].join(" ");
 </anti-pattern>
 
 <critical>
-- Always copy anchors exactly from tool output, but NEVER include line content after the `{{hsep}}` separator in the op line.
-- Every inserted/replacement content line MUST start with `{{hsep}}`; raw content lines are invalid.
-- Do not write unified diff syntax (`@@ -X,Y +X,Y @@`, `-OLD`, `+NEW`). The header is `@@ PATH`; line ops are `<`/`+`/`-`/`=`.
-- `= A..B` deletes the range; payload is what's written. If a payload edge line already exists immediately outside `A..B`, widen the range to cover it — otherwise it duplicates.
-- Multiple ops in one patch are cheap. Prefer two narrow ops over one wide `=`.
-  - Before choosing a `= A..B` range, mentally delete lines A through B. If that would split an unclosed bracket, paren, brace, or string/template from a line above A, or orphan a closing delimiter that belongs to an opener inside the range, you are bisecting a syntactic construct. Widen the range to a self-contained boundary, or use `+`/`-` instead.
-  - `= A..B` removes the range as a unit; the lines immediately outside it remain. If those outside lines form a wrapper (`try {`, `catch`, `if`, `else`, loop delimiters) you do not intend to delete, your payload is inserted inside that wrapper. Make sure the payload remains valid and preserves required behavior like error handling. If you need to change the wrapper itself, include it in the range and reproduce it.
+- Copy anchors verbatim (line number + 2-char hash); NEVER include the `|TEXT` body.
+- Every payload line MUST start with `{{hsep}}`; raw content is invalid.
+- NEVER write unified diff syntax. Header is `@@ PATH`; ops are `<`/`+`/`-`/`=`.
+- `= A..B` deletes the range; payload is what's written. Edge line matches just outside? Widen, or it duplicates.
+- Multiple ops are cheap. SHOULD prefer two narrow ops over one wide `=`.
+  - Before `= A..B`, mentally delete A..B. Splits an unclosed bracket/brace/string from above, or orphans a closer inside? You're bisecting a construct.
 </critical>

package/src/prompts/tools/read.md

@@ -1,45 +1,58 @@
-Reads the content at the specified path or URL.
+Read files, directories, archives, SQLite databases, images, documents, internal resources, and web URLs through a single `path` string.
 
 <instruction>
-The `read` tool is multi-purpose and more capable than it looks — inspects files, directories, archives, SQLite databases, images, documents (PDF/DOCX/PPTX/XLSX/RTF/EPUB/ipynb), **and URLs**.
-- You MUST parallelize reads when exploring related files
-- For URLs, `read` fetches the page and returns clean extracted text/markdown by default (reader-mode). It handles HTML pages, GitHub issues/PRs, Stack Overflow, Wikipedia, Reddit, NPM, arXiv, RSS/Atom, JSON endpoints, PDFs, etc. You SHOULD reach for `read` — not a browser/puppeteer tool — for fetching and inspecting web content.
+- One tool for filesystem, archives, SQLite, images, documents (PDF/DOCX/PPTX/XLSX/RTF/EPUB/ipynb), internal URIs, and web URLs (reader-mode by default).
+- You SHOULD parallelize independent reads when exploring related files.
+- You SHOULD reach for `read` — not a browser/puppeteer tool — for fetching web content.
+</instruction>
 
 ## Parameters
-- `path` — file path or URL (required). Append `:<sel>` for line ranges or raw mode (for example `src/foo.ts:50-200` or `src/foo.ts:raw`).
+
+- `path` — required. Local path, internal URI (`skill://`, `agent://`, `artifact://`, `memory://`, `rule://`, `local://`, `mcp://`), or URL. Append `:<sel>` for line ranges, raw mode, or special modes (e.g. `src/foo.ts:50-200`, `src/foo.ts:raw`, `db.sqlite:users:42`).
 
 ## Selectors
 
-|`path` suffix|Behavior|
-|---|---|
-|_(omitted)_|For parseable code files, return a structural summary. Otherwise read from the start (up to {{DEFAULT_LIMIT}} lines).|
-|`:50`|Read from line 50 onward|
-|`:50-200`|Read lines 50-200|
-|`:50+150`|Read 150 lines starting at line 50|
-|`:20+1`|Read exactly one line|
-|`:raw`|Read verbatim text without anchors or summarization|
-|`:conflicts`|Return a one-line-per-block index of every merge conflict in the file|
+Append `:<sel>` to `path`. The bare path falls back to the default mode.
+
+- _(none)_ — parseable code → structural summary (signatures kept, bodies elided); other files → read from the start (up to {{DEFAULT_LIMIT}} lines).
+- `:50` — read from line 50 onward.
+- `:50-200` — lines 50–200 inclusive.
+- `:50+150` — 150 lines starting at line 50.
+- `:20+1` — exactly one line.
+- `:5-16,960-973` — multiple ranges in one call (sorted, overlaps merged).
+- `:raw` — verbatim text; no anchors, no summary, no line prefixes.
+- `:2-4:raw` or `:raw:2-4` — range AND verbatim; the two compose in either order.
+- `:conflicts` — one-line-per-block index of every unresolved git merge conflict.
+
+# Files
+
+- Reading a directory path returns a depth-limited dirent listing.
+{{#if IS_HL_MODE}}
+- Reading a file with an explicit selector returns lines prefixed with `line+hash` anchors: `41th|def alpha():`. The 2-char hash is a content fingerprint that `edit` / `apply_patch` consume — copy it verbatim, NEVER fabricate.
+{{else}}
+{{#if IS_LINE_NUMBER_MODE}}
+- Reading a file with an explicit selector returns lines prefixed with line numbers: `41|def alpha():`.
+{{/if}}
+{{/if}}
+- Parseable code without a selector returns a **structural summary**: declarations kept, large bodies collapsed to `..` (merged brace pair) or `…` (standalone). Summarized output ends with a footer of the form:
+
+  `[NN lines across MM elided regions; read <path>:raw or a line range like <path>:1-9999 for verbatim content]`
 
-# Filesystem
-- Reading a directory path returns a list of dirents.
-  {{#if IS_HL_MODE}}
-- Reading a file with an explicit selector returns lines prefixed with anchors (line+hash): `41th|def alpha():`
-  {{else}}
-  {{#if IS_LINE_NUMBER_MODE}}
-- Reading a file with an explicit selector returns lines prefixed with line numbers: `41|def alpha():`
-  {{/if}}
-  {{/if}}
-- Reading a parseable code file without a selector returns a structural summary with signatures/declarations kept and large bodies collapsed to `…`. Use `:raw` or an explicit range such as `:1-9999` for verbatim content.
+  If the elided body is what you actually need, re-issue the **exact selector the footer names**. NEVER guess what's inside `..` / `…` — those markers carry no content.
 
-# Inspection
+# Documents & Notebooks
 
-Extracts text from PDF, Word, PowerPoint, Excel, RTF, EPUB, and Jupyter notebook files. Notebooks are shown as editable `# %% [type] cell:N` text; edits to that text are applied back to the underlying `.ipynb` JSON while preserving notebook metadata where possible. Can inspect images.
+Extracts text from PDF, Word, PowerPoint, Excel, RTF, and EPUB. Notebooks (`.ipynb`) are shown as editable `# %% [type] cell:N` text; edits round-trip back to the underlying JSON preserving notebook metadata. Add `:raw` to a notebook to bypass the converter and read the JSON directly.
 
-# Directories & Archives
+# Images
 
-Directories and archive roots return a list of entries. Supports `.tar`, `.tar.gz`, `.tgz`, `.zip`. Use `archive.ext:path/inside/archive` to read contents, and append a selector to the archive entry such as `archive.zip:dir/file.ts:50-60`.
+Reading an image path returns metadata (mime, bytes, dimensions, channels, alpha). For actual visual analysis, call `inspect_image` with the path and a question describing what to inspect.
 
-# SQLite Databases
+# Archives
+
+Supports `.tar`, `.tar.gz`, `.tgz`, `.zip`. Use `archive.ext:path/inside/archive` to read a member, and append a normal selector to the inner path: `archive.zip:dir/file.ts:50-60`.
+
+# SQLite
 
 For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
 - `file.db` — list tables with row counts
@@ -51,13 +64,19 @@ For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
 
 # URLs
 
-Extracts content from web pages, GitHub issues/PRs, Stack Overflow, Wikipedia, Reddit, NPM, arXiv, RSS/Atom feeds, JSON endpoints, PDFs at URLs, and similar text-based resources. Returns clean reader-mode text/markdown — no browser required. Use a `:raw` suffix for untouched HTML. URL line selectors mirror the file form (`:50`, `:50-100`, `:50+150`, `:raw`). If a URL would otherwise look like `host:port`, add a trailing slash before the selector (e.g. `https://example.com/:80`).
-</instruction>
+- Default reader-mode: HTML pages, GitHub issues/PRs, Stack Overflow, Wikipedia, Reddit, NPM, arXiv, RSS/Atom, JSON endpoints, PDFs → clean text/markdown.
+- `:raw` returns untouched HTML; line selectors (`:50`, `:50-100`, `:50+150`) paginate the cached fetched output.
+- Bare `host:port` URLs collide with the selector grammar — add a trailing slash before the selector: `https://example.com/:80`.
+
+# Internal URIs
+
+`skill://<name>`, `agent://<id>`, `artifact://<id>`, `memory://root`, `rule://<name>`, `local://<name>.md`, `mcp://<uri>` resolve transparently and accept the same line selectors as filesystem paths. Use `artifact://<id>` to recover full output that a previous bash/eval/tool result spilled or truncated.
 
 <critical>
-- You MUST use `read` for every file, directory, archive, and URL read. `cat`, `head`, `tail`, `less`, `more`, `ls`, `tar`, `unzip`, `curl`, and `wget` are **FORBIDDEN** for inspection — any such Bash call is a bug, regardless of how short or convenient it looks.
-- You MUST prefer `read` over a browser/puppeteer tool for fetching URL content; only use a browser if `read` fails to deliver reasonable content.
-- You MUST always include the `path` parameter — never call `read` with an empty argument object `{}`.
-- For specific line ranges, append the selector to `path` (e.g. `path="src/foo.ts:50-200"`, `path="src/foo.ts:50+150"`) — NEVER reach for `sed -n`, `awk NR`, or `head`/`tail` pipelines.
-- You MAY use path suffix selectors with URL reads; the tool paginates cached fetched output.
+- You MUST use `read` for every file, directory, archive, and URL inspection. `cat`, `head`, `tail`, `less`, `more`, `ls`, `tar`, `unzip`, `curl`, `wget` are FORBIDDEN — any such bash call is a bug, regardless of how short or convenient it looks.
+- You MUST prefer `read` over a browser/puppeteer tool for URL content; only reach for a browser when `read` cannot deliver reasonable content.
+- You MUST always include `path`. NEVER call `read` with `{}`.
+- For line ranges, append the selector to `path` (`path="src/foo.ts:50-200"`, `path="src/foo.ts:50+150"`). NEVER substitute `sed -n`, `awk NR`, or `head`/`tail` pipelines.
+- Summary footer says `read <path>:raw …`? Re-issue the exact selector it names. NEVER guess what's inside `..` / `…` markers — they carry no content.
+- You MAY combine selectors with URL reads and internal URIs; both paginate the cached resolved output.
 </critical>

package/src/prompts/tools/resolve.md

@@ -1,8 +1,9 @@
-Resolves a pending preview action by either applying or discarding it.
+Resolves a pending action by either applying or discarding it.
 - `action` is required:
-  - `"apply"` persists the pending changes.
-  - `"discard"` rejects the pending changes.
-- `reason` is required and must explain why you chose to apply or discard.
+  - `"apply"` persists / submits the pending action.
+  - `"discard"` rejects the pending action.
+- `reason` is required and must briefly explain why you chose to apply or discard.
+- `extra` (optional) is free-form metadata passed to the resolving tool. Schema depends on context:
 
-Only valid when a pending action exists (typically after a preview step).
+Valid whenever a pending action exists — either a preview-style staging (e.g. `ast_edit`) or a long-lived approval gate.
 Call fails with an error when no pending action exists.

package/src/sdk.ts

@@ -1044,7 +1044,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			getSessionSpawns: () => options.spawns ?? "*",
 			getModelString: () => (hasExplicitModel && model ? formatModelString(model) : undefined),
 			getActiveModelString,
-			getPlanModeState: () => session.getPlanModeState(),
+			getPlanModeState: () => session?.getPlanModeState(),
+			getGoalModeState: () => session?.getGoalModeState(),
+			getGoalRuntime: () => session?.goalRuntime,
 			getClientBridge: () => session?.clientBridge,
 			getCompactContext: () => session.formatCompactContext(),
 			getTodoPhases: () => session.getTodoPhases(),
@@ -1078,6 +1080,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 					timestamp: Date.now(),
 				}),
 			peekQueueInvoker: () => session.peekQueueInvoker(),
+			peekStandingResolveHandler: () => session.peekStandingResolveHandler(),
+			setStandingResolveHandler: handler => session.setStandingResolveHandler(handler),
 			allocateOutputArtifact: async toolType => {
 				try {
 					return await sessionManager.allocateArtifactPath(toolType);
@@ -1377,6 +1381,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		for (const tool of builtinTools) {
 			toolRegistry.set(tool.name, tool);
 		}
+		if (!toolRegistry.has("goal") && settings.get("goal.enabled")) {
+			const goalTool = await logger.time("createTools:goal:session", HIDDEN_TOOLS.goal, toolSession);
+			if (goalTool) {
+				toolRegistry.set(goalTool.name, wrapToolWithMetaNotice(goalTool));
+			}
+		}
 		for (const tool of wrappedExtensionTools) {
 			toolRegistry.set(tool.name, tool);
 		}
@@ -1503,7 +1513,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			(options.toolNames ? [...new Set(options.toolNames.map(name => name.toLowerCase()))] : undefined) ??
 			toolNamesFromRegistry;
 		const normalizedRequested = requestedToolNames.filter(name => toolRegistry.has(name));
-		const includeExitPlanMode = requestedToolNames.includes("exit_plan_mode");
 		// Effective discovery mode: tools.discoveryMode takes precedence; mcp.discoveryMode is back-compat alias.
 		const toolsDiscoveryModeSetting = settings.get("tools.discoveryMode");
 		const effectiveDiscoveryMode: "off" | "mcp-only" | "all" =
@@ -1516,9 +1525,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const defaultInactiveToolNames = new Set(
 			registeredTools.filter(tool => tool.definition.defaultInactive).map(tool => tool.definition.name),
 		);
-		const requestedActiveToolNames = includeExitPlanMode
-			? normalizedRequested
-			: normalizedRequested.filter(name => name !== "exit_plan_mode");
+		const requestedActiveToolNames = normalizedRequested.filter(name => name !== "goal");
 		const initialRequestedActiveToolNames = options.toolNames
 			? requestedActiveToolNames
 			: requestedActiveToolNames.filter(name => !defaultInactiveToolNames.has(name));