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

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## [Unreleased]
 
+## [15.0.2] - 2026-05-15
+
+### Added
+
+- Added the `set_host_uri_schemes` RPC command so hosts can register and replace writable/read-only internal URI schemes with scheme metadata (`writable`, `immutable`) at runtime
+- Enabled the `write` tool to dispatch `write(url, content)` to registered internal URL handlers, allowing edits to non-filesystem resources via host-managed URI schemes
+- Added host-owned internal URI read/write over RPC, including abort support, so URI operations are resolved by the host transport for `read` and `write` requests
+- Added handling of host URI request results in RPC mode so host services can stream completion frames for internal URI operations
+- Added scratch-directory awareness to the status-line `path` segment. When the project directory is inside an OS-level scratch root (the platform `os.tmpdir()`, `/tmp` and `/var/tmp` plus their macOS `/private/...` aliases, `~/tmp`, or — on Windows — `%TEMP%` / `%TMP%` / `%SystemRoot%\Temp`), the segment now (1) renders the new `icon.scratchFolder` symbol instead of `icon.folder`, and (2) strips the scratch root from the displayed path so only the trailing folder (and any subpath beneath it) is shown — mirroring how `/work` and `~/Projects` are already abbreviated. Both behaviors honor the existing `stripWorkPrefix` option. Icon defaults: 🗑 (emoji), `` (nf-fa-trash) for Nerd Font, `[T]` for ASCII, `◌` in the poimandres themes; themes can override `icon.scratchFolder` independently of `icon.folder`.
+
+### Changed
+
+- Changed the `github` tool's search ops (`search_issues`, `search_prs`, `search_code`, `search_commits`) to default the `repo` scope to the current checkout's `owner/repo` when `repo` is omitted. The auto-scope is skipped when the query already carries an explicit `repo:`/`org:`/`user:`/`owner:` qualifier or when `gh repo view` cannot resolve a github remote (in which case the search proceeds across all of GitHub as before). `search_repos` is unchanged — repository-scoping there must live in the query.
+
+- Changed bash command preprocessing to strip trailing `| head` and `| tail` pipelines (including `|&`) from each top-level segment in command chains separated by `;`, `&&`, `||`, or `&`
+- Changed bash fixup notices to state that stderr is already merged into stdout and to reflect that fixes were applied for multiple stripped segments when several transforms fire
+- Changed shell-minimizer per-line truncation marker from a bare `…` to `…[+N]`, where `N` is the count of dropped Unicode scalars. The bracketed tally disambiguates minimizer-driven cuts from genuine `…` characters in the source (paths, JSON, stack traces, etc.) and gives the agent an exact count so it can decide whether the missing tail is recoverable inline or warrants reading the `[raw output: artifact://<id>]` footer the bash wrapper already emits when the minimizer rewrites output. Affects pipeline Stage 5 (`truncate_lines_at` in `defs/*.toml`) and the internal callers in `filters/git.rs`, `filters/listing.rs`, and `filters/lint.rs`. ([#1046](https://github.com/can1357/oh-my-pi/issues/1046))
+- Changed bash command preprocessing to use the real `brush-parser` AST via `pi-natives` `applyBashFixups` instead of a hand-rolled top-level mask scanner. The previous regex/character-walking implementation reimplemented quote/heredoc/`$(...)` tracking with conservative bail-outs (notably refusing to fixup commands containing here-strings); the AST-driven version inherits the full shell parser, so semantics-preserving rewrites like stripping `| head -5` off `cat <<<'content' | head -5` now succeed instead of being skipped. No public API change — `applyBashFixups(command)` returns the same `{ command, stripped }` shape.
+
+### Fixed
+
+- Fixed bash command fixups to remove a redundant standalone trailing `2>&1` redirect when no other pipe or redirection remains
+- Fixed command-fixup notices to list all stripped segments instead of reporting only one
+- Fixed summarized `read` output stalling agents on elided regions by appending an explicit footer like `[NN lines across MM elided regions; read <path>:raw or a line range like <path>:1-9999 for verbatim content]`. The footer fires whenever the structural summarizer elided at least one span, so the model gets a concrete recovery selector instead of having to guess from a bare `...` / `{ .. }` marker. Surfaces `elidedLines` on `ReadToolDetails.summary` alongside the existing `elidedSpans`. ([#1046](https://github.com/can1357/oh-my-pi/issues/1046))
+- Updated the `read` tool prompt to describe the new elision footer and instruct the model to follow `:raw` (or an explicit line range) when the elided body is actually needed, rather than guessing.
+- Fixed plugin extensions failing to load when their `peerDependencies` reference internal `pi-*` packages under any scope other than `@mariozechner` (e.g. `Cannot find module '@earendil-works/pi-tui'` from `@juicesharp/rpiv-ask-user-question`, or `Cannot find module '@oh-my-pi/pi-utils'` from `@oh-my-pi/swarm-extension`). The legacy-pi specifier shim now treats `@mariozechner`, `@earendil-works`, **and** the canonical `@oh-my-pi` itself as aliases for the same set of bundled in-process packages (`pi-agent-core`, `pi-ai`, `pi-coding-agent`, `pi-natives`, `pi-tui`, `pi-utils`), and additionally rewrites the upstream-only `pi-ai/oauth` subpath onto our `pi-ai/utils/oauth` layout. Restored the `Key` runtime helper export on `@oh-my-pi/pi-tui` to match upstream — plugins using `Key.enter` / `Key.ctrl("c")` (e.g. `@plannotator/pi-extension`, `@juicesharp/rpiv-ask-user-question`) no longer fail with `Export named 'Key' not found`. End-to-end verified against `@juicesharp/rpiv-ask-user-question`, `@oh-my-pi/swarm-extension`, and `@plannotator/pi-extension` — each now loads cleanly with all of its tools/commands/handlers registered. Plugins importing any of those scopes are remapped to the omp binary's own copy at load time, so peer deps are no longer dragged in from npm and there is exactly one module instance per package regardless of which scope name the plugin's manifest happened to declare.
+- Fixed `omp commit` hanging after a successful commit instead of returning to the shell. The command now mirrors the `runPrintMode` exit pattern and calls `postmortem.quit(0)` once the pipeline resolves so lingering HTTP/2 keep-alive sockets, the Settings autosave timer, and other AgentSession background handles don't keep the event loop pinned. ([#1041](https://github.com/can1357/oh-my-pi/issues/1041))
+- Fixed hashline payload parsing to silently treat truly-blank lines as empty `~`-prefixed payload lines when more payload follows in the same run. The previous behavior broke at the blank ("payload line has no preceding +, <, or = operation.") even though the intent is obvious — the only ambiguity is between in-payload blanks and end-of-section blanks, and a one-line lookahead resolves it: blanks that precede a non-payload op still end the run cleanly as section separators. Recovers the common case of forgetting the leading separator on a blank inserted line without changing how trailing blanks between ops behave.
+- Rewrote the hashline edit prompt examples to use an ASCII-only `TITLE = "Mr"` → `"Mrs"` / `"Dr"` motif instead of the previous `" • "` and `"·"` separators. Some agents had been copying the middle-dot literal characters into real edits as if they were format scaffolding (e.g. emitting payload lines like `~	·`), since the demo inserts were near-twins of the existing string. The new example keeps every original op shape (single-line replace, multiline replace, insert AFTER/BEFORE, append, delete, blank, plus both anti-patterns) but uses content that is obviously domain-specific and clearly distinct from any payload separator. Pure prompt change; no parser, schema, or runtime behavior is affected.
+- Fixed startup fallback-chain validation to recognize cached runtime-discovered standard provider models, including Ollama Cloud models listed by `--list-models`, so `retry.fallbackChains` no longer warns that valid `ollama-cloud/<model>` selectors are unknown. ([#1052](https://github.com/can1357/oh-my-pi/issues/1052))
+- Fixed `discoverAgents()` ignoring `disabledProviders` for the `claude-plugins` provider. Plugin roots from `~/.claude/plugins/` were scanned unconditionally, so agents from Claude Code marketplace plugins continued to appear in `/agents` and the Agent Control Center even when `disabledProviders: [claude-plugins]` was set. The discovery path now checks `isProviderEnabled("claude-plugins")` before calling `listClaudePluginRoots()`, matching how every other capability respects the disabled-providers set. ([#1075](https://github.com/can1357/oh-my-pi/issues/1075))
+
+### Fixed
+
+- Fixed `$env:VAR` PowerShell variables being mangled on Windows when commands invoked PowerShell as a subprocess (e.g. `powershell -Command "Write-Host $env:SystemRoot"`). Brush-core applied POSIX parameter expansion to `$env` before spawning the child, leaving a dangling `:NAME`. The fix lives in `pi-shell` at env-var application time: every brush session now defines `env=$env` as an internal shell variable so `$env:NAME` expands to the literal `$env:NAME` token that PowerShell expects. The fallback is not exported, only influences brush's own expansion, and is shadowed by any user assignment to `env` (e.g. `env=prod; echo "$env:8080"` still prints `prod:8080`), so the POSIX bash contract is preserved. ([#1079](https://github.com/can1357/oh-my-pi/issues/1079))
+
+
 ## [15.0.1] - 2026-05-14
 ### Breaking Changes
 
@@ -15,6 +52,7 @@
 - Added per-line column cap shared across streaming tool outputs (`bash`, `ssh`, `python`, `js eval`) and the `read` tool. Lines wider than `tools.outputMaxColumns` bytes (default **768**) are ellipsis-truncated at write time and remaining bytes up to the next `\n` are dropped — bounded memory even on multi-MB single-line outputs (e.g. `cat /dev/urandom`). The cap lives on `OutputSink` as the new `maxColumns` option, persists state across chunk boundaries so split-mid-line writes still respect the budget, and exposes `columnDroppedBytes` / `columnTruncatedLines` on `OutputSummary`. Middle-elision byte math subtracts column drops so the "elided from middle" count stays honest. `read` reuses the same setting but trims its already-collected lines via `truncateLine`. Skipped when the read selector is `:raw`. The artifact file (`artifact://<id>`) keeps the full uncapped stream. Set `tools.outputMaxColumns = 0` to disable.
 - Added Bun HTTP/2 fetch opt-in. Dev scripts (`bun run dev`, `bun run stats`) now pass `bun --experimental-http2-fetch` so every `fetch()` advertises `h2` in the TLS ALPN list and falls back to HTTP/1.1 when the server doesn't select it. Multiplexing collapses parallel requests to the same origin onto one TLS connection. For the installed `omp` binary, export `BUN_FEATURE_FLAG_EXPERIMENTAL_HTTP2_CLIENT=1` in your shell to enable the same behavior (the flag has to be set before Bun starts; `process.env` from inside JS is too late). Requires Bun **1.3.14**.
 - Added per-subagent cost display (`$X.XX` in the task progress tree and the session-observer stats line). Cost is accumulated incrementally from `message_end` events and shown only when non-zero, using the `statusLineCost` theme color. Providers that do not report per-turn cost data (e.g. subscription/OAuth usage) continue to show nothing.
+- Added ACP elicitation bridge so skills/extensions calling `select`, `confirm`, or `input` on the extension UI context now produce real `unstable_createElicitation` form requests to the ACP client (rather than always resolving to `undefined` / `false`). The `acpExtensionUiContext` constant is promoted to `createAcpExtensionUiContext(connection, getSessionId, clientCapabilities)` — invoked once per session inside `#configureExtensions`, with `getSessionId: () => string` so the live `record.session.sessionId` is read on every elicitation (the underlying id mutates when an extension command calls `ctx.newSession` / `ctx.switchSession`). Each method maps to a single-property `value` schema: `select` → `{type: "string", enum}`, `confirm` → `{type: "boolean"}` (joined `title` + `message` when the trimmed message is non-empty; otherwise just `title`), `input` → `{type: "string", description: placeholder?}` (ACP has no `placeholder` field on `StringPropertySchema`; empty / whitespace-only placeholders are treated as absent). `accept` responses narrow the returned `ElicitationContentValue` back to the method's declared type with a runtime `typeof` guard; `decline` / `cancel` / transport failures fall back to the prior stub return values. `dialogOptions.signal` is honored: an already-aborted signal short-circuits before any SDK round-trip, and an abort mid-flight races against the elicitation so the caller's promise resolves to the stub fallback (the ACP request itself keeps running on the client side — the SDK exposes no form-mode cancel surface; `unstable_completeElicitation` is URL-mode only — matching the in-flight pattern used by `requestRpcEditor`). `dialogOptions.timeout` is honored on parity with `RpcExtensionUIContext`: when the timer fires before the client responds, `onTimeout` is invoked and the caller resolves to the stub fallback. A throwing `onTimeout` is caught and logged (`logger.warn`) so the elicitation promise still settles. Late SDK rejections that arrive after abort/timeout are dropped silently to keep operator logs clean; transport failures still emit `logger.warn` with `{ sessionId, method, error }`. Calls are skipped when the client did not advertise `clientCapabilities.elicitation.form` during `initialize`, so non-elicitation clients are unaffected. `createAcpExtensionUiContext` is exported for tests.
 
 ### Changed
 

package/package.json

@@ -1,9 +1,9 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.0.1",
+	"version": "15.0.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
-	"homepage": "https://github.com/can1357/oh-my-pi",
+	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
 	"contributors": [
 		"Mario Zechner"
@@ -47,12 +47,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "15.0.1",
-		"@oh-my-pi/pi-agent-core": "15.0.1",
-		"@oh-my-pi/pi-ai": "15.0.1",
-		"@oh-my-pi/pi-natives": "15.0.1",
-		"@oh-my-pi/pi-tui": "15.0.1",
-		"@oh-my-pi/pi-utils": "15.0.1",
+		"@oh-my-pi/omp-stats": "15.0.2",
+		"@oh-my-pi/pi-agent-core": "15.0.2",
+		"@oh-my-pi/pi-ai": "15.0.2",
+		"@oh-my-pi/pi-natives": "15.0.2",
+		"@oh-my-pi/pi-tui": "15.0.2",
+		"@oh-my-pi/pi-utils": "15.0.2",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@types/turndown": "5.0.6",

package/src/commands/commit.ts

@@ -1,6 +1,7 @@
 /**
  * Generate and optionally push a commit with changelog updates.
  */
+import { postmortem } from "@oh-my-pi/pi-utils";
 import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runCommitCommand } from "../commit";
 import type { CommitCommandArgs } from "../commit/types";
@@ -31,6 +32,15 @@ export default class Commit extends Command {
 		};
 
 		await initTheme();
+		// The agentic commit flow opens HTTP/2 keep-alive sockets to the model
+		// provider (via `installH2Fetch`) and spins up an AgentSession with
+		// background async-job + extension machinery. `session.dispose()` releases
+		// what it can, but Bun's fetch keeps idle connections warm and a few
+		// timers (Settings autosave, OAuth refresh) stay armed long enough to
+		// pin the event loop after the commit is already written. Mirror the
+		// `runPrintMode` exit pattern from `main.ts` so the CLI returns to the
+		// shell instead of stranding the user on Ctrl+C (issue #1041).
 		await runCommitCommand(cmd);
+		await postmortem.quit(0);
 	}
 }

package/src/config/model-registry.ts

@@ -1015,8 +1015,12 @@ export class ModelRegistry {
 
 		this.#addImplicitDiscoverableProviders(configuredProviders);
 		const builtInModels = this.#applyHardcodedModelPolicies(this.#loadBuiltInModels(overrides));
+		const cachedStandardModels = this.#applyHardcodedModelPolicies(this.#loadCachedStandardProviderModels());
 		const cachedDiscoveries = this.#applyHardcodedModelPolicies(this.#loadCachedDiscoverableModels());
-		const resolvedDefaults = this.#mergeResolvedModels(builtInModels, cachedDiscoveries);
+		const resolvedDefaults = this.#mergeResolvedModels(
+			this.#mergeResolvedModels(builtInModels, cachedStandardModels),
+			cachedDiscoveries,
+		);
 		const withConfigModels = this.#mergeCustomModels(resolvedDefaults, this.#customModelOverlays);
 		// Merge runtime extension models so they survive refresh() cycles
 		const combined = this.#mergeCustomModels(withConfigModels, this.#runtimeModelOverlays);
@@ -1115,6 +1119,32 @@ export class ModelRegistry {
 		return merged;
 	}
 
+	#loadCachedStandardProviderModels(): Model<Api>[] {
+		const configuredDiscoveryProviders = new Set(this.#discoverableProviders.map(provider => provider.provider));
+		const cachedModels: Model<Api>[] = [];
+		for (const descriptor of PROVIDER_DESCRIPTORS) {
+			if (configuredDiscoveryProviders.has(descriptor.providerId)) {
+				continue;
+			}
+			const cache = readModelCache<Api>(descriptor.providerId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
+			if (!cache) {
+				continue;
+			}
+			const models = cache.models.map(model =>
+				model.provider === descriptor.providerId ? model : { ...model, provider: descriptor.providerId },
+			);
+			const providerOverride = this.#providerOverrides.get(descriptor.providerId);
+			const withTransport = providerOverride
+				? models.map(model => this.#applyProviderTransportOverride(model, providerOverride))
+				: models;
+			const withCompat = providerOverride?.compat
+				? withTransport.map(model => ({ ...model, compat: mergeCompat(model.compat, providerOverride.compat) }))
+				: withTransport;
+			cachedModels.push(...this.#applyProviderModelOverrides(descriptor.providerId, withCompat));
+		}
+		return cachedModels;
+	}
+
 	#loadCachedDiscoverableModels(): Model<Api>[] {
 		const cachedModels: Model<Api>[] = [];
 		for (const providerConfig of this.#discoverableProviders) {

package/src/config/settings-schema.ts

@@ -1648,6 +1648,17 @@ export const SETTINGS_SCHEMA = {
 	},
 	"bashInterceptor.patterns": { type: "array", default: DEFAULT_BASH_INTERCEPTOR_RULES },
 
+	"bash.stripTrailingHeadTail": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "editing",
+			label: "Strip Trailing head/tail",
+			description:
+				"Silently drop trailing `| head`/`| tail` pipes from single-line bash commands. Output is already truncated automatically.",
+		},
+	},
+
 	// Shell output minimizer
 	"shellMinimizer.enabled": {
 		type: "boolean",

package/src/discovery/claude-plugins.ts

@@ -31,6 +31,7 @@ const PRIORITY = 70; // Below claude.ts (80) so user .claude/ overrides win
 interface ClaudePluginManifest {
 	skills?: string;
 	"slash-commands"?: string;
+	commands?: string;
 }
 
 interface ResolvedPluginDir {
@@ -59,24 +60,35 @@ function isWithinPluginRoot(rootPath: string, targetPath: string): boolean {
 
 async function resolvePluginDir(
 	root: ClaudePluginRoot,
-	manifestKey: keyof ClaudePluginManifest,
+	manifestKeys: ReadonlyArray<keyof ClaudePluginManifest>,
 	fallback: string,
 ): Promise<ResolvedPluginDir> {
 	const manifest = await readPluginManifest(root);
 	const fallbackDir = path.join(root.path, fallback);
-	const configured = manifest?.[manifestKey];
-	if (typeof configured !== "string" || !configured.trim()) {
+
+	let configured: string | undefined;
+	let matchedKey: keyof ClaudePluginManifest | undefined;
+	for (const key of manifestKeys) {
+		const val = manifest?.[key];
+		if (typeof val === "string" && val.trim()) {
+			configured = val.trim();
+			matchedKey = key;
+			break;
+		}
+	}
+
+	if (configured === undefined) {
 		return { dir: fallbackDir };
 	}
 
-	const resolved = path.resolve(root.path, configured.trim());
+	const resolved = path.resolve(root.path, configured);
 	if (isWithinPluginRoot(root.path, resolved)) {
 		return { dir: resolved };
 	}
 
 	return {
 		dir: fallbackDir,
-		warning: `[claude-plugins] Ignoring ${String(manifestKey)} path outside plugin root for ${root.id}: ${configured}`,
+		warning: `[claude-plugins] Ignoring ${String(matchedKey)} path outside plugin root for ${root.id}: ${configured}`,
 	};
 }
 
@@ -93,7 +105,7 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const { dir: skillsDir, warning } = await resolvePluginDir(root, "skills", "skills");
+			const { dir: skillsDir, warning } = await resolvePluginDir(root, ["skills"], "skills");
 			const result = await scanSkillsFromDir(ctx, {
 				dir: skillsDir,
 				providerId: PROVIDER_ID,
@@ -128,7 +140,7 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const { dir: commandsDir, warning } = await resolvePluginDir(root, "slash-commands", "commands");
+			const { dir: commandsDir, warning } = await resolvePluginDir(root, ["commands", "slash-commands"], "commands");
 			const result = await loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
 				extensions: ["md"],
 				transform: (name, content, filePath, source) => {

package/src/eval/py/runner.py

@@ -25,9 +25,11 @@ when installed.
 
 from __future__ import annotations
 
+import asyncio
 import ast
 import base64
 import builtins
+import inspect
 import io
 import json
 import os
@@ -120,6 +122,7 @@ class _RunnerState:
             "__builtins__": builtins,
         }
         self.last_install_marker: int = 0
+        self.loop: asyncio.AbstractEventLoop | None = None
 
 
 _STATE = _RunnerState()
@@ -688,13 +691,41 @@ _install_builtins(_STATE.user_ns)
 # ---------------------------------------------------------------------------
 
 
+_TLA_FLAG = getattr(ast, "PyCF_ALLOW_TOP_LEVEL_AWAIT", 0x2000)
+
+
+def _get_event_loop() -> asyncio.AbstractEventLoop:
+    loop = _STATE.loop
+    if loop is None or loop.is_closed():
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        _STATE.loop = loop
+    return loop
+
+
+def _run_compiled(code, ns: dict, *, want_value: bool) -> Any:
+    """Execute a code object, awaiting it if compiled as a coroutine.
+
+    ``want_value`` is True for the trailing expression — we return ``eval``'s
+    result (or the awaited coroutine's value). For statement blocks the
+    return is always ``None``.
+    """
+    if code.co_flags & inspect.CO_COROUTINE:
+        coro = eval(code, ns)
+        result = _get_event_loop().run_until_complete(coro)
+        return result if want_value else None
+    if want_value:
+        return eval(code, ns)
+    exec(code, ns)
+    return None
+
+
 def _exec_source(source: str, ns: dict) -> None:
     """Compile + execute ``source``; if the last node is an expression, route
-    its value through ``__omp_display`` so dataframes/figures render rich."""
-    try:
-        module = ast.parse(source, mode="exec")
-    except SyntaxError:
-        raise
+    its value through ``__omp_display`` so dataframes/figures render rich.
+    Top-level ``await`` / ``async for`` / ``async with`` is permitted; the
+    cell is driven through the runner's persistent event loop."""
+    module = ast.parse(source, mode="exec")
 
     if not module.body:
         return
@@ -704,16 +735,16 @@ def _exec_source(source: str, ns: dict) -> None:
         body_module = ast.Module(body=module.body[:-1], type_ignores=[])
         expr_module = ast.Expression(body=last.value)
         ast.copy_location(expr_module, last)
-        body_code = compile(body_module, "<cell>", "exec")
-        expr_code = compile(expr_module, "<cell>", "eval")
-        exec(body_code, ns)
-        value = eval(expr_code, ns)
+        body_code = compile(body_module, "<cell>", "exec", flags=_TLA_FLAG)
+        expr_code = compile(expr_module, "<cell>", "eval", flags=_TLA_FLAG)
+        _run_compiled(body_code, ns, want_value=False)
+        value = _run_compiled(expr_code, ns, want_value=True)
         if value is not None:
             __omp_display(value, kind="result")
         return
 
-    code = compile(module, "<cell>", "exec")
-    exec(code, ns)
+    code = compile(module, "<cell>", "exec", flags=_TLA_FLAG)
+    _run_compiled(code, ns, want_value=False)
 
 
 # ---------------------------------------------------------------------------

package/src/eval/py/runtime.ts

@@ -151,6 +151,7 @@ export function filterEnv(env: Record<string, string | undefined>): Record<strin
  */
 export function resolveVenvPath(cwd: string): string | undefined {
 	if ($env.VIRTUAL_ENV) return $env.VIRTUAL_ENV;
+	if ($env.CONDA_PREFIX) return $env.CONDA_PREFIX;
 	const candidates = [path.join(cwd, ".venv"), path.join(cwd, "venv")];
 	for (const candidate of candidates) {
 		if (fs.existsSync(candidate)) {

package/src/extensibility/extensions/get-commands-handler.ts

@@ -0,0 +1,77 @@
+/**
+ * Helper for wiring the `getCommands` action of {@link ExtensionAPI}.
+ *
+ * Centralizes the union over the three slash-command sources the runtime
+ * exposes so the five wiring sites (interactive UI, ACP, RPC, print, child
+ * task executor) cannot drift:
+ *   - extension-registered hook commands (`source: "extension"`)
+ *   - prompt commands loaded as `LoadedCustomCommand` — user/project/bundled
+ *     custom commands and MCP prompts (`source: "prompt"`)
+ *   - skill commands derived from `session.skills`, gated on
+ *     `skillsSettings.enableSkillCommands` (`source: "skill"`)
+ *
+ * Built-in slash commands are intentionally excluded; `getCommands()` is the
+ * surface extensions use to discover dynamic commands they did not register
+ * themselves. Each frontend (interactive-mode, ACP) prepends its own builtins.
+ */
+import type { SkillsSettings } from "../../config/settings";
+import type { CustomCommandSource, LoadedCustomCommand } from "../custom-commands";
+import { getSkillSlashCommandName, type Skill } from "../skills";
+import type { SlashCommandInfo, SlashCommandLocation } from "../slash-commands";
+import type { ExtensionRunner } from "./runner";
+
+interface CommandsCapableSession {
+	readonly extensionRunner?: ExtensionRunner;
+	readonly customCommands: ReadonlyArray<LoadedCustomCommand>;
+	readonly skills: ReadonlyArray<Skill>;
+	readonly skillsSettings?: SkillsSettings;
+}
+
+export function getSessionSlashCommands(session: CommandsCapableSession): SlashCommandInfo[] {
+	const out: SlashCommandInfo[] = [];
+
+	const runner = session.extensionRunner;
+	if (runner) {
+		for (const cmd of runner.getRegisteredCommands()) {
+			out.push({
+				name: cmd.name,
+				description: cmd.description,
+				source: "extension",
+			});
+		}
+	}
+
+	for (const cmd of session.customCommands) {
+		out.push({
+			name: cmd.command.name,
+			description: cmd.command.description,
+			source: "prompt",
+			location: customCommandLocation(cmd.source),
+			path: cmd.resolvedPath,
+		});
+	}
+
+	if (session.skillsSettings?.enableSkillCommands) {
+		for (const skill of session.skills) {
+			out.push({
+				name: getSkillSlashCommandName(skill),
+				description: skill.description || undefined,
+				source: "skill",
+				path: skill.filePath,
+			});
+		}
+	}
+
+	return out;
+}
+
+function customCommandLocation(source: CustomCommandSource): SlashCommandLocation | undefined {
+	switch (source) {
+		case "user":
+			return "user";
+		case "project":
+			return "project";
+		case "bundled":
+			return undefined;
+	}
+}

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -3,21 +3,46 @@ import * as os from "node:os";
 import * as path from "node:path";
 import * as url from "node:url";
 
-const LEGACY_PI_PACKAGE_MAP = {
-	"@mariozechner/pi-agent-core": "@oh-my-pi/pi-agent-core",
-	"@mariozechner/pi-ai": "@oh-my-pi/pi-ai",
-	"@mariozechner/pi-coding-agent": "@oh-my-pi/pi-coding-agent",
-	"@mariozechner/pi-tui": "@oh-my-pi/pi-tui",
-} as const;
-
-const LEGACY_PI_CODING_AGENT_SUBPATH_MAP = {
-	"extensibility/extensions": "@oh-my-pi/pi-coding-agent/extensibility/extensions",
-	"extensibility/hooks": "@oh-my-pi/pi-coding-agent/extensibility/hooks",
-} as const;
-
-const LEGACY_PI_SPECIFIER_FILTER = /^@mariozechner\/pi-(agent-core|ai|coding-agent|tui)(\/.*)?$/;
-const LEGACY_PI_IMPORT_SPECIFIER_REGEX =
-	/((?:from\s+|import\s*\(\s*)["'])(@mariozechner\/pi-(?:agent-core|ai|coding-agent|tui)(?:\/[^"'()\s]+)?)(["'])/g;
+// Canonical scope for in-process pi packages. Plugins published against any of
+// the aliased scopes below (mariozechner's original publish, earendil-works'
+// fork, or the canonical @oh-my-pi scope itself) are remapped to this scope and
+// resolved against the bundled copy that ships inside the omp binary. This
+// keeps plugins running against the exact runtime state of the host (single
+// module registry, single tool registry, etc.) regardless of which historical
+// scope name they happened to declare in their peerDependencies.
+const CANONICAL_PI_SCOPE = "@oh-my-pi";
+
+// Scopes that have historically been used to publish (or alias) the same set
+// of internal pi-* packages. `@oh-my-pi` is intentionally included so that
+// direct imports of the canonical name still flow through `Bun.resolveSync`
+// against the host binary, avoiding a duplicate copy being pulled in from a
+// plugin's own node_modules tree at install time.
+const PI_SCOPE_ALIASES = ["oh-my-pi", "mariozechner", "earendil-works"] as const;
+
+// Internal pi-* package basenames bundled inside the omp binary.
+const PI_PACKAGE_NAMES = ["pi-agent-core", "pi-ai", "pi-coding-agent", "pi-natives", "pi-tui", "pi-utils"] as const;
+
+const PI_SCOPE_ALTERNATION = PI_SCOPE_ALIASES.join("|");
+const PI_PACKAGE_ALTERNATION = PI_PACKAGE_NAMES.join("|");
+
+// Upstream `@mariozechner/*` packages exposed a few subpaths at the package
+// root that we relocated under a different folder. Each entry rewrites
+// `<pkg>/<from>` → `<pkg>/<to>` after the scope has been canonicalised, so
+// plugins importing the upstream layout still resolve to a real file in our
+// bundled copy. Add new entries as `pkg/from -> pkg/to` whenever a plugin
+// surfaces another upstream-only subpath that breaks resolution.
+const PI_SUBPATH_REMAPS: ReadonlyMap<string, string> = new Map<string, string>([
+	// `@mariozechner/pi-ai/oauth` re-exported `./utils/oauth/index.js`.
+	// Our pi-ai keeps the implementation under `utils/oauth` but never added a
+	// root-level re-export, so map the upstream subpath onto it directly.
+	["pi-ai/oauth", "pi-ai/utils/oauth"],
+]);
+
+const LEGACY_PI_SPECIFIER_FILTER = new RegExp(`^@(?:${PI_SCOPE_ALTERNATION})/(?:${PI_PACKAGE_ALTERNATION})(?:/.*)?$`);
+const LEGACY_PI_IMPORT_SPECIFIER_REGEX = new RegExp(
+	`((?:from\\s+|import\\s*\\(\\s*)["'])(@(?:${PI_SCOPE_ALTERNATION})/(?:${PI_PACKAGE_ALTERNATION})(?:/[^"'()\\s]+)?)(["'])`,
+	"g",
+);
 const LEGACY_PI_FILE_PREFIX = "omp-legacy-pi-file:";
 const LEGACY_PI_FILE_NAMESPACE = "omp-legacy-pi-file";
 const resolvedSpecifierFallbacks = new Map<string, string>();
@@ -25,25 +50,17 @@ const resolvedSpecifierFallbacks = new Map<string, string>();
 let isLegacyPiSpecifierShimInstalled = false;
 
 function remapLegacyPiSpecifier(specifier: string): string | null {
-	const [legacyScope, packageName, ...subpathParts] = specifier.split("/");
-	const legacyPackageName = `${legacyScope}/${packageName}`;
-	const mappedPackageName = LEGACY_PI_PACKAGE_MAP[legacyPackageName as keyof typeof LEGACY_PI_PACKAGE_MAP];
-	if (!mappedPackageName) {
+	if (!LEGACY_PI_SPECIFIER_FILTER.test(specifier)) {
 		return null;
 	}
-	if (subpathParts.length === 0) {
-		return mappedPackageName;
-	}
-
-	const subpath = subpathParts.join("/");
-	if (legacyPackageName === "@mariozechner/pi-coding-agent") {
-		return (
-			LEGACY_PI_CODING_AGENT_SUBPATH_MAP[subpath as keyof typeof LEGACY_PI_CODING_AGENT_SUBPATH_MAP] ??
-			`${mappedPackageName}/${subpath}`
-		);
+	const slashIdx = specifier.indexOf("/", 1);
+	// Filter guarantees a slash exists, but guard anyway to keep the type narrow.
+	if (slashIdx === -1) {
+		return null;
 	}
-
-	return `${mappedPackageName}/${subpath}`;
+	const rest = specifier.slice(slashIdx + 1);
+	const remappedSubpath = PI_SUBPATH_REMAPS.get(rest) ?? rest;
+	return `${CANONICAL_PI_SCOPE}/${remappedSubpath}`;
 }
 
 function getResolvedSpecifier(specifier: string): string {

package/src/hashline/input.ts

@@ -108,7 +108,8 @@ export function splitHashlineInputs(input: string, options: SplitHashlineOptions
 
 	const flush = () => {
 		if (currentPath.length === 0) return;
-		sections.push({ path: currentPath, diff: currentLines.join("\n") });
+		const hasOps = currentLines.some(rawLine => stripTrailingCarriageReturn(rawLine).trim().length > 0);
+		if (hasOps) sections.push({ path: currentPath, diff: currentLines.join("\n") });
 		currentLines = [];
 	};
 

package/src/hashline/parser.ts

@@ -86,9 +86,33 @@ function collectPayload(
 	let index = startIndex;
 	while (index < lines.length) {
 		const line = stripTrailingCarriageReturn(lines[index]);
-		if (!line.startsWith(HL_EDIT_SEP)) break;
-		payload.push(line.slice(1));
-		index++;
+		if (line.startsWith(HL_EDIT_SEP)) {
+			payload.push(line.slice(1));
+			index++;
+			continue;
+		}
+		// Silently recover from a missing payload prefix on an otherwise blank
+		// line: if more payload follows (possibly past further blanks), treat
+		// each intervening blank as an empty `${HL_EDIT_SEP}` payload line.
+		// Additionally, when the op explicitly requires payload (`+`/`<`) and
+		// we have not collected any yet, accept the blank(s) themselves as the
+		// empty payload — common typo of forgetting the `${HL_EDIT_SEP}` prefix
+		// when inserting a blank line.
+		if (line.length === 0) {
+			let lookahead = index + 1;
+			while (lookahead < lines.length && stripTrailingCarriageReturn(lines[lookahead]).length === 0) {
+				lookahead++;
+			}
+			const followedByPayload =
+				lookahead < lines.length && stripTrailingCarriageReturn(lines[lookahead]).startsWith(HL_EDIT_SEP);
+			const acceptBareBlank = requirePayload && payload.length === 0;
+			if (followedByPayload || acceptBareBlank) {
+				for (let j = index; j < lookahead; j++) payload.push("");
+				index = lookahead;
+				continue;
+			}
+		}
+		break;
 	}
 	if (payload.length === 0 && requirePayload) {
 		throw new Error(`line ${opLineNum}: + and < operations require at least one ${HL_EDIT_SEP}TEXT payload line.`);