@oh-my-pi/pi-coding-agent 14.5.9 → 14.5.10

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [Unreleased]
 
+## [14.5.10] - 2026-04-30
+
+### Breaking Changes
+
+- Removed the `worktree` parameter from `github` `pr_checkout`. Worktrees are now always written to `~/.omp/wt/<encoded-primary-repo>/pr-<number>/`, derived from the primary repository path
+- Stopped reading the `branch` parameter for `github` `pr_checkout`. The local branch is now always `pr-<number>`; the `branch` schema field is still accepted by `pr_push`, `repo_view`, and `run_watch`
+
+### Added
+
+- Added `checkouts` summary entries to `pr_checkout` results, including each checkout's branch, worktree path, remote, and reuse status
+- Added combined summaries for `pr_view` and `pr_diff` when `pr` is an array, so multi-request responses now include all requested pull requests in one return
+- Added array support to the `pr` parameter on `github` `pr_view`, `pr_diff`, and `pr_checkout` so a single call can fetch, diff, or check out multiple pull requests in one batch
+- Added a per-repo serialization lock (`withRepoLock`) so concurrent `pr_checkout` calls against the same repository no longer race on git's internal `.git/config.lock`, commit-graph, and worktree lock files
+
+### Changed
+
+- Changed the diff preview shown after edits so changed lines are never collapsed: removed runs and the global preview budget no longer truncate, only unchanged context still collapses
+- Changed adjacent `-`/`+` pairs in edit previews to fold into a single `*<line><hash>|<new-content>` modification line so 1:1 line replacements stay compact
+- Changed `git.remote.add` to be idempotent when the remote already exists with the same URL (instead of failing with `remote ... already exists`), and to surface a clear error when the existing URL differs
+- Changed `pr_checkout` to run `gh pr view` calls in parallel for batch invocations while serializing the in-repo git mutations to keep the operation race-free
+- Changed `pr_checkout` to auto-derive the worktree location and local branch name (see Breaking Changes), removing the per-call overrides that previously let callers pin a worktree path or local branch
+
+### Removed
+
+- Removed the `./hooks` and `./hooks/*` package export entries
+- Removed the `Suspicious duplicate` warning emitted after edits — it produced too many false positives (e.g. legitimate adjacent `\t});\n\t});`); the auto-fix path that uses bracket balance to safely de-duplicate is unchanged
+
+### Fixed
+
+- Fixed bash interceptor rules to also check the original command before `cd` normalization, so leading `cd ... &&` wrappers no longer bypass interception
+- Fixed LSP client shutdown to properly await the language server's exit instead of fire-and-forget, preventing premature process termination on SIGINT and SIGTERM
+- Fixed concurrent bash commands being tracked independently so aborting one no longer silently drops tracking of others
+
 ## [14.5.9] - 2026-04-30
 
 ### Added
@@ -82,6 +115,7 @@
 
 ### Added
 
+- Added the `after_provider_response` extension event for observing provider response status, headers, and request IDs.
 - Added internal URL support to the `search` tool, allowing `artifact://`-style paths that resolve to local files to be searched directly
 - Added IRC relay observation in the main agent UI so every IRC exchange between agents is rendered in the main transcript, even when the main agent is not a direct participant
 - Added stateful `href`/`hrefr` prompt helpers that can reuse anchors remembered from prior `hline` helper calls

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.5.9",
+	"version": "14.5.10",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.20.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.5.9",
-		"@oh-my-pi/pi-agent-core": "14.5.9",
-		"@oh-my-pi/pi-ai": "14.5.9",
-		"@oh-my-pi/pi-natives": "14.5.9",
-		"@oh-my-pi/pi-tui": "14.5.9",
-		"@oh-my-pi/pi-utils": "14.5.9",
+		"@oh-my-pi/omp-stats": "14.5.10",
+		"@oh-my-pi/pi-agent-core": "14.5.10",
+		"@oh-my-pi/pi-ai": "14.5.10",
+		"@oh-my-pi/pi-natives": "14.5.10",
+		"@oh-my-pi/pi-tui": "14.5.10",
+		"@oh-my-pi/pi-utils": "14.5.10",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@xterm/headless": "^6.0.0",
@@ -516,14 +516,6 @@
 			"types": "./src/web/search/providers/*.ts",
 			"import": "./src/web/search/providers/*.ts"
 		},
-		"./hooks": {
-			"types": "./src/extensibility/hooks/index.ts",
-			"import": "./src/extensibility/hooks/index.ts"
-		},
-		"./hooks/*": {
-			"types": "./src/extensibility/hooks/*.ts",
-			"import": "./src/extensibility/hooks/*.ts"
-		},
 		"./*.js": "./src/*.ts"
 	}
 }

package/scripts/build-binary.ts

@@ -34,7 +34,7 @@ async function main(): Promise<void> {
 					"build",
 					"--compile",
 					"--define",
-					"PI_COMPILED=true",
+					'process.env.PI_COMPILED="true"',
 					"--external",
 					"mupdf",
 					"--root",

package/src/cli/update-cli.ts

@@ -53,13 +53,37 @@ function normalizePathForComparison(filePath: string): string {
 	return normalized;
 }
 
-function isPathInDirectory(filePath: string, directoryPath: string): boolean {
+function tryRealpath(p: string): string | undefined {
+	try {
+		return fs.realpathSync.native(p);
+	} catch {
+		return undefined;
+	}
+}
+
+function isPathInDirectoryLexical(filePath: string, directoryPath: string): boolean {
 	const normalizedPath = normalizePathForComparison(path.resolve(filePath));
 	const normalizedDirectory = normalizePathForComparison(path.resolve(directoryPath));
 	const relativePath = path.relative(normalizedDirectory, normalizedPath);
 	return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
 }
 
+function isPathInDirectory(filePath: string, directoryPath: string): boolean {
+	if (isPathInDirectoryLexical(filePath, directoryPath)) return true;
+	// Layer realpath resolution on top of the lexical guard. On Windows, ~/.bun
+	// is a junction when Bun is installed via Scoop, so `bun pm bin -g` and the
+	// PATH-resolved omp path can refer to the same directory through different
+	// strings. path.resolve does not traverse junctions/symlinks; realpath does.
+	// Resolve the file's parent directory to tolerate the file itself not yet
+	// existing (e.g. a fresh install path) while still catching link-traversed
+	// equality once the directory exists.
+	const fileDir = tryRealpath(path.dirname(path.resolve(filePath)));
+	const dirReal = tryRealpath(path.resolve(directoryPath));
+	if (!fileDir || !dirReal) return false;
+	const resolvedFile = path.join(fileDir, path.basename(filePath));
+	return isPathInDirectoryLexical(resolvedFile, dirReal);
+}
+
 type UpdateTarget = { method: "bun" } | { method: "binary"; path: string };
 
 function resolveUpdateMethod(ompPath: string, bunBinDir: string | undefined): "bun" | "binary" {

package/src/config/model-registry.ts

@@ -145,8 +145,16 @@ const OpenAICompatSchema = Type.Object({
 	maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
 	supportsUsageInStreaming: Type.Optional(Type.Boolean()),
 	requiresToolResultName: Type.Optional(Type.Boolean()),
+	requiresMistralToolIds: Type.Optional(Type.Boolean()),
 	requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
 	requiresThinkingAsText: Type.Optional(Type.Boolean()),
+	reasoningContentField: Type.Optional(
+		Type.Union([Type.Literal("reasoning_content"), Type.Literal("reasoning"), Type.Literal("reasoning_text")]),
+	),
+	requiresReasoningContentForToolCalls: Type.Optional(Type.Boolean()),
+	requiresAssistantContentForToolCalls: Type.Optional(Type.Boolean()),
+	supportsToolChoice: Type.Optional(Type.Boolean()),
+	disableReasoningOnForcedToolChoice: Type.Optional(Type.Boolean()),
 	thinkingFormat: Type.Optional(
 		Type.Union([
 			Type.Literal("openai"),
@@ -183,6 +191,7 @@ const ModelThinkingSchema = Type.Object({
 	minLevel: EffortSchema,
 	maxLevel: EffortSchema,
 	mode: ThinkingControlModeSchema,
+	defaultLevel: Type.Optional(EffortSchema),
 });
 
 // Schema for custom model definition
@@ -558,27 +567,20 @@ function resolveOAuthAccountIdForAccessToken(
 	return undefined;
 }
 
-function mergeCompat(
-	baseCompat: Model<Api>["compat"],
-	overrideCompat: ModelOverride["compat"],
-): Model<Api>["compat"] | undefined {
+function mergeCompat<TBase extends object, TOverride extends object>(
+	baseCompat: TBase | null | undefined,
+	overrideCompat: TOverride | null | undefined,
+): (TBase & TOverride) | TBase | TOverride | undefined {
+	if (!baseCompat) return overrideCompat ?? undefined;
 	if (!overrideCompat) return baseCompat;
-	const base = baseCompat ?? {};
-	const override = overrideCompat;
-	const merged: NonNullable<Model<Api>["compat"]> = { ...base, ...override };
-	if (baseCompat?.reasoningEffortMap || overrideCompat.reasoningEffortMap) {
-		merged.reasoningEffortMap = { ...baseCompat?.reasoningEffortMap, ...overrideCompat.reasoningEffortMap };
-	}
-	if (baseCompat?.openRouterRouting || overrideCompat.openRouterRouting) {
-		merged.openRouterRouting = { ...baseCompat?.openRouterRouting, ...overrideCompat.openRouterRouting };
-	}
-	if (baseCompat?.vercelGatewayRouting || overrideCompat.vercelGatewayRouting) {
-		merged.vercelGatewayRouting = { ...baseCompat?.vercelGatewayRouting, ...overrideCompat.vercelGatewayRouting };
-	}
-	if (baseCompat?.extraBody || overrideCompat.extraBody) {
-		merged.extraBody = { ...baseCompat?.extraBody, ...overrideCompat.extraBody };
+
+	const merged: Record<string, unknown> = { ...(baseCompat as Record<string, unknown>) };
+	for (const [key, overrideValue] of Object.entries(overrideCompat)) {
+		const baseValue = (baseCompat as Record<string, unknown>)[key];
+		merged[key] =
+			isRecord(baseValue) && isRecord(overrideValue) ? mergeCompat(baseValue, overrideValue) : overrideValue;
 	}
-	return merged;
+	return merged as TBase & TOverride;
 }
 
 function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<Api> {

package/src/config/settings-schema.ts

@@ -1793,38 +1793,33 @@ export const SETTINGS_SCHEMA = {
 		ui: {
 			tab: "providers",
 			label: "SearXNG Endpoint",
-			description: "Base URL of the SearXNG instance (e.g. https://searx.example.org)",
+			description: "Self-hosted search base URL",
 		},
 	},
 
 	"searxng.token": {
 		type: "string",
 		default: undefined,
-		ui: {
-			tab: "providers",
-			label: "SearXNG Token",
-			description: "Optional bearer token for SearXNG authentication",
-		},
+	},
+
+	"searxng.basicUsername": {
+		type: "string",
+		default: undefined,
+	},
+
+	"searxng.basicPassword": {
+		type: "string",
+		default: undefined,
 	},
 
 	"searxng.categories": {
 		type: "string",
 		default: undefined,
-		ui: {
-			tab: "providers",
-			label: "SearXNG Categories",
-			description: "Comma-separated categories filter (e.g. general,news,science)",
-		},
 	},
 
 	"searxng.language": {
 		type: "string",
 		default: undefined,
-		ui: {
-			tab: "providers",
-			label: "SearXNG Language",
-			description: "Language code for search results (e.g. en, zh-CN)",
-		},
 	},
 
 	"commit.mapReduceEnabled": { type: "boolean", default: true },

package/src/discovery/claude-plugins.ts

@@ -265,10 +265,28 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 		}
 
 		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
-		const config = parsed as { mcpServers?: Record<string, unknown> };
-		if (!config.mcpServers || typeof config.mcpServers !== "object") continue;
+		const obj = parsed as Record<string, unknown>;
+
+		// Two shapes are supported:
+		//   nested: { "mcpServers": { name: cfg, ... } }   (OMP/Claude Code project shape)
+		//   flat:   { name: cfg, ... }                      (Claude marketplace plugin shape)
+		// If "mcpServers" is present and an object, treat it as the canonical map.
+		// Otherwise, treat the whole object as the server map.
+		let servers: Record<string, unknown>;
+		if (
+			obj.mcpServers !== undefined &&
+			obj.mcpServers !== null &&
+			typeof obj.mcpServers === "object" &&
+			!Array.isArray(obj.mcpServers)
+		) {
+			servers = obj.mcpServers as Record<string, unknown>;
+		} else if (!("mcpServers" in obj)) {
+			servers = obj;
+		} else {
+			continue;
+		}
 
-		for (const [serverName, serverCfg] of Object.entries(config.mcpServers)) {
+		for (const [serverName, serverCfg] of Object.entries(servers)) {
 			if (!serverCfg || typeof serverCfg !== "object" || Array.isArray(serverCfg)) continue;
 			const raw = serverCfg as {
 				enabled?: boolean;
@@ -283,6 +301,13 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 				oauth?: MCPServer["oauth"];
 				type?: string;
 			};
+			// Require either command (stdio) or url (HTTP/SSE) — Claude marketplace plugins
+			// occasionally ship .mcp.json entries with neither, which would register a useless
+			// server and surface as a connection error at runtime.
+			if (typeof raw.command !== "string" && typeof raw.url !== "string") {
+				warnings.push(`[claude-plugins] Skipping MCP server "${serverName}" in ${mcpPath}: missing command or url`);
+				continue;
+			}
 			const namespacedName = root.plugin ? `${root.plugin}:${serverName}` : serverName;
 			const server: MCPServer = {
 				name: namespacedName,

package/src/edit/modes/atom.ts

@@ -518,11 +518,26 @@ function isReplaceStart(line: string): boolean {
 	return /^[1-9]\d*[a-z]{2}[ \t]*[=|]/.test(stripped);
 }
 
+// Lookahead used by the blank-line forgiveness rule below: returns true when
+// the first non-blank line at or after `start` is a `\TEXT` continuation.
+function nextNonBlankIsBackslash(lines: readonly string[], start: number): boolean {
+	for (let j = start; j < lines.length; j++) {
+		const peek = lines[j].endsWith("\r") ? lines[j].slice(0, -1) : lines[j];
+		if (peek.length === 0) continue;
+		return peek.startsWith("\\");
+	}
+	return false;
+}
+
 // Explicit continuation uses `\TEXT` after a replacement op (`Lid=FIRST` or
 // `LidA..LidB=FIRST`). The leading backslash is the continuation marker; the
 // rest of the line is inserted literally, so `\\TEXT` inserts a line starting
-// with `\TEXT`. Raw unprefixed continuation remains an undocumented
-// best-effort recovery for range replacements only, kept for old transcripts.
+// with `\TEXT`. As a forgiveness rule, a literal blank line inside an active
+// replacement that is itself followed (possibly through more blanks) by another
+// `\TEXT` continuation is treated as an implicit `\` blank insert — authors
+// frequently drop a real blank between `\TEXT` lines instead of writing `\`.
+// Raw unprefixed continuation remains an undocumented best-effort recovery for
+// range replacements only, kept for old transcripts.
 function preprocessRangeReplaceContinuation(diff: string): string {
 	const lines = diff.split("\n");
 	let inRangeReplace = false;
@@ -541,6 +556,14 @@ function preprocessRangeReplaceContinuation(diff: string): string {
 			continue;
 		}
 
+		// Forgiveness: a blank line inside an active replacement that is followed
+		// by another `\TEXT` continuation is treated as an implicit `\` blank
+		// insert. Keeps the replacement open across the blank.
+		if (inReplace && line.length === 0 && nextNonBlankIsBackslash(lines, i + 1)) {
+			lines[i] = `+${RANGE_CONTINUATION_SENTINEL}`;
+			continue;
+		}
+
 		if (inRangeReplace) {
 			if (line.length === 0 || OP_LINE_HEAD_RE.test(line)) {
 				inRangeReplace = isRangeReplaceStart(line);
@@ -949,6 +972,9 @@ function getAnchorForAnchorEdit(edit: IndexedAnchorEdit["edit"]): Anchor {
 // missed one delete on the front or back of the deletion range, leaving a
 // stale copy of a line the agent already re-emitted (e.g. inserting a new
 // closing `}` while the original `}` was never deleted, producing `}\n}`).
+// A single edit may damage multiple unrelated segments (e.g. two block
+// rewrites that each missed their trailing `}`), so detection and auto-fix
+// operate on every new adjacent duplicate at once.
 //
 // Auto-fix is gated on bracket balance: we only remove the duplicate line if
 // its removal restores the original file's `{}`/`()`/`[]` delta. That makes
@@ -1008,23 +1034,28 @@ function detectAndAutoFixDuplicates(
 
 	const formatPreview = (text: string): string => JSON.stringify(text.length > 60 ? `${text.slice(0, 60)}…` : text);
 
-	// Auto-fix only when there is exactly one new adjacent duplicate AND the
-	// edit shifted bracket balance. Removing one of the two identical lines
-	// must restore the original delta exactly.
-	if (newDupPositions.length === 1) {
-		const pos = newDupPositions[0];
-		const origBalance = computeBalance(originalLines);
-		const finalBalance = computeBalance(finalLines);
-		if (!balancesEqual(origBalance, finalBalance)) {
-			const trial = finalLines.slice(0, pos).concat(finalLines.slice(pos + 1));
-			if (balancesEqual(computeBalance(trial), origBalance)) {
-				return {
-					fixed: trial,
-					warnings: [
-						`Auto-fixed: removed duplicate line ${pos + 1} (${formatPreview(finalLines[pos])}); the edit left two adjacent identical lines and bracket balance was off. Verify the result.`,
-					],
-				};
-			}
+	// Auto-fix when removing one line from each new adjacent duplicate pair
+	// collectively restores the original bracket balance. The balance check is
+	// the safety gate: if we over- or under-correct (e.g. when 3+ adjacent
+	// identical lines confuse the per-pair scan), the trial balance will not
+	// match and we fall through to warnings.
+	const origBalance = computeBalance(originalLines);
+	const finalBalance = computeBalance(finalLines);
+	if (!balancesEqual(origBalance, finalBalance)) {
+		const trial = finalLines.slice();
+		// Remove in reverse so earlier indices remain valid.
+		for (let i = newDupPositions.length - 1; i >= 0; i--) {
+			trial.splice(newDupPositions[i], 1);
+		}
+		if (balancesEqual(computeBalance(trial), origBalance)) {
+			const previews = newDupPositions.map(pos => `${pos + 1} (${formatPreview(finalLines[pos])})`).join(", ");
+			const noun = newDupPositions.length === 1 ? "duplicate line" : "duplicate lines";
+			return {
+				fixed: trial,
+				warnings: [
+					`Auto-fixed: removed ${noun} ${previews}; the edit left adjacent identical lines and bracket balance was off. Verify the result.`,
+				],
+			};
 		}
 	}