@oh-my-pi/pi-coding-agent 13.7.1 → 13.7.4

package/src/patch/hashline.ts

@@ -412,10 +412,14 @@ export function validateLineRef(ref: { line: number; hash: string }, fileLines:
 }
 
 function isEscapedTabAutocorrectEnabled(): boolean {
-	const value = Bun.env.PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS;
-	if (value === "0") return false;
-	if (value === "1") return true;
-	return true;
+	switch (Bun.env.PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS) {
+		case "0":
+			return false;
+		case "1":
+			return true;
+		default:
+			return true;
+	}
 }
 
 function maybeAutocorrectEscapedTabIndentation(edits: HashlineEdit[], warnings: string[]): void {
@@ -623,20 +627,19 @@ export function applyHashlineEdits(
 				} else {
 					const count = edit.end.line - edit.pos.line + 1;
 					const newLines = [...edit.lines];
-					const trailingReplacementLine = newLines[newLines.length - 1];
-					const nextSurvivingLine = fileLines[edit.end.line];
+					const trailingReplacementLine = newLines[newLines.length - 1]?.trimEnd();
+					const nextSurvivingLine = fileLines[edit.end.line]?.trimEnd();
 					if (
-						trailingReplacementLine !== undefined &&
-						trailingReplacementLine.trim().length > 0 &&
-						nextSurvivingLine !== undefined &&
-						trailingReplacementLine.trim() === nextSurvivingLine.trim() &&
+						trailingReplacementLine &&
+						nextSurvivingLine &&
+						trailingReplacementLine === nextSurvivingLine &&
 						// Safety: only correct when end-line content differs from the duplicate.
 						// If end already points to the boundary, matching next line is coincidence.
-						fileLines[edit.end.line - 1].trim() !== trailingReplacementLine.trim()
+						fileLines[edit.end.line - 1]?.trimEnd() !== trailingReplacementLine
 					) {
 						newLines.pop();
 						warnings.push(
-							`Auto-corrected range replace ${edit.pos.line}#${edit.pos.hash}-${edit.end.line}#${edit.end.hash}: removed trailing replacement line "${trailingReplacementLine.trim()}" that duplicated next surviving line`,
+							`Auto-corrected range replace ${edit.pos.line}#${edit.pos.hash}-${edit.end.line}#${edit.end.hash}: removed trailing replacement line "${trailingReplacementLine}" that duplicated next surviving line`,
 						);
 					}
 					fileLines.splice(edit.pos.line - 1, count, ...newLines);

package/src/patch/index.ts

@@ -129,10 +129,11 @@ export function stripNewLinePrefixes(lines: string[]): string[] {
 
 export function hashlineParseText(edit: string[] | string | null): string[] {
 	if (edit === null) return [];
-	const lines = stripNewLinePrefixes(Array.isArray(edit) ? edit : edit.split("\n"));
-	if (lines.length === 0) return [];
-	if (lines[lines.length - 1].trim() === "") return lines.slice(0, -1);
-	return lines;
+	if (typeof edit === "string") {
+		const normalizedEdit = edit.endsWith("\n") ? edit.slice(0, -1) : edit;
+		edit = normalizedEdit.replaceAll("\r", "").split("\n");
+	}
+	return stripNewLinePrefixes(edit);
 }
 
 const hashlineEditSchema = Type.Object(

package/src/prompts/tools/hashline.md

@@ -6,49 +6,31 @@ Applies precise file edits using `LINE#ID` tags from `read` output.
 3. You **MUST** submit one `edit` call per file with all operations, think your changes through before submitting.
 </workflow>
 
-<prohibited>
-You **MUST NOT** use this tool for formatting-only edits: reindenting, realigning, brace-style changes, whitespace normalization, or line-length wrapping. Any edit whose diff is purely whitespace is a formatting operation — run the appropriate formatter for the project instead.
-</prohibited>
-
 <operations>
-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`:
+**`path`** — the path to the file to edit.
+**`move`** — if set, move the file to the given path.
+**`delete`** — if true, delete the file.
+**`edits.[n].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:
+**`edits.[n].end`** — range replace only. The last line of the range (inclusive). Omit for single-line replace.
+**`edits.[n].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
-- `{ path: "…", edits: [{ op: "replace", pos: "N#ID", lines: null }] }` — delete one line
-- `{ path: "…", edits: [{ op: "replace", pos: "N#ID", end: "M#ID", lines: null }] }` — delete a range
-- `{ path: "…", edits: [{ op: "replace", pos: "N#ID", lines: […] }] }` — replace one line
-- `{ path: "…", edits: [{ op: "replace", pos: "N#ID", end: "M#ID", lines: […] }] }` — replace a range
-
-### Insert new lines
-- `{ path: "…", edits: [{ op: "prepend", pos: "N#ID", lines: […] }] }` — insert before tagged line
-- `{ path: "…", edits: [{ op: "prepend", lines: […] }] }` — insert at beginning of file (no tag)
-- `{ path: "…", edits: [{ op: "append", pos: "N#ID", lines: […] }] }` — insert after tagged line
-- `{ path: "…", edits: [{ op: "append", lines: […] }] }` — insert at end of file (no tag)
-
-### File-level controls
-- `{ path: "…", delete: true, edits: [] }` — delete the file
-- `{ path: "…", 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.
+Tags should be referenced from the last `read` output.
+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 per operation.
-2. **`end` is inclusive:** If `lines` includes a closing token (`}`, `]`, `)`, `);`, `},`), `end` **MUST** include the original boundary line. To delete a line while keeping neighbors, use `lines: null` — do not replace it with an adjacent line's content.
-3. **Copy indentation from `read` output:** Leading whitespace in `lines` **MUST** follow adjacent lines exactly. Do not reconstruct from memory.
-4. **Verify the splice before submitting:** For each edit op, mentally read the result:
-   - Does the last `lines` entry duplicate the line surviving after `end`? → extend `end` or remove the duplicate.
-   - Does the first `lines` entry duplicate the line before `pos`? → the edit is wrong.
-   - For `prepend`/`append`: does new code land inside or outside the enclosing block? Trace the braces.
+2. **Prefer insertion over neighbor rewrites:** You **SHOULD** anchor on structural boundaries (`}`, `]`, `},`), not interior lines.
+3. **Range end tag (inclusive):** `end` is inclusive and **MUST** point to the final line being replaced.
+   - If `lines` includes a closing boundary token (`}`, `]`, `)`, `);`, `},`), `end` **MUST** include the original boundary line.
+   - You **MUST NOT** set `end` to an interior line and then re-add the boundary token in `lines`; that duplicates the next surviving line.
 </rules>
 
 <recovery>
@@ -61,18 +43,56 @@ Every edit has `op`, `pos`, and `lines`. Range replaces also have `end`. Both `p
 {{hlinefull 23 "  const timeout: number = 5000;"}}
 ```
 ```
-{ op: "replace", pos: {{hlinejsonref 23 "  const timeout: number = 5000;"}}, lines: ["  const timeout: number = 30_000;"] }
+{
+  path: "…",
+  edits: [{
+    op: "replace",
+    pos: {{hlineref 23 "  const timeout: number = 5000;"}},
+    lines: ["  const timeout: number = 30_000;"]
+  }]
+}
 ```
 </example>
 
 <example name="delete lines">
 Single line — `lines: null` deletes entirely:
 ```
-{ op: "replace", pos: {{hlinejsonref 7 "// @ts-ignore"}}, lines: null }
+{
+  path: "…",
+  edits: [{
+    op: "replace",
+    pos: {{hlineref 7 "// @ts-ignore"}},
+    lines: null
+  }]
+}
 ```
 Range — add `end`:
 ```
-{ op: "replace", pos: {{hlinejsonref 80 "  // TODO: remove after migration"}}, end: {{hlinejsonref 83 "  }"}}, lines: null }
+{
+  path: "…",
+  edits: [{
+    op: "replace",
+    pos: {{hlineref 80 "  // TODO: remove after migration"}},
+    end: {{hlineref 83 "  }"}},
+    lines: null
+  }]
+}
+```
+</example>
+
+<example name="clear text but keep the line break">
+```ts
+{{hlinefull 14 "  placeholder: \"DO NOT SHIP\","}}
+```
+```
+{
+  path: "…",
+  edits: [{
+    op: "replace",
+    pos: {{hlineref 14 "  placeholder: \"DO NOT SHIP\","}},
+    lines: [""]
+  }]
+}
 ```
 </example>
 
@@ -83,37 +103,63 @@ Range — add `end`:
 {{hlinefull 62 "      return null;"}}
 {{hlinefull 63 "    }"}}
 ```
-Include the closing `}` in the replaced range — stopping one line short orphans the brace or duplicates it.
 ```
-{ op: "replace", pos: {{hlinejsonref 61 "      console.error(err);"}}, end: {{hlinejsonref 63 "    }"}}, lines: ["      if (isEnoent(err)) return null;", "      throw err;", "    }"] }
+{
+  path: "…",
+  edits: [{
+    op: "replace",
+    pos: {{hlineref 61 "      console.error(err);"}},
+    end: {{hlineref 63 "    }"}},
+    lines: [
+      "      if (isEnoent(err)) return null;",
+      "      throw err;",
+      "    }"
+    ]
+  }]
+}
 ```
 </example>
 
-<example name="insert inside a block (good vs bad)">
-Adding a method inside a class — anchor on the **closing brace**, not after it.
+<example name="inclusive end avoids duplicate boundary">
 ```ts
-{{hlinefull 20 "  greet() {"}}
-{{hlinefull 21 "    return \"hi\";"}}
-{{hlinefull 22 "  }"}}
-{{hlinefull 23 "}"}}
-{{hlinefull 24 ""}}
-{{hlinefull 25 "function other() {"}}
-```
-Bad — appends **after** closing `}` (method lands outside the class):
-```
-{ op: "append", pos: {{hlinejsonref 23 "}"}}, lines: ["  newMethod() {", "    return 1;", "  }"] }
-```
-Result — `newMethod` is a **top-level function**, not a class method:
-```
-}         ← class closes here
-  newMethod() {
-    return 1;
-  }
-```
-Good — prepends **before** closing `}` (method stays inside the class):
-```
-{ op: "prepend", pos: {{hlinejsonref 23 "}"}}, lines: ["  newMethod() {", "    return 1;", "  }"] }
-```
+{{hlinefull 70 "if (ok) {"}}
+{{hlinefull 71 "  run();"}}
+{{hlinefull 72 "}"}}
+{{hlinefull 73 "after();"}}
+```
+Bad — `end` stops before `}` while `lines` already includes `}`:
+```
+{
+  path: "…",
+  edits: [{
+    op: "replace",
+    pos: {{hlineref 70 "if (ok) {"}},
+    end: {{hlineref 71 "  run();"}},
+    lines: [
+      "if (ok) {",
+      "  runSafe();",
+      "}"
+    ]
+  }]
+}
+```
+Good — include original `}` in the replaced range when replacement keeps `}`:
+```
+{
+  path: "…",
+  edits: [{
+    op: "replace",
+    pos: {{hlineref 70 "if (ok) {"}},
+    end: {{hlineref 72 "}"}},
+    lines: [
+      "if (ok) {",
+      "  runSafe();",
+      "}"
+    ]
+  }]
+}
+```
+Also apply the same rule to `);`, `],`, and `},` closers: if replacement includes the closer token, `end` must include the original closer line.
 </example>
 
 <example name="insert between sibling declarations">
@@ -126,26 +172,62 @@ Good — prepends **before** closing `}` (method stays inside the class):
 {{hlinefull 49 "  runY();"}}
 {{hlinefull 50 "}"}}
 ```
-Use a trailing `""` to preserve the blank line between top-level sibling declarations.
 ```
-{ op: "prepend", pos: {{hlinejsonref 48 "function y() {"}}, lines: ["function z() {", "  runZ();", "}", ""] }
+{
+  path: "…",
+  edits: [{
+    op: "prepend",
+    pos: {{hlineref 48 "function y() {"}},
+    lines: [
+      "function z() {",
+      "  runZ();",
+      "}",
+      ""
+    ]
+  }]
+}
 ```
+Use a trailing `""` to preserve the blank line between top-level sibling declarations.
 </example>
 
 <example name="disambiguate anchors">
 Blank lines and repeated patterns (`}`, `return null;`) appear many times — never anchor on them when a unique line exists nearby.
 ```ts
-{{hlinefull 46 "}"}}
-{{hlinefull 47 ""}}
-{{hlinefull 48 "function processItem(item: Item) {"}}
+{{hlinefull 101 "}"}}
+{{hlinefull 102 ""}}
+{{hlinefull 103 "export function serialize(data: unknown): string {"}}
 ```
 Bad — anchoring on the blank line (ambiguous, may shift):
 ```
-{ op: "append", pos: {{hlinejsonref 47 ""}}, lines: ["function helper() { }"] }
+{
+  path: "…",
+  edits: [{
+    op: "append",
+    pos: {{hlineref 102 ""}},
+    lines: [
+      "function validate(data: unknown): boolean {",
+      "  return data != null && typeof data === \"object\";",
+      "}",
+      ""
+    ]
+  }]
+}
 ```
 Good — anchor on the unique declaration line:
 ```
-{ op: "prepend", pos: {{hlinejsonref 48 "function processItem(item: Item) {"}}, lines: ["function helper() { }", ""] }
+{
+  path: "…",
+  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>
 

package/src/slash-commands/builtin-registry.ts

@@ -1,3 +1,4 @@
+import { getOAuthProviders } from "@oh-my-pi/pi-ai";
 import type { SettingPath, SettingValue } from "../config/settings";
 import { settings } from "../config/settings";
 import type { InteractiveModeContext } from "../modes/types";
@@ -261,12 +262,27 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 	{
 		name: "login",
 		description: "Login with OAuth provider",
-		inlineHint: "[redirect URL]",
+		inlineHint: "[provider|redirect URL]",
 		allowArgs: true,
 		handle: (command, runtime) => {
 			const manualInput = runtime.ctx.oauthManualInput;
 			const args = command.args.trim();
 			if (args.length > 0) {
+				const matchedProvider = getOAuthProviders().find(provider => provider.id === args);
+				if (matchedProvider) {
+					if (manualInput.hasPending()) {
+						const pendingProvider = manualInput.pendingProviderId;
+						const message = pendingProvider
+							? `OAuth login already in progress for ${pendingProvider}. Paste the redirect URL with /login <url>.`
+							: "OAuth login already in progress. Paste the redirect URL with /login <url>.";
+						runtime.ctx.showWarning(message);
+						runtime.ctx.editor.setText("");
+						return;
+					}
+					void runtime.ctx.showOAuthSelector("login", matchedProvider.id);
+					runtime.ctx.editor.setText("");
+					return;
+				}
 				const submitted = manualInput.submit(args);
 				if (submitted) {
 					runtime.ctx.showStatus("OAuth callback received; completing login…");

package/src/task/executor.ts

@@ -41,7 +41,7 @@ import {
 } from "./types";
 
 const MCP_CALL_TIMEOUT_MS = 60_000;
-const ajv = new Ajv({ allErrors: true, strict: false });
+const ajv = new Ajv({ allErrors: true, strict: false, logger: false });
 
 /** Agent event types to forward for progress tracking. */
 const agentEventTypes = new Set<AgentEvent["type"]>([

package/src/task/render.ts

@@ -879,7 +879,9 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 
 	// Error message
 	if (result.error && (!success || mergeFailed) && (!aborted || result.error !== result.abortReason)) {
-		lines.push(`${continuePrefix}${theme.fg(mergeFailed ? "warning" : "error", truncateToWidth(result.error, 70))}`);
+		lines.push(
+			`${continuePrefix}${theme.fg(mergeFailed ? "warning" : "error", truncateToWidth(replaceTabs(result.error), 70))}`,
+		);
 	}
 
 	return lines;

package/src/tools/fetch.ts

@@ -1,8 +1,7 @@
 import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { htmlToMarkdown } from "@oh-my-pi/pi-natives";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
+import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { ptree, truncate } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { parseHTML } from "linkedom";
@@ -14,6 +13,7 @@ import { DEFAULT_MAX_BYTES, truncateHead } from "../session/streaming-output";
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { ensureTool } from "../utils/tools-manager";
+import { summarizeUrlWithKagi } from "../web/kagi";
 import { specialHandlers } from "../web/scrapers";
 import type { RenderResult } from "../web/scrapers/types";
 import { finalizeOutput, loadPage, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
@@ -423,12 +423,13 @@ function parseFeedToMarkdown(content: string, maxItems = 10): string {
 }
 
 /**
- * Render HTML to markdown using native, jina, trafilatura, lynx (in order of preference)
+ * Render HTML to markdown using kagi, jina, trafilatura, lynx (in order of preference)
  */
 async function renderHtmlToText(
 	url: string,
 	html: string,
 	timeout: number,
+	useKagiSummarizer: boolean,
 	userSignal?: AbortSignal,
 ): Promise<{ content: string; ok: boolean; method: string }> {
 	const signal = ptree.combineSignals(userSignal, timeout * 1000);
@@ -440,7 +441,20 @@ async function renderHtmlToText(
 		signal,
 	};
 
-	// Try jina first (reader API)
+	// Try Kagi Universal Summarizer first (if enabled and KAGI_API_KEY is configured)
+	if (useKagiSummarizer) {
+		try {
+			const kagiSummary = await summarizeUrlWithKagi(url, { signal });
+			if (kagiSummary && kagiSummary.length > 100 && !isLowQualityOutput(kagiSummary)) {
+				return { content: kagiSummary, ok: true, method: "kagi" };
+			}
+		} catch {
+			// Kagi failed, continue to next method
+			signal?.throwIfAborted();
+		}
+	}
+
+	// Try jina next (reader API)
 	try {
 		const jinaUrl = `https://r.jina.ai/${url}`;
 		const response = await fetch(jinaUrl, {
@@ -553,7 +567,13 @@ async function handleSpecialUrls(url: string, timeout: number, signal?: AbortSig
 /**
  * Main render function implementing the full pipeline
  */
-async function renderUrl(url: string, timeout: number, raw: boolean, signal?: AbortSignal): Promise<RenderResult> {
+async function renderUrl(
+	url: string,
+	timeout: number,
+	raw: boolean,
+	useKagiSummarizer: boolean,
+	signal?: AbortSignal,
+): Promise<RenderResult> {
 	const notes: string[] = [];
 	const fetchedAt = new Date().toISOString();
 	if (signal?.aborted) {
@@ -792,7 +812,7 @@ async function renderUrl(url: string, timeout: number, raw: boolean, signal?: Ab
 		}
 
 		// Step 6: Render HTML with lynx or html2text
-		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, signal);
+		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, useKagiSummarizer, signal);
 		if (!htmlResult.ok) {
 			notes.push("html rendering failed (lynx/html2text unavailable)");
 			const output = finalizeOutput(rawContent);
@@ -915,7 +935,8 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 			throw new ToolAbortError();
 		}
 
-		const result = await renderUrl(url, effectiveTimeout, raw, signal);
+		const useKagiSummarizer = this.session.settings.get("fetch.useKagiSummarizer");
+		const result = await renderUrl(url, effectiveTimeout, raw, useKagiSummarizer, signal);
 		const truncation = truncateHead(result.content, {
 			maxBytes: DEFAULT_MAX_BYTES,
 			maxLines: FETCH_DEFAULT_MAX_LINES,
@@ -1066,8 +1087,8 @@ export function renderFetchResult(
 			if (contentPreviewLines === undefined || lastExpanded !== expanded) {
 				const previewLimit = expanded ? 12 : 3;
 				const previewList = applyListLimit(contentLines, { headLimit: previewLimit });
-				const previewLines = previewList.items.map(line => truncate(line.trimEnd(), 120, "…"));
-				const remaining = Math.max(0, contentLines.length - previewLines.length);
+				const previewLines = previewList.items.map(line => line.trimEnd());
+				const remaining = Math.max(0, contentLines.length - previewList.items.length);
 				contentPreviewLines =
 					previewLines.length > 0
 						? previewLines.map(line => uiTheme.fg("dim", line))

package/src/tools/submit-result.ts

@@ -4,7 +4,7 @@
  * Subagents must call this tool to finish and return structured JSON output.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { sanitizeSchemaForStrictMode } from "@oh-my-pi/pi-ai/utils/schema";
+import { dereferenceJsonSchema, sanitizeSchemaForStrictMode } from "@oh-my-pi/pi-ai/utils/schema";
 import type { Static, TSchema } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import Ajv, { type ErrorObject, type ValidateFunction } from "ajv";
@@ -18,7 +18,7 @@ export interface SubmitResultDetails {
 	error?: string;
 }
 
-const ajv = new Ajv({ allErrors: true, strict: false });
+const ajv = new Ajv({ allErrors: true, strict: false, logger: false });
 
 function normalizeSchema(schema: unknown): { normalized?: unknown; error?: string } {
 	if (schema === undefined || schema === null) return {};
@@ -52,53 +52,6 @@ function formatAjvErrors(errors: ErrorObject[] | null | undefined): string {
 		.join("; ");
 }
 
-/**
- * Resolve all $ref references in a JSON Schema by inlining definitions.
- * Handles $defs and definitions at any nesting level.
- * Removes $defs/definitions from the output since all refs are inlined.
- */
-function resolveSchemaRefs(schema: Record<string, unknown>): Record<string, unknown> {
-	const defs: Record<string, Record<string, unknown>> = {};
-	const defsObj = schema.$defs ?? schema.definitions;
-	if (defsObj && typeof defsObj === "object" && !Array.isArray(defsObj)) {
-		for (const [name, def] of Object.entries(defsObj as Record<string, unknown>)) {
-			if (def && typeof def === "object" && !Array.isArray(def)) {
-				defs[name] = def as Record<string, unknown>;
-			}
-		}
-	}
-	if (Object.keys(defs).length === 0) return schema;
-
-	const inlining = new Set<string>();
-	function inline(node: unknown): unknown {
-		if (node === null || typeof node !== "object") return node;
-		if (Array.isArray(node)) return node.map(inline);
-		const obj = node as Record<string, unknown>;
-		const ref = obj.$ref;
-		if (typeof ref === "string") {
-			const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
-			if (match) {
-				const name = match[1];
-				const def = defs[name];
-				if (def) {
-					if (inlining.has(name)) return {};
-					inlining.add(name);
-					const resolved = inline(def);
-					inlining.delete(name);
-					return resolved;
-				}
-			}
-		}
-		const result: Record<string, unknown> = {};
-		for (const [key, value] of Object.entries(obj)) {
-			if (key === "$defs" || key === "definitions") continue;
-			result[key] = inline(value);
-		}
-		return result;
-	}
-	return inline(schema) as Record<string, unknown>;
-}
-
 export class SubmitResultTool implements AgentTool<TSchema, SubmitResultDetails> {
 	readonly name = "submit_result";
 	readonly label = "Submit Result";
@@ -168,11 +121,11 @@ export class SubmitResultTool implements AgentTool<TSchema, SubmitResultDetails>
 						: undefined;
 
 			if (sanitizedSchema !== undefined) {
-				const resolved = resolveSchemaRefs({
+				const resolved = dereferenceJsonSchema({
 					...sanitizedSchema,
 					description: schemaDescription,
 				});
-				dataSchema = Type.Unsafe(resolved);
+				dataSchema = Type.Unsafe(resolved as Record<string, unknown>);
 			} else {
 				dataSchema = Type.Record(Type.String(), Type.Any(), {
 					description: schemaError ? schemaDescription : "Structured JSON output (no schema specified)",

package/src/tui/output-block.ts

@@ -1,7 +1,7 @@
 /**
  * Bordered output container with optional header and sections.
  */
-import { ImageProtocol, padding, TERMINAL, visibleWidth } from "@oh-my-pi/pi-tui";
+import { ImageProtocol, padding, TERMINAL, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
 import { getSixelLineMask } from "../utils/sixel";
 import type { State } from "./types";
@@ -88,13 +88,12 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 				lines.push(line);
 				continue;
 			}
-			// Sections may receive content that was already padded to terminal width
-			// (e.g. from Text.render()). Trailing spaces would trigger truncateToWidth()
-			// to append an ellipsis even when the *semantic* content fits.
-			const text = truncateToWidth(line.trimEnd(), contentWidth);
-			const innerPadding = padding(Math.max(0, contentWidth - visibleWidth(text)));
-			const fullLine = `${contentPrefix}${text}${innerPadding}${contentSuffix}`;
-			lines.push(padToWidth(fullLine, lineWidth, bgFn));
+			const wrappedLines = wrapTextWithAnsi(line.trimEnd(), contentWidth);
+			for (const wrappedLine of wrappedLines) {
+				const innerPadding = padding(Math.max(0, contentWidth - visibleWidth(wrappedLine)));
+				const fullLine = `${contentPrefix}${wrappedLine}${innerPadding}${contentSuffix}`;
+				lines.push(padToWidth(fullLine, lineWidth, bgFn));
+			}
 		}
 	}
 

package/src/utils/tools-manager.ts

@@ -296,7 +296,7 @@ type EnsureToolOptions = {
 
 export async function ensureTool(tool: ToolName, silentOrOptions?: EnsureToolOptions): Promise<string | undefined> {
 	const { signal, silent = false, notify } = silentOrOptions ?? {};
-	const existingPath = await getToolPath(tool);
+	const existingPath = getToolPath(tool);
 	if (existingPath) {
 		return existingPath;
 	}