@oh-my-pi/pi-coding-agent 17.2.3 → 17.2.5

package/src/edit/streaming.ts

@@ -30,7 +30,6 @@ import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { computeHashlineDiff, computeHashlineSectionDiff } from "./hashline/diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
-import type { ReplaceEditEntry } from "./modes/replace";
 
 export interface PerFileDiffPreview {
 	path: string;
@@ -333,27 +332,32 @@ function splitApplyPatchPerFile(input: string): EditMatcherEntry[] {
 
 interface ReplaceArgs {
 	path?: string;
-	edits?: ReplaceEditEntry[];
+	old_string?: string;
+	new_string?: string;
+	replace_all?: boolean;
 	__partialJson?: string;
 }
 
 const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 	extractCompleteEdits(args, partialJson) {
-		if (!args?.edits) return args;
-		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
+		// While args are still streaming, `old_string` is only trustworthy once
+		// the parser has moved past it — i.e. the `new_string` key has appeared.
+		// Previewing a half-streamed `old_string` would flash a bogus
+		// "no match" diff error until the rest of the value arrives.
+		if (!partialJson || partialJson.includes('"new_string"')) return args;
+		return { ...args, old_string: undefined, new_string: undefined };
 	},
 	async computeDiffPreview(args, ctx) {
 		if (!args.path) return null;
-		const first = args.edits?.[0];
-		if (!first || first.old_text === undefined || first.new_text === undefined) return null;
+		if (args.old_string === undefined || args.new_string === undefined) return null;
 		ctx.signal.throwIfAborted();
 		const result = await computeEditDiff(
 			args.path,
-			first.old_text,
-			first.new_text,
+			args.old_string,
+			args.new_string,
 			ctx.cwd,
 			ctx.allowFuzzy ?? true,
-			first.all,
+			args.replace_all,
 			ctx.fuzzyThreshold,
 		);
 		ctx.signal.throwIfAborted();
@@ -363,14 +367,7 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 		return "";
 	},
 	matcherDigest(args) {
-		const edits = args?.edits;
-		if (!Array.isArray(edits)) return undefined;
-		let digest: string | undefined;
-		for (const edit of edits) {
-			if (typeof edit?.new_text !== "string") continue;
-			digest = digest === undefined ? edit.new_text : `${digest}\n${edit.new_text}`;
-		}
-		return digest;
+		return typeof args?.new_string === "string" ? args.new_string : undefined;
 	},
 	matcherPaths(args) {
 		return typeof args?.path === "string" && args.path.length > 0 ? [args.path] : undefined;

package/src/eval/py/kernel.ts

@@ -82,8 +82,9 @@ const availabilityCache = new Map<string, Promise<PythonKernelAvailability>>();
 export async function checkPythonKernelAvailability(
 	cwd: string,
 	interpreter?: string,
+	options?: { forceProbe?: boolean },
 ): Promise<PythonKernelAvailability> {
-	if (isBunTestRuntime() || $flag("PI_PYTHON_SKIP_CHECK")) {
+	if (!options?.forceProbe && (isBunTestRuntime() || $flag("PI_PYTHON_SKIP_CHECK"))) {
 		return { ok: true };
 	}
 	const resolvedCwd = path.resolve(cwd);

package/src/eval/py/spawn-options.ts

@@ -1,10 +1,10 @@
 /**
  * Subprocess spawn-option helpers for the Python kernel.
  *
- * Pure helpers (`shouldHideKernelWindow`, `consoleAttachedViaTTY`) live here
- * so they can be unit-tested without dragging in the kernel's runtime
- * dependencies. The effectful `hostHasInheritableConsole` wraps a Win32 FFI
- * probe with a TTY fallback and is the function `kernel.ts` actually calls.
+ * Pure helpers (`shouldHideKernelWindow`, `consoleAttached`) live here so they
+ * can be unit-tested without dragging in the kernel's runtime dependencies.
+ * The effectful `hostHasInheritableConsole` combines a Win32 FFI probe with
+ * TTY evidence and is the function `kernel.ts` actually calls.
  */
 import { dlopen, FFIType } from "bun:ffi";
 
@@ -54,20 +54,21 @@ export function shouldDetachKernel(platform: NodeJS.Platform): boolean {
 }
 
 /**
- * TTY-based fallback used when the Win32 console probe is unavailable.
+ * Combine native Win32 and stdio TTY evidence of an inheritable console.
  *
- * Returns `true` if any of stdin/stdout/stderr is currently a TTY. This
- * correctly detects the common interactive launches and the partial-
- * redirection cases (`omp -p > out.txt`, `< in.txt`, `2> err.log`) where at
- * least one stream stays bound to the terminal. The all-stdio-redirected
- * case (`< in > out 2> err` from a console) is the reason we prefer the
- * Win32 probe over this fallback whenever possible.
+ * `GetConsoleWindow()` detects classic consoles even when every stdio stream
+ * is redirected. TTY detection covers ConPTY-backed terminals, where compiled
+ * hosts can receive a null HWND despite being attached to Windows Terminal.
+ * Either signal must preserve console inheritance: `CREATE_NO_WINDOW` can
+ * deadlock NumPy native-extension loading in the Python child.
  */
-export function consoleAttachedViaTTY(opts: {
+export function consoleAttached(opts: {
+	nativeConsole?: boolean | null;
 	stdinIsTTY: boolean;
 	stdoutIsTTY: boolean;
 	stderrIsTTY: boolean;
 }): boolean {
+	if (opts.nativeConsole === true) return true;
 	return opts.stdinIsTTY || opts.stdoutIsTTY || opts.stderrIsTTY;
 }
 
@@ -75,10 +76,10 @@ export function consoleAttachedViaTTY(opts: {
  * Probe `kernel32.dll!GetConsoleWindow()` to detect whether the current
  * Windows process owns a console window.
  *
- * Returns `true` for a non-NULL HWND, `false` when NULL (no console — true
- * service / `DETACHED_PROCESS` / GUI parent), and `null` when the probe
- * itself fails (off-Windows, FFI disabled, or unexpected kernel32 layout).
- * A `null` return means "don't trust me, use the TTY fallback".
+ * Returns `true` for a non-NULL HWND, `false` when NULL, and `null` when the
+ * probe itself fails (off-Windows, FFI disabled, or unexpected kernel32
+ * layout). A false result is not conclusive for ConPTY-backed terminals, so
+ * callers must also inspect the stdio TTY signals.
  *
  * Cached on first call because in practice the console attachment of a
  * long-lived OMP host never changes for the lifetime of the process, and
@@ -117,21 +118,15 @@ export function __resetWindowsConsoleProbeCache(): void {
 /**
  * Whether the host process owns a console its children can inherit.
  *
- * - On Windows, the authoritative signal is `GetConsoleWindow()`. It returns
- *   a non-NULL HWND whenever the process has a console attached, regardless
- *   of how the standard streams are redirected — so an `omp -p ... < in.txt
- *   > out.txt 2> err.log` launched from a real Windows Terminal session is
- *   correctly classified as console-attached and the kernel keeps its
- *   inheritable console.
- * - On any other platform, or if the FFI probe fails, fall back to the
- *   TTY-OR heuristic. That still catches the common interactive cases.
+ * On Windows, `GetConsoleWindow()` detects classic consoles and all-stdio-
+ * redirected launches while stdio TTYs detect ConPTY-backed terminals. Either
+ * signal is sufficient. Other platforms use the same TTY evidence, although
+ * `windowsHide` is a no-op there.
  */
 export function hostHasInheritableConsole(): boolean {
-	if (process.platform === "win32") {
-		const native = probeWindowsConsoleWindow();
-		if (native !== null) return native;
-	}
-	return consoleAttachedViaTTY({
+	const nativeConsole = process.platform === "win32" ? probeWindowsConsoleWindow() : null;
+	return consoleAttached({
+		nativeConsole,
 		stdinIsTTY: !!process.stdin.isTTY,
 		stdoutIsTTY: !!process.stdout.isTTY,
 		stderrIsTTY: !!process.stderr.isTTY,

package/src/export/html/template.js

@@ -204,7 +204,7 @@
           containsActive.set(node, has);
         }
 
-        // Stack: [node, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild]
+        // Stack: [node, indent, showConnector, isLast, gutters, isVirtualRootChild]
         const stack = [];
 
         // Add roots (prioritize branch containing active leaf)
@@ -213,11 +213,11 @@
         );
         for (let i = orderedRoots.length - 1; i >= 0; i--) {
           const isLast = i === orderedRoots.length - 1;
-          stack.push([orderedRoots[i], multipleRoots ? 1 : 0, multipleRoots, multipleRoots, isLast, [], multipleRoots]);
+          stack.push([orderedRoots[i], multipleRoots ? 1 : 0, multipleRoots, isLast, [], multipleRoots]);
         }
 
         while (stack.length > 0) {
-          const [node, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild] = stack.pop();
+          const [node, indent, showConnector, isLast, gutters, isVirtualRootChild] = stack.pop();
 
           result.push({ node, indent, showConnector, isLast, gutters, isVirtualRootChild, multipleRoots });
 
@@ -229,18 +229,10 @@
             Number(containsActive.get(b)) - Number(containsActive.get(a))
           );
 
-          // Calculate child indent (matches tree-selector.ts)
-          let childIndent;
-          if (multipleChildren) {
-            // Parent branches: children get +1
-            childIndent = indent + 1;
-          } else if (justBranched && indent > 0) {
-            // First generation after a branch: +1 for visual grouping
-            childIndent = indent + 1;
-          } else {
-            // Single-child chain: stay flat
-            childIndent = indent;
-          }
+          // Real branch points add visual depth, and a virtual root's direct
+          // children (the session roots) nest one level under the shared
+          // column-0 root. Linear continuations otherwise stay aligned.
+          const childIndent = multipleChildren || isVirtualRootChild ? indent + 1 : indent;
 
           // Build gutters for children
           const connectorDisplayed = showConnector && !isVirtualRootChild;
@@ -253,7 +245,7 @@
           // Add children in reverse order for stack
           for (let i = orderedChildren.length - 1; i >= 0; i--) {
             const childIsLast = i === orderedChildren.length - 1;
-            stack.push([orderedChildren[i], childIndent, multipleChildren, multipleChildren, childIsLast, childGutters, false]);
+            stack.push([orderedChildren[i], childIndent, multipleChildren, childIsLast, childGutters, false]);
           }
         }
 
@@ -268,13 +260,6 @@
         const displayIndent = multipleRoots ? Math.max(0, indent - 1) : indent;
         const connector = showConnector && !isVirtualRootChild ? (isLast ? '└─ ' : '├─ ') : '';
         const connectorPosition = connector ? displayIndent - 1 : -1;
-        // Chain rows (no connector of their own) under a last-sibling (`└─`)
-        // branch stay anchored by a vertical drawn one level right of the
-        // suppressed gutter — below the branch head's content — never in the
-        // `└─` corner column itself (#2298, #2325). Chains under `├─` heads
-        // are already anchored by the sibling line (`show: true` gutter).
-        const nearestGutter = !connector ? gutters[gutters.length - 1] : undefined;
-        const chainAnchorLevel = nearestGutter && !nearestGutter.show ? nearestGutter.position + 1 : -1;
 
         const totalChars = displayIndent * 3;
         const prefixChars = [];
@@ -287,9 +272,6 @@
             // Standard tree semantics: `│` only while more siblings continue
             // below (`show`), space below a `└─`.
             prefixChars.push(posInLevel === 0 && gutter.show ? '│' : ' ');
-          } else if (level === chainAnchorLevel) {
-            // Chain anchor for rows under a `└─` branch head.
-            prefixChars.push(posInLevel === 0 ? '│' : ' ');
           } else if (connector && level === connectorPosition) {
             if (posInLevel === 0) {
               prefixChars.push(isLast ? '└' : '├');

package/src/extensibility/extensions/loader.ts

@@ -509,6 +509,26 @@ async function discoverExtensionsInDir(dir: string): Promise<string[]> {
 
 	return discovered;
 }
+async function discoverHooksInPackageRoot(root: string): Promise<string[]> {
+	const hooks: string[] = [];
+	for (const hookType of ["pre", "post"]) {
+		const hookDir = path.join(root, "hooks", hookType);
+		let entries: fs1.Dirent[];
+		try {
+			entries = await fs.readdir(hookDir, { withFileTypes: true });
+		} catch (err) {
+			if (isEnoent(err) || isEacces(err) || hasFsCode(err, "ENOTDIR") || hasFsCode(err, "EPERM")) continue;
+			throw err;
+		}
+		for (const entry of entries) {
+			if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
+				hooks.push(path.join(hookDir, entry.name));
+			}
+		}
+	}
+	return hooks;
+}
+
 /**
  * Discover absolute paths of extensions to load, without importing or
  * binding factories. Hot path on session startup — the scan walks native
@@ -522,10 +542,16 @@ async function discoverExtensionsInDir(dir: string): Promise<string[]> {
  * `LoadExtensionsResult` directly would reuse handlers/tools/commands that
  * closed over the parent's `cwd` and event bus.
  */
+export interface DiscoverExtensionPathOptions {
+	/** Include ambient native extensions, hooks, and installed plugins. */
+	ambient?: boolean;
+}
+
 export async function discoverExtensionPaths(
 	configuredPaths: string[],
 	cwd: string,
 	disabledExtensionIds?: string[],
+	options: DiscoverExtensionPathOptions = {},
 ): Promise<string[]> {
 	const allPaths: string[] = [];
 	const seen = new Set<string>();
@@ -549,33 +575,44 @@ export async function discoverExtensionPaths(
 		}
 	};
 
-	// 1. Discover extension modules via capability API (native .omp/.pi only).
-	// Scope the load to the native provider — the extension-module capability
-	// also has claude/codex/gemini/opencode providers, and their items were
-	// discarded here anyway (see #4198). The provider filter skips the walk
-	// entirely instead of running four foreign directory scans and dropping
-	// the results.
-	const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, {
-		...loadOptions,
-		providers: ["native"],
-	});
-	for (const ext of discovered.items) {
-		addPath(ext.path);
-	}
-
-	// 2. Discover JS/TS hook factories from hookCapability and bind them through
-	// the extension runner, which owns the current runtime event bus. Hook
-	// capability loading already applies hook-specific disabled ids; do not also
-	// filter them through extension-module names.
-	const hooks = await loadCapability<Hook>(hookCapability.id, loadOptions);
-	for (const hookPath of hooks.items
-		.map(hook => hook.path)
-		.filter(hookPath => isExtensionFile(path.basename(hookPath)))) {
-		addPath(hookPath);
-	}
-
-	// 3. Discover extension entry points from installed plugins
-	addPaths(await getAllPluginExtensionPaths(cwd));
+	const ambient = options.ambient !== false;
+	if (ambient) {
+		// 1. Discover extension modules via capability API (native .omp/.pi only).
+		// Scope the load to the native provider — the extension-module capability
+		// also has claude/codex/gemini/opencode providers, and their items were
+		// discarded here anyway (see #4198). The provider filter skips the walk
+		// entirely instead of running four foreign directory scans and dropping
+		// the results.
+		const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, {
+			...loadOptions,
+			providers: ["native"],
+		});
+		for (const ext of discovered.items) {
+			addPath(ext.path);
+		}
+	}
+
+	// 2. Discover JS/TS hook factories and bind them through the extension
+	// runner, which owns the current runtime event bus. Non-ambient discovery
+	// scans only this invocation's configured package roots; it must not consult
+	// settings, installed packages, or process-global CLI injection state.
+	if (ambient) {
+		const hooks = await loadCapability<Hook>(hookCapability.id, loadOptions);
+		for (const hookPath of hooks.items
+			.map(hook => hook.path)
+			.filter(hookPath => isExtensionFile(path.basename(hookPath)))) {
+			addPath(hookPath);
+		}
+	} else {
+		for (const configuredPath of configuredPaths) {
+			addPaths(await discoverHooksInPackageRoot(resolvePath(configuredPath, cwd)));
+		}
+	}
+
+	// 3. Discover extension entry points from installed plugins.
+	if (ambient) {
+		addPaths(await getAllPluginExtensionPaths(cwd));
+	}
 
 	// 4. Explicitly configured paths
 	for (const configuredPath of configuredPaths) {
@@ -618,7 +655,8 @@ export async function discoverAndLoadExtensions(
 	cwd: string,
 	eventBus?: EventBus,
 	disabledExtensionIds?: string[],
+	options: DiscoverExtensionPathOptions = {},
 ): Promise<LoadExtensionsResult> {
-	const paths = await discoverExtensionPaths(configuredPaths, cwd, disabledExtensionIds);
+	const paths = await discoverExtensionPaths(configuredPaths, cwd, disabledExtensionIds, options);
 	return loadExtensions(paths, cwd, eventBus);
 }

package/src/extensibility/extensions/wrapper.ts

@@ -239,6 +239,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		// short-circuit above.
 		const resolvedArgs = approvalArgs(effectiveParams, context);
 		const resolved = resolveApproval(this.tool, resolvedArgs, approvalMode, userPolicies);
+		context?.xdevTierResolved?.(resolved.tier);
 		if (resolved.policy === "deny") {
 			throw new Error(
 				`Tool "${this.tool.name}" is blocked by user policy.\n` +

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -19,7 +19,15 @@
  * `types.ts` via the `export *` below — pi-ai still exports both as types,
  * only the runtime `Type` builder and `StringEnum()` helper were removed.
  */
-import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import {
+	type Api,
+	type AssistantMessage,
+	type AssistantMessageEventStream,
+	type Context,
+	type Model,
+	type SimpleStreamOptions,
+	streamSimple,
+} from "@oh-my-pi/pi-ai";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { clampThinkingLevelForModel } from "@oh-my-pi/pi-catalog/model-thinking";
 import {
@@ -121,6 +129,19 @@ export { calculateCost, getBundledModel, getBundledModels, getBundledProviders,
 export const getModel = getBundledModel;
 export const getModels = getBundledModels;
 
+/**
+ * Stream OpenAI Responses through the historical simple-options contract.
+ *
+ * Legacy `/compat` callers pass {@link SimpleStreamOptions}; routing through
+ * `streamSimple` preserves option normalization before provider dispatch.
+ */
+export function streamSimpleOpenAIResponses(
+	model: Model<"openai-responses">,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+	return streamSimple(model, context, options);
+}
 /**
  * Compatibility re-exports for runtime helpers that upstream
  * `@earendil-works/pi-ai` exposed from its package root but omp's

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -1415,12 +1415,13 @@ export function getPackageDir(): string {
 	return getOmpPackageDir() ?? (isCompiledBinary() ? path.dirname(process.execPath) : process.cwd());
 }
 
-// Legacy pi's `@earendil-works/pi-coding-agent` re-exported `estimateTokens`
-// and `compact` from its package root (via `./core/compaction/index.ts`). In
-// omp both live in `@oh-my-pi/pi-agent-core/compaction`, and the coding-agent
-// barrel below does not forward them, so legacy extensions importing either
-// fail Bun's static export check during validation (issues #6583, #7174).
-export { compact, estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
+// Legacy pi's `@earendil-works/pi-coding-agent` re-exported `estimateTokens`,
+// `compact`, and `serializeConversation` from its package root (via
+// `./core/compaction/index.ts`). In omp they live in
+// `@oh-my-pi/pi-agent-core/compaction`, and the coding-agent barrel below does
+// not forward them, so legacy extensions importing them fail Bun's static
+// export check during validation (issues #6583, #7174, #7403).
+export { compact, estimateTokens, serializeConversation } from "@oh-my-pi/pi-agent-core/compaction";
 
 // Same barrel gap for two more legacy package-root exports: pi re-exported the
 // `CONFIG_DIR_NAME` constant and the CLI parser `parseArgs`. In omp