@oh-my-pi/pi-coding-agent 15.1.0 → 15.1.2

package/src/extensibility/typebox.ts

@@ -12,7 +12,7 @@
  * the agent pipeline:
  *
  *   - `isZodSchema()` keys off the Zod `_zod` marker that every schema carries.
- *   - `zodToWireSchema()` emits the same draft-7 JSON Schema providers expect
+ *   - `zodToWireSchema()` emits the same draft 2020-12 JSON Schema providers expect
  *     from TypeBox-authored tools (defaulted fields treated as optional, etc.).
  *
  * The surface intentionally covers only the common TypeBox builders. Plugins

package/src/hashline/index.ts

@@ -11,4 +11,3 @@ export * from "./prefixes";
 export * from "./recovery";
 export * from "./stream";
 export * from "./types";
-export * from "./utils";

package/src/hashline/input.ts

@@ -2,7 +2,6 @@ import * as path from "node:path";
 import { ABORT_MARKER, BEGIN_PATCH_MARKER, END_PATCH_MARKER, FILE_HEADER_PREFIX } from "./constants";
 import { HL_EDIT_SEP } from "./hash";
 import type { SplitHashlineOptions } from "./types";
-import { stripTrailingCarriageReturn } from "./utils";
 
 export interface HashlineInputSection {
 	path: string;
@@ -64,8 +63,7 @@ function stripLeadingBlankLines(input: string): string {
 }
 
 export function containsRecognizableHashlineOperations(input: string): boolean {
-	for (const rawLine of input.split("\n")) {
-		const line = stripTrailingCarriageReturn(rawLine);
+	for (const line of input.split(/\r?\n/)) {
 		if (/^[+<=-]\s+/.test(line) || line.startsWith(HL_EDIT_SEP)) return true;
 	}
 	return false;
@@ -74,8 +72,8 @@ export function containsRecognizableHashlineOperations(input: string): boolean {
 function normalizeFallbackInput(input: string, options: SplitHashlineOptions): string {
 	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
 	const hasExplicitHeader = stripped
-		.split("\n")
-		.some(rawLine => parseHashlineHeaderLine(stripTrailingCarriageReturn(rawLine), options.cwd) !== null);
+		.split(/\r?\n/)
+		.some(rawLine => parseHashlineHeaderLine(rawLine, options.cwd) !== null);
 	if (hasExplicitHeader) return input;
 
 	if (!options.path || !containsRecognizableHashlineOperations(input)) return input;
@@ -91,8 +89,8 @@ export function splitHashlineInput(input: string, options: SplitHashlineOptions
 
 export function splitHashlineInputs(input: string, options: SplitHashlineOptions = {}): HashlineInputSection[] {
 	const stripped = stripLeadingBlankLines(normalizeFallbackInput(input, options));
-	const lines = stripped.split("\n");
-	const firstLine = stripTrailingCarriageReturn(lines[0] ?? "");
+	const lines = stripped.split(/\r?\n/);
+	const firstLine = lines[0] ?? "";
 
 	if (parseHashlineHeaderLine(firstLine, options.cwd) === null) {
 		const preview = JSON.stringify(firstLine.slice(0, 120));
@@ -108,13 +106,12 @@ export function splitHashlineInputs(input: string, options: SplitHashlineOptions
 
 	const flush = () => {
 		if (currentPath.length === 0) return;
-		const hasOps = currentLines.some(rawLine => stripTrailingCarriageReturn(rawLine).trim().length > 0);
+		const hasOps = currentLines.some(line => line.trim().length > 0);
 		if (hasOps) sections.push({ path: currentPath, diff: currentLines.join("\n") });
 		currentLines = [];
 	};
 
-	for (const rawLine of lines) {
-		const line = stripTrailingCarriageReturn(rawLine);
+	for (const line of lines) {
 		if (line.trimEnd() === END_PATCH_MARKER || line.trimEnd() === ABORT_MARKER) break;
 		if (isPatchEnvelopeMarker(line)) continue;
 		const header = parseHashlineHeaderLine(line, options.cwd);
@@ -123,7 +120,7 @@ export function splitHashlineInputs(input: string, options: SplitHashlineOptions
 			currentPath = header.path;
 			currentLines = [];
 		} else {
-			currentLines.push(rawLine);
+			currentLines.push(line);
 		}
 	}
 	flush();

package/src/hashline/parser.ts

@@ -1,7 +1,6 @@
 import { ABORT_MARKER, ABORT_WARNING, BEGIN_PATCH_MARKER, END_PATCH_MARKER, RANGE_INTERIOR_HASH } from "./constants";
 import { describeAnchorExamples, HL_EDIT_SEP, HL_HASH_CAPTURE_RE_RAW } from "./hash";
 import type { Anchor, HashlineCursor, HashlineEdit } from "./types";
-import { stripTrailingCarriageReturn } from "./utils";
 
 const LID_CAPTURE_RE = new RegExp(`^${HL_HASH_CAPTURE_RE_RAW}$`);
 
@@ -85,9 +84,9 @@ function collectPayload(
 	const payload: string[] = [];
 	let index = startIndex;
 	while (index < lines.length) {
-		const line = stripTrailingCarriageReturn(lines[index]);
+		const line = lines[index];
 		if (line.startsWith(HL_EDIT_SEP)) {
-			payload.push(line.slice(1));
+			payload.push(line.slice(1).trimEnd());
 			index++;
 			continue;
 		}
@@ -100,11 +99,10 @@ function collectPayload(
 		// when inserting a blank line.
 		if (line.length === 0) {
 			let lookahead = index + 1;
-			while (lookahead < lines.length && stripTrailingCarriageReturn(lines[lookahead]).length === 0) {
+			while (lookahead < lines.length && lines[lookahead].length === 0) {
 				lookahead++;
 			}
-			const followedByPayload =
-				lookahead < lines.length && stripTrailingCarriageReturn(lines[lookahead]).startsWith(HL_EDIT_SEP);
+			const followedByPayload = lookahead < lines.length && lines[lookahead].startsWith(HL_EDIT_SEP);
 			const acceptBareBlank = requirePayload && payload.length === 0;
 			if (followedByPayload || acceptBareBlank) {
 				for (let j = index; j < lookahead; j++) payload.push("");
@@ -127,7 +125,7 @@ export function parseHashline(diff: string): HashlineEdit[] {
 export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]; warnings: string[] } {
 	const edits: HashlineEdit[] = [];
 	const warnings: string[] = [];
-	const lines = diff.split("\n");
+	const lines = diff.split(/\r?\n/);
 	let editIndex = 0;
 
 	const pushInsert = (cursor: HashlineCursor, text: string, lineNum: number) => {
@@ -136,7 +134,7 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 
 	for (let i = 0; i < lines.length; ) {
 		const lineNum = i + 1;
-		const line = stripTrailingCarriageReturn(lines[i]);
+		const line = lines[i];
 
 		if (line.trim().length === 0) {
 			i++;

package/src/modes/acp/acp-agent.ts

@@ -1416,6 +1416,7 @@ export class AcpAgent implements Agent {
 		resetCapabilities();
 		const fileCommands = await loadSlashCommands({ cwd });
 		record.session.setSlashCommands(fileCommands);
+		await record.session.refreshSshTool({ activateIfAvailable: true });
 		await this.#emitAvailableCommandsUpdate(record);
 	}
 

package/src/modes/controllers/command-controller.ts

@@ -968,6 +968,7 @@ export class CommandController {
 			clearClaudePluginRootsCache(); // re-warms preloadedPluginRoots with new project dir (async)
 			resetCapabilities();
 			await this.ctx.refreshSlashCommandState(resolvedPath);
+			await this.ctx.session.refreshSshTool({ activateIfAvailable: true });
 
 			this.ctx.statusLine.invalidate();
 			this.ctx.updateEditorTopBorder();

package/src/modes/controllers/ssh-command-controller.ts

@@ -204,6 +204,7 @@ export class SSHCommandController {
 			if (compat) hostConfig.compat = true;
 
 			await addSSHHost(filePath, name, hostConfig);
+			await this.ctx.session.refreshSshTool({ activateIfAvailable: true });
 
 			const scopeLabel = scope === "user" ? "user" : "project";
 			const lines = [
@@ -364,6 +365,7 @@ export class SSHCommandController {
 			}
 
 			await removeSSHHost(filePath, name);
+			await this.ctx.session.refreshSshTool();
 
 			this.#showMessage(
 				["", theme.fg("success", `✓ Removed SSH host "${name}" from ${scope} config`), ""].join("\n"),

package/src/modes/theme/theme-schema.json

@@ -1,5 +1,5 @@
 {
-	"$schema": "http://json-schema.org/draft-07/schema#",
+	"$schema": "https://json-schema.org/draft/2020-12/schema",
 	"title": "OMP Coding Agent Theme",
 	"description": "Theme schema for the OMP coding agent",
 	"type": "object",

package/src/prompts/tools/hashline.md

@@ -143,4 +143,5 @@ When braces bound your edit, you SHOULD prefer these shapes:
 - `= 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.
+- NEVER use this tool to reformat code (indentation, whitespace, line wrapping, style). Run the project's formatter instead.
 </critical>

package/src/prompts/tools/read.md

@@ -15,7 +15,7 @@ Read files, directories, archives, SQLite databases, images, documents, internal
 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` / `: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.

package/src/sdk.ts

@@ -1428,6 +1428,17 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 		}
 
+		const reloadSshTool = async (): Promise<AgentTool | null> => {
+			if (!requestedToolNameSet.has("ssh")) return null;
+			const sshTool = (await loadSshTool({
+				...toolSession,
+				cwd: sessionManager.getCwd(),
+			})) as unknown as AgentTool | null;
+			if (!sshTool) return null;
+			const wrapped = wrapToolWithMetaNotice(sshTool);
+			return (extensionRunner ? new ExtensionToolWrapper(wrapped, extensionRunner) : wrapped) as AgentTool;
+		};
+
 		let cursorEventEmitter: ((event: AgentEvent) => void) | undefined;
 		const cursorExecHandlers = new CursorExecHandlers({
 			cwd,
@@ -1532,6 +1543,7 @@ 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 requestedToolNameSet = new Set(normalizedRequested);
 		// 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" =
@@ -1810,6 +1822,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			onResponse,
 			convertToLlm: convertToLlmFinal,
 			rebuildSystemPrompt,
+			reloadSshTool,
+			requestedToolNames: requestedToolNameSet,
 			getMcpServerInstructions: mcpManager
 				? () => {
 						const raw = mcpManager.getServerInstructions();

package/src/session/agent-session.ts

@@ -79,6 +79,7 @@ import {
 	Snowflake,
 } from "@oh-my-pi/pi-utils";
 import { type AsyncJob, AsyncJobManager } from "../async";
+import { reset as resetCapabilities } from "../capability";
 import type { Rule } from "../capability/rule";
 import { MODEL_ROLE_IDS, type ModelRegistry } from "../config/model-registry";
 import {
@@ -92,6 +93,7 @@ import {
 import { expandPromptTemplate, type PromptTemplate } from "../config/prompt-templates";
 import type { Settings, SkillsSettings } from "../config/settings";
 import { RawSseDebugBuffer } from "../debug/raw-sse-buffer";
+import { loadCapability } from "../discovery";
 import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "../edit";
 import {
 	disposeKernelSessionsByOwner,
@@ -153,6 +155,7 @@ import planModeToolDecisionReminderPrompt from "../prompts/system/plan-mode-tool
 import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
 import { type AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
 import { deobfuscateSessionContext, type SecretObfuscator } from "../secrets/obfuscator";
+import { invalidateHostMetadata } from "../ssh/connection-manager";
 import { resolveThinkingLevelForModel, toReasoningEffort } from "../thinking";
 import {
 	buildDiscoverableToolSearchIndex,
@@ -274,6 +277,9 @@ export interface AgentSessionConfig {
 	convertToLlm?: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
 	/** System prompt builder that can consider tool availability. Returns ordered provider-facing blocks. */
 	rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{ systemPrompt: string[] }>;
+	/** Rebuild the SSH tool from current capability discovery results. */
+	reloadSshTool?: () => Promise<AgentTool | null>;
+	requestedToolNames?: ReadonlySet<string>;
 	/**
 	 * Optional accessor for live MCP server instructions. Read by the session's
 	 * `rebuildSystemPrompt`-skip optimization to detect server-side instruction
@@ -736,6 +742,8 @@ export class AgentSession {
 		| ((toolNames: string[], tools: Map<string, AgentTool>) => Promise<{ systemPrompt: string[] }>)
 		| undefined;
 	#getMcpServerInstructions: (() => Map<string, string> | undefined) | undefined;
+	#reloadSshTool: (() => Promise<AgentTool | null>) | undefined;
+	#requestedToolNames: ReadonlySet<string> | undefined;
 	#baseSystemPrompt: string[];
 	/**
 	 * Signature of the (toolNames, tool descriptions) tuple passed to the most
@@ -868,6 +876,7 @@ export class AgentSession {
 		this.#modelRegistry = config.modelRegistry;
 		this.#validateRetryFallbackChains();
 		this.#toolRegistry = config.toolRegistry ?? new Map();
+		this.#requestedToolNames = config.requestedToolNames;
 		this.#transformContext = config.transformContext ?? (messages => messages);
 		this.#onPayload = config.onPayload;
 		this.rawSseDebugBuffer = config.rawSseDebugBuffer ?? new RawSseDebugBuffer();
@@ -886,6 +895,7 @@ export class AgentSession {
 		this.#convertToLlm = config.convertToLlm ?? convertToLlm;
 		this.#rebuildSystemPrompt = config.rebuildSystemPrompt;
 		this.#getMcpServerInstructions = config.getMcpServerInstructions;
+		this.#reloadSshTool = config.reloadSshTool;
 		this.#baseSystemPrompt = this.agent.state.systemPrompt;
 		this.#mcpDiscoveryEnabled = config.mcpDiscoveryEnabled ?? false;
 		this.#setDiscoverableMCPTools(this.#collectDiscoverableMCPToolsFromRegistry());
@@ -3000,6 +3010,45 @@ export class AgentSession {
 		}
 	}
 
+	/**
+	 * Reload the SSH tool from disk-backed capability discovery and make the
+	 * refreshed definition visible to the next model call without restarting.
+	 */
+	async refreshSshTool(options?: { activateIfAvailable?: boolean }): Promise<void> {
+		resetCapabilities();
+		if (!this.#reloadSshTool) return;
+		const previousSshTool = this.#toolRegistry.get("ssh");
+		const previousActiveToolNames = this.getActiveToolNames();
+		const hadSshTool = previousSshTool !== undefined;
+		const wasActive = previousActiveToolNames.includes("ssh");
+		const previousHostNames =
+			previousSshTool && "hostNames" in previousSshTool && Array.isArray(previousSshTool.hostNames)
+				? [...previousSshTool.hostNames]
+				: [];
+		const candidateHostNames = new Set(previousHostNames);
+		const capability = await loadCapability<{ name: string }>("ssh", { cwd: this.sessionManager.getCwd() });
+		for (const host of capability.items) {
+			if (typeof host?.name === "string") {
+				candidateHostNames.add(host.name);
+			}
+		}
+		await invalidateHostMetadata(candidateHostNames);
+		const sshAllowed = this.#requestedToolNames === undefined || this.#requestedToolNames.has("ssh");
+		const refreshedTool = await this.#reloadSshTool();
+		if (refreshedTool) {
+			this.#toolRegistry.set(refreshedTool.name, refreshedTool);
+		} else {
+			this.#toolRegistry.delete("ssh");
+			this.#selectedDiscoveredToolNames.delete("ssh");
+		}
+
+		const nextActive = previousActiveToolNames.filter(name => name !== "ssh" && this.#toolRegistry.has(name));
+		if (refreshedTool && sshAllowed && (wasActive || (options?.activateIfAvailable && !hadSshTool))) {
+			nextActive.push(refreshedTool.name);
+		}
+		await this.#applyActiveToolsByName(nextActive);
+	}
+
 	/**
 	 * Set active tools by name.
 	 * Only tools in the registry can be enabled. Unknown tool names are ignored.

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

@@ -1506,6 +1506,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			const projectPath = await resolveActiveProjectRegistryPath(runtime.ctx.sessionManager.getCwd());
 			clearPluginRootsAndCaches(projectPath ? [projectPath] : undefined);
 			await runtime.ctx.refreshSlashCommandState();
+			await runtime.ctx.session.refreshSshTool({ activateIfAvailable: true });
 			runtime.ctx.showStatus("Plugins reloaded.");
 			runtime.ctx.editor.setText("");
 		},
@@ -1632,6 +1633,7 @@ export async function executeBuiltinSlashCommand(
 				const projectPath = await resolveActiveProjectRegistryPath(ctx.sessionManager.getCwd());
 				clearPluginRootsAndCaches(projectPath ? [projectPath] : undefined);
 				await ctx.refreshSlashCommandState();
+				await ctx.session.refreshSshTool({ activateIfAvailable: true });
 			},
 		};
 		const result = await command.handle(parsed, adapted);

package/src/slash-commands/helpers/ssh.ts

@@ -142,6 +142,7 @@ async function handleRemoveCommand(rest: string, runtime: SlashCommandRuntime):
 	try {
 		const filePath = getSSHConfigPath(parsed.scope, runtime.cwd);
 		await removeSSHHost(filePath, parsed.name);
+		await runtime.session.refreshSshTool();
 		await runtime.output(`Removed SSH host "${parsed.name}" from ${parsed.scope} config.`);
 		return commandConsumed();
 	} catch (err) {
@@ -162,6 +163,7 @@ async function handleAddCommand(rest: string, runtime: SlashCommandRuntime): Pro
 	try {
 		const filePath = getSSHConfigPath(parsed.scope, runtime.cwd);
 		await addSSHHost(filePath, parsed.name, hostConfig);
+		await runtime.session.refreshSshTool({ activateIfAvailable: true });
 		await runtime.output(`Added SSH host "${parsed.name}" (${parsed.scope}).`);
 		return commandConsumed();
 	} catch (err) {

package/src/ssh/connection-manager.ts

@@ -55,6 +55,16 @@ function getHostInfoPath(name: string): string {
 	return path.join(HOST_INFO_DIR, `${sanitizeHostName(name)}.json`);
 }
 
+async function deleteHostInfoFromDisk(hostName: string): Promise<void> {
+	const path = getHostInfoPath(hostName);
+	try {
+		await fs.promises.unlink(path);
+	} catch (err) {
+		if (isEnoent(err)) return;
+		logger.warn("Failed to delete SSH host info", { host: hostName, error: String(err) });
+	}
+}
+
 async function validateKeyPermissions(keyPath?: string): Promise<void> {
 	if (!keyPath) return;
 	let stats: fs.Stats;
@@ -429,6 +439,23 @@ export async function ensureConnection(host: SSHConnectionTarget): Promise<void>
 	}
 }
 
+export async function invalidateHostMetadata(hostNames: Iterable<string>): Promise<void> {
+	const names = [...hostNames];
+	for (const hostName of names) {
+		hostInfoCache.delete(hostName);
+		await deleteHostInfoFromDisk(hostName);
+	}
+	for (const hostName of names) {
+		const activeHost = activeHosts.get(hostName);
+		if (activeHost) {
+			await closeConnectionInternal(activeHost);
+			activeHosts.delete(hostName);
+			continue;
+		}
+		await closeConnectionInternal({ name: hostName, host: hostName });
+	}
+}
+
 async function closeConnectionInternal(host: SSHConnectionTarget): Promise<void> {
 	if (!supportsSshControlMaster()) return;
 	const target = buildSshTarget(host.username, host.host);
@@ -436,13 +463,7 @@ async function closeConnectionInternal(host: SSHConnectionTarget): Promise<void>
 }
 
 export async function closeConnection(hostName: string): Promise<void> {
-	const host = activeHosts.get(hostName);
-	if (!host) {
-		await closeConnectionInternal({ name: hostName, host: hostName });
-		return;
-	}
-	await closeConnectionInternal(host);
-	activeHosts.delete(hostName);
+	await invalidateHostMetadata([hostName]);
 }
 
 export async function closeAllConnections(): Promise<void> {

package/src/tools/bash-interactive.ts

@@ -27,7 +27,7 @@ export interface BashInteractiveResult extends OutputSummary {
 }
 
 function normalizeCaptureChunk(chunk: string): string {
-	const normalized = chunk.replace(/\r\n/gu, "\n").replace(/\r/gu, "\n");
+	const normalized = chunk.replace(/\r\n?/gu, "\n");
 	return sanitizeWithOptionalSixelPassthrough(normalized, sanitizeText);
 }
 

package/src/tools/bash-pty-selection.ts

@@ -0,0 +1,14 @@
+import { $env } from "@oh-my-pi/pi-utils/env";
+
+/** Minimal UI-capability fields needed to decide whether bash can use the local PTY overlay. */
+export interface BashPtyContext {
+	hasUI?: boolean;
+	ui?: unknown;
+}
+
+/** Return whether a bash tool call should use the local interactive PTY overlay. */
+export function canUseInteractiveBashPty(pty: boolean, ctx: BashPtyContext | undefined): boolean {
+	if (!pty) return false;
+	if (process.platform === "win32") return false;
+	return $env.PI_NO_PTY !== "1" && ctx?.hasUI === true && ctx.ui !== undefined;
+}

package/src/tools/bash.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { ImageProtocol, TERMINAL, Text } from "@oh-my-pi/pi-tui";
-import { $env, getProjectDir, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
+import { getProjectDir, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import { AsyncJobManager } from "../async";
 import { type BashResult, executeBash } from "../exec/bash-executor";
@@ -20,6 +20,7 @@ import type { ToolSession } from ".";
 import { applyBashFixups, formatBashFixupNotice } from "./bash-command-fixup";
 import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-interactive";
 import { checkBashInterception } from "./bash-interceptor";
+import { canUseInteractiveBashPty } from "./bash-pty-selection";
 import { expandInternalUrls, type InternalUrlExpansionOptions } from "./bash-skill-urls";
 import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
 import { resolveToCwd } from "./path-utils";
@@ -807,9 +808,9 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		// Allocate artifact for truncated output storage
 		const { path: artifactPath, id: artifactId } = (await this.session.allocateOutputArtifact?.("bash")) ?? {};
 
-		const usePty = pty && $env.PI_NO_PTY !== "1" && ctx?.hasUI === true && ctx.ui !== undefined;
-		const result: BashResult | BashInteractiveResult = usePty
-			? await runInteractiveBashPty(ctx.ui!, {
+		const interactiveUi = canUseInteractiveBashPty(pty, ctx) ? ctx?.ui : undefined;
+		const result: BashResult | BashInteractiveResult = interactiveUi
+			? await runInteractiveBashPty(interactiveUi, {
 					command,
 					cwd: commandCwd,
 					timeoutMs,

package/src/tools/image-gen.ts

@@ -1075,7 +1075,7 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 					headers: {
 						"Content-Type": "application/json",
 						Authorization: `Bearer ${apiKey.apiKey}`,
-						"HTTP-Referer": "https://github.com/can1357/oh-my-pi",
+						"HTTP-Referer": "https://omp.sh/",
 						"X-OpenRouter-Title": "Oh-My-Pi",
 						"X-OpenRouter-Categories": "cli-agent",
 					},

package/src/tools/path-utils.ts

@@ -7,8 +7,8 @@ import { InternalUrlRouter } from "../internal-urls";
 import { ToolError } from "./tool-errors";
 
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-const FILE_LINE_RANGE_RE = /^(?:L?\d+(?:[-+]L?\d+)?(?:,L?\d+(?:[-+]L?\d+)?)*|raw|conflicts)$/i;
-const FILE_LINE_RANGE_ONLY_RE = /^L?\d+(?:[-+]L?\d+)?(?:,L?\d+(?:[-+]L?\d+)?)*$/i;
+const FILE_LINE_RANGE_RE = /^(?:L?\d+(?:[-+]L?\d+|-)?(?:,L?\d+(?:[-+]L?\d+|-)?)*|raw|conflicts)$/i;
+const FILE_LINE_RANGE_ONLY_RE = /^L?\d+(?:[-+]L?\d+|-)?(?:,L?\d+(?:[-+]L?\d+|-)?)*$/i;
 const FILE_RAW_ONLY_RE = /^raw$/i;
 const NARROW_NO_BREAK_SPACE = "\u202F";
 const TOP_LEVEL_INTERNAL_URL_PREFIXES = [

package/src/tools/read.ts

@@ -513,7 +513,7 @@ type ParsedSelector =
 	| { kind: "conflicts" }
 	| { kind: "lines"; ranges: [LineRange, ...LineRange[]]; raw?: boolean };
 
-const LINE_RANGE_RE = /^L?(\d+)(?:([-+])L?(\d+))?$/i;
+const LINE_RANGE_RE = /^L?(\d+)(?:([-+])L?(\d+)?)?$/i;
 
 /** Returns true when the selector requested verbatim/raw output (alone or combined with a range). */
 function isRawSelector(parsed: ParsedSelector): boolean {
@@ -541,10 +541,13 @@ function parseLineRangeChunk(sel: string): LineRange | null {
 		}
 		rawEnd = rawStart + rhs - 1;
 	} else if (sep === "-") {
-		if (rhs === undefined || rhs < rawStart) {
-			throw new ToolError(`Invalid range ${rawStart}-${rhs ?? 0}: end must be >= start.`);
+		// `301-` is shorthand for "from 301 onward" — equivalent to bare `301`.
+		if (rhs !== undefined) {
+			if (rhs < rawStart) {
+				throw new ToolError(`Invalid range ${rawStart}-${rhs}: end must be >= start.`);
+			}
+			rawEnd = rhs;
 		}
-		rawEnd = rhs;
 	}
 	return { startLine: rawStart, endLine: rawEnd };
 }

package/src/tools/search.ts

@@ -328,11 +328,18 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					return nextWidth;
 				}, 0);
 				const cacheEntries: Array<readonly [number, string]> = [];
+				let lastEmittedLine: number | undefined;
+				const gutterPad = " ".repeat(lineNumberWidth + 1);
 				for (const match of fileMatches) {
 					const pushLine = (lineNumber: number, line: string, isMatch: boolean, recordable: boolean) => {
+						if (lastEmittedLine !== undefined && lineNumber > lastEmittedLine + 1) {
+							modelOut.push("...");
+							displayOut.push(`${gutterPad}│...`);
+						}
 						modelOut.push(formatMatchLine(lineNumber, line, isMatch, { useHashLines }));
 						displayOut.push(formatCodeFrameLine(isMatch ? "*" : " ", lineNumber, line, lineNumberWidth));
 						if (recordable) cacheEntries.push([lineNumber, line] as const);
+						lastEmittedLine = lineNumber;
 					};
 					if (match.contextBefore) {
 						for (const ctx of match.contextBefore) {

package/src/tools/yield.ts

@@ -11,6 +11,7 @@ import {
 	type JsonSchemaValidationIssue,
 	type JsonSchemaValidationResult,
 	sanitizeSchemaForStrictMode,
+	tryEnforceStrictSchema,
 	validateJsonSchemaValue,
 } from "@oh-my-pi/pi-ai/utils/schema";
 import { subprocessToolRegistry } from "../task/subprocess-tool-registry";
@@ -140,15 +141,25 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 			const schemaDescription = schemaError
 				? `Structured JSON output (output schema invalid; accepting unconstrained object): ${schemaError}`
 				: `Structured output matching the schema:\n${schemaHint}`;
-			const sanitizedSchema =
+			let sanitizedSchema: Record<string, unknown> | undefined;
+			if (
 				!schemaError &&
 				normalizedSchema != null &&
 				typeof normalizedSchema === "object" &&
 				!Array.isArray(normalizedSchema)
-					? sanitizeSchemaForStrictMode(normalizedSchema as Record<string, unknown>)
-					: !schemaError && normalizedSchema === true
-						? {}
-						: undefined;
+			) {
+				const normalizedRecord = normalizedSchema as Record<string, unknown>;
+				const strictProbe = tryEnforceStrictSchema(normalizedRecord);
+				if (strictProbe.strict) {
+					sanitizedSchema = sanitizeSchemaForStrictMode(normalizedRecord);
+				} else {
+					sanitizedSchema = normalizedRecord;
+					this.strict = false;
+				}
+			} else if (!schemaError && normalizedSchema === true) {
+				sanitizedSchema = {};
+				this.strict = false;
+			}
 
 			let dataSchema: Record<string, unknown>;
 			if (sanitizedSchema !== undefined) {
@@ -161,6 +172,7 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 				}
 				dataSchema = resolved;
 			} else {
+				this.strict = false;
 				dataSchema = looseRecordSchema(
 					schemaError ? schemaDescription : "Structured JSON output (no schema specified)",
 				);

package/src/tui/code-cell.ts

@@ -77,13 +77,28 @@ function formatHeader(options: CodeCellOptions, theme: Theme): { title: string;
 	return { title: headerTitle, meta: metaParts.join(theme.fg("dim", theme.sep.dot)) };
 }
 
+/**
+ * Normalize terminal control characters that would otherwise corrupt TUI rendering:
+ * - Collapse `\r\n` to `\n`.
+ * - Within a line, treat `\r` as a cursor-return overwrite by keeping only the
+ *   final segment (mirrors how rsync/curl/pip progress bars render to a terminal).
+ * Splits on `\n` and returns the cleaned lines.
+ */
+function sanitizeTerminalLines(text: string): string[] {
+	return text.split(/\r?\n/).map(collapseCarriageReturns);
+}
+
+function collapseCarriageReturns(line: string): string {
+	const idx = line.lastIndexOf("\r");
+	return idx < 0 ? line : line.slice(idx + 1);
+}
 export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[] {
 	const { code, language, output, expanded = false, outputMaxLines = 6, codeMaxLines = 12, width } = options;
 	const { title, meta } = formatHeader(options, theme);
 	const state = getState(options.status);
 
 	const normalizedCode = replaceTabs(code ?? "");
-	const rawCodeLines = normalizedCode.split("\n");
+	const rawCodeLines = sanitizeTerminalLines(normalizedCode);
 	const maxCodeLines = expanded ? rawCodeLines.length : Math.min(rawCodeLines.length, codeMaxLines);
 	const visibleCode = rawCodeLines.slice(0, maxCodeLines).join("\n");
 	const codeLines = highlightCode(visibleCode, language);
@@ -96,7 +111,7 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 
 	const outputLines: string[] = [];
 	if (output?.trim()) {
-		const rawLines = output.split("\n");
+		const rawLines = sanitizeTerminalLines(output);
 		const maxLines = expanded ? rawLines.length : Math.min(rawLines.length, outputMaxLines);
 		const displayLines = rawLines
 			.slice(0, maxLines)
@@ -163,7 +178,7 @@ export function renderMarkdownCell(options: MarkdownCellOptions, theme: Theme):
 
 	const outputLines: string[] = [];
 	if (output?.trim()) {
-		const rawLines = output.split("\n");
+		const rawLines = sanitizeTerminalLines(output);
 		const maxLines = expanded ? rawLines.length : Math.min(rawLines.length, outputMaxLines);
 		const displayLines = rawLines
 			.slice(0, maxLines)

package/src/web/scrapers/searchcode.ts

@@ -55,8 +55,7 @@ function formatCodeBlock(
 ): string | null {
 	if (!code) return null;
 
-	const normalized = code.replace(/\r\n/g, "\n").trimEnd();
-	const codeLines = normalized.split("\n");
+	const codeLines = code.trimEnd().split(/\r?\n/);
 	const languageTag = typeof language === "string" ? language.trim().toLowerCase() : "";
 
 	let displayLines = codeLines;