@oh-my-pi/pi-coding-agent 9.6.4 → 9.8.0

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [9.8.0] - 2026-02-01
+### Breaking Changes
+
+- Removed persistent shell session support; bash execution now uses native bindings via brush-core for improved reliability
+
+### Added
+
+- Added `sessionKey` option to bash executor to isolate shell sessions per agent instance
+- Added shell snapshot support for bash execution to preserve shell state across commands
+- Added `onChunk` callback support for streaming command output in real-time
+
+### Changed
+
+- Refactored bash executor to queue output chunks asynchronously for improved reliability
+- Updated bash executor to pass environment variables separately as `sessionEnv` to native bindings
+- Migrated system information collection to use native bindings from brush-core instead of shell command execution
+- Updated CPU information to report core count alongside model name
+- Simplified OS version reporting to use Node.js built-in APIs
+- Migrated bash command execution from ptree-based persistent sessions to native shell bindings with streaming support
+- Simplified bash executor to use brush-core native API instead of managing long-lived shell processes
+- Routed clipboard copy and image paste through native arboard bindings instead of shell commands
+- Embedded native addon payload for compiled binaries and extract to `~/.omp/natives/<version>` on first run
+
+### Removed
+
+- Removed shell configuration from environment information display
+- Removed `shell-session.ts` module providing persistent shell session management
+- Removed shell session test suite for persistent execution patterns
+
 ## [9.6.2] - 2026-02-01
 ### Changed
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "9.6.4",
+	"version": "9.8.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -74,17 +74,17 @@
 	"scripts": {
 		"check": "tsgo -p tsconfig.json",
 		"format-prompts": "bun scripts/format-prompts.ts",
-		"build:binary": "cd ../.. && bun build --compile --define OMP_COMPILED=true --root . ./packages/coding-agent/src/cli.ts --outfile packages/coding-agent/dist/omp",
+		"build:binary": "cd ../.. && bun --cwd=packages/natives run embed:native && bun build --compile --define OMP_COMPILED=true --root . ./packages/coding-agent/src/cli.ts --outfile packages/coding-agent/dist/omp && bun --cwd=packages/natives run embed:native --reset",
 		"generate-template": "bun scripts/generate-template.ts",
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "9.6.4",
-		"@oh-my-pi/pi-agent-core": "9.6.4",
-		"@oh-my-pi/pi-ai": "9.6.4",
-		"@oh-my-pi/pi-natives": "9.6.4",
-		"@oh-my-pi/pi-tui": "9.6.4",
-		"@oh-my-pi/pi-utils": "9.6.4",
+		"@oh-my-pi/omp-stats": "9.8.0",
+		"@oh-my-pi/pi-agent-core": "9.8.0",
+		"@oh-my-pi/pi-ai": "9.8.0",
+		"@oh-my-pi/pi-natives": "9.8.0",
+		"@oh-my-pi/pi-tui": "9.8.0",
+		"@oh-my-pi/pi-utils": "9.8.0",
 		"@openai/agents": "^0.4.4",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",

package/src/exec/bash-executor.ts

@@ -1,19 +1,20 @@
 /**
  * Bash command execution with streaming support and cancellation.
  *
- * Provides unified bash execution for AgentSession.executeBash() and direct calls.
+ * Uses brush-core via native bindings for shell execution.
  */
-import { Exception, ptree } from "@oh-my-pi/pi-utils";
+import { Shell } from "@oh-my-pi/pi-natives";
 import { Settings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
-import { getOrCreateSnapshot, getSnapshotSourceCommand } from "../utils/shell-snapshot";
-import { executeShellCommand } from "./shell-session";
+import { getOrCreateSnapshot } from "../utils/shell-snapshot";
 
 export interface BashExecutorOptions {
 	cwd?: string;
 	timeout?: number;
 	onChunk?: (chunk: string) => void;
 	signal?: AbortSignal;
+	/** Session key suffix to isolate shell sessions per agent */
+	sessionKey?: string;
 	/** Additional environment variables to inject */
 	env?: Record<string, string>;
 	/** Artifact path/id for full output storage */
@@ -33,117 +34,114 @@ export interface BashResult {
 	artifactId?: string;
 }
 
+const shellSessions = new Map<string, Shell>();
+
 export async function executeBash(command: string, options?: BashExecutorOptions): Promise<BashResult> {
 	const settings = await Settings.init();
-	const { shell, args, env, prefix } = settings.getShellConfig();
-	const snapshotPath = await getOrCreateSnapshot(shell, env);
-
-	if (shouldUsePersistentShell(settings.get("bash.persistentShell"))) {
-		return await executeShellCommand({ shell, env, prefix, snapshotPath }, command, {
-			cwd: options?.cwd,
-			timeout: options?.timeout,
-			signal: options?.signal,
-			onChunk: options?.onChunk,
-			env: options?.env,
-			artifactPath: options?.artifactPath,
-			artifactId: options?.artifactId,
-		});
-	}
-
-	return await executeBashOnce(command, options, { shell, args, env, prefix, snapshotPath });
-}
-
-/**
- * Determine whether to use persistent shell sessions.
- * Priority: OMP_SHELL_PERSIST env var > settings > default (false)
- */
-function shouldUsePersistentShell(settingValue: boolean): boolean {
-	// Env var takes precedence (for debugging/override)
-	const flag = parseEnvFlag(process.env.OMP_SHELL_PERSIST);
-	if (flag !== undefined) return flag;
-	// Windows never uses persistent shell (too unreliable)
-	if (process.platform === "win32") return false;
-	// Use setting value (defaults to false)
-	return settingValue;
-}
-
-function parseEnvFlag(value: string | undefined): boolean | undefined {
-	if (!value) return undefined;
-	const normalized = value.toLowerCase();
-	if (["1", "true", "yes", "on"].includes(normalized)) return true;
-	if (["0", "false", "no", "off"].includes(normalized)) return false;
-	return undefined;
-}
+	const { shell, env: shellEnv, prefix } = settings.getShellConfig();
+	const snapshotPath = shell.includes("bash") ? await getOrCreateSnapshot(shell, shellEnv) : null;
 
-async function executeBashOnce(
-	command: string,
-	options: BashExecutorOptions | undefined,
-	config: {
-		shell: string;
-		args: string[];
-		env: Record<string, string | undefined>;
-		prefix?: string;
-		snapshotPath: string | null;
-	},
-): Promise<BashResult> {
-	const { shell, args, env, prefix, snapshotPath } = config;
-
-	// Merge additional env vars if provided
-	const finalEnv = options?.env ? { ...env, ...options.env } : env;
-	const snapshotPrefix = getSnapshotSourceCommand(snapshotPath);
+	// Apply command prefix if configured
 	const prefixedCommand = prefix ? `${prefix} ${command}` : command;
-	const finalCommand = `${snapshotPrefix}${prefixedCommand}`;
+	const finalCommand = prefixedCommand;
 
+	// Create output sink for truncation and artifact handling
 	const sink = new OutputSink({
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
 	});
 
-	using child = ptree.spawn([shell, ...args, finalCommand], {
-		cwd: options?.cwd,
-		env: finalEnv,
-		signal: options?.signal,
-		timeout: options?.timeout,
-		detached: true,
-	});
+	let pendingChunks = Promise.resolve();
+	const enqueueChunk = (chunk: string) => {
+		pendingChunks = pendingChunks.then(() => sink.push(chunk)).catch(() => {});
+	};
 
-	// Pump streams - errors during abort/timeout are expected
-	// Use preventClose to avoid closing the shared sink when either stream finishes
-	await Promise.allSettled([child.stdout.pipeTo(sink.createInput()), child.stderr.pipeTo(sink.createInput())]).catch(
-		() => {},
-	);
+	if (options?.signal?.aborted) {
+		return {
+			exitCode: undefined,
+			cancelled: true,
+			...(await sink.dump("Command cancelled")),
+		};
+	}
+
+	let abortListener: (() => void) | undefined;
 
-	// Wait for process exit
 	try {
+		const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey);
+		let shellSession = shellSessions.get(sessionKey);
+		if (!shellSession) {
+			shellSession = new Shell({ sessionEnv: shellEnv, snapshotPath: snapshotPath ?? undefined });
+			shellSessions.set(sessionKey, shellSession);
+		}
+
+		if (options?.signal) {
+			abortListener = () => {
+				shellSession?.abort();
+			};
+			options.signal.addEventListener("abort", abortListener, { once: true });
+		}
+
+		const result = await shellSession.run(
+			{
+				command: finalCommand,
+				cwd: options?.cwd,
+				env: options?.env,
+				timeoutMs: options?.timeout,
+			},
+			(err, chunk) => {
+				if (!err) {
+					enqueueChunk(chunk);
+				}
+			},
+		);
+
+		await pendingChunks;
+
+		// Handle timeout
+		if (result.timedOut) {
+			const annotation = options?.timeout
+				? `Command timed out after ${Math.round(options.timeout / 1000)} seconds`
+				: "Command timed out";
+			return {
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump(annotation)),
+			};
+		}
+
+		// Handle cancellation
+		if (result.cancelled) {
+			return {
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump("Command cancelled")),
+			};
+		}
+
+		// Normal completion
 		return {
-			exitCode: await child.exited,
+			exitCode: result.exitCode,
 			cancelled: false,
 			...(await sink.dump()),
 		};
-	} catch (err: unknown) {
-		// Exception covers NonZeroExitError, AbortError, TimeoutError
-		if (err instanceof Exception) {
-			if (err.aborted) {
-				const isTimeout = err instanceof ptree.TimeoutError || err.message.toLowerCase().includes("timed out");
-				const annotation = isTimeout
-					? `Command timed out after ${Math.round((options?.timeout ?? 0) / 1000)} seconds`
-					: undefined;
-				return {
-					exitCode: undefined,
-					cancelled: true,
-					...(await sink.dump(annotation)),
-				};
-			}
-
-			// NonZeroExitError
-			return {
-				exitCode: err.exitCode,
-				cancelled: false,
-				...(await sink.dump()),
-			};
+	} finally {
+		await pendingChunks;
+		if (options?.signal && abortListener) {
+			options.signal.removeEventListener("abort", abortListener);
 		}
-
-		throw err;
 	}
 }
+
+function buildSessionKey(
+	shell: string,
+	prefix: string | undefined,
+	snapshotPath: string | null,
+	env: Record<string, string>,
+	agentSessionKey?: string,
+): string {
+	const entries = Object.entries(env);
+	entries.sort(([a], [b]) => a.localeCompare(b));
+	const envSerialized = entries.map(([key, value]) => `${key}=${value}`).join("\n");
+	return [agentSessionKey ?? "", shell, prefix ?? "", snapshotPath ?? "", envSerialized].join("\n");
+}

package/src/ipy/executor.ts

@@ -424,7 +424,8 @@ export async function executePython(code: string, options?: PythonExecutorOption
 	await ensureKernelAvailable(cwd);
 
 	const kernelMode = options?.kernelMode ?? "session";
-	const useSharedGateway = options?.useSharedGateway;
+	const isTestEnv = process.env.BUN_ENV === "test" || process.env.NODE_ENV === "test";
+	const useSharedGateway = isTestEnv ? false : options?.useSharedGateway;
 	const sessionFile = options?.sessionFile;
 	const artifactsDir = options?.artifactsDir;
 

package/src/ipy/gateway-coordinator.ts

@@ -265,8 +265,8 @@ async function startGatewayProcess(
 			stdin: "ignore",
 			stdout: "pipe",
 			stderr: "pipe",
-			detached: true,
 			windowsHide: true,
+			detached: true,
 			env: kernelEnv,
 		},
 	);
@@ -296,13 +296,13 @@ async function startGatewayProcess(
 		await Bun.sleep(100);
 	}
 
-	await procmgr.terminate({ target: gatewayProcess, group: true });
+	gatewayProcess.kill();
 	throw new Error("Gateway startup timeout");
 }
 
 async function killGateway(pid: number, context: string): Promise<void> {
 	try {
-		await procmgr.terminate({ target: pid, group: true });
+		await procmgr.terminate({ target: pid });
 	} catch (err) {
 		logger.warn("Failed to kill shared gateway process", {
 			error: err instanceof Error ? err.message : String(err),

package/src/ipy/kernel.ts

@@ -490,7 +490,6 @@ export class PythonKernel {
 				{
 					cwd: options.cwd,
 					env: kernelEnv,
-					detached: true,
 				},
 			);
 

package/src/lsp/client.ts

@@ -411,7 +411,6 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 
 		const proc = ptree.spawn([command, ...args], {
 			cwd,
-			detached: true,
 			stdin: "pipe",
 			env: env ? { ...process.env, ...env } : undefined,
 		});

package/src/main.ts

@@ -385,7 +385,8 @@ async function buildSessionOptions(
 			process.exit(1);
 		}
 		options.model = model;
-		settings.setModelRole("default", `${model.provider}/${model.id}`);
+		const currentRoles = settings.get("modelRoles") as Record<string, string>;
+		settings.override("modelRoles", { ...currentRoles, default: `${model.provider}/${model.id}` });
 	} else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
 		const remembered = settings.getModelRole("default");
 		if (remembered) {
@@ -637,9 +638,10 @@ export async function main(args: string[]) {
 	const planModel = parsed.plan ?? process.env.OMP_PLAN_MODEL;
 	if (smolModel || slowModel || planModel) {
 		const currentRoles = settings.get("modelRoles") as Record<string, string>;
-		if (smolModel) settings.override("modelRoles", { ...currentRoles, smol: smolModel });
-		if (slowModel) settings.override("modelRoles", { ...currentRoles, slow: slowModel });
-		if (planModel) settings.override("modelRoles", { ...currentRoles, plan: planModel });
+		if (smolModel) currentRoles.smol = smolModel;
+		if (slowModel) currentRoles.slow = slowModel;
+		if (planModel) currentRoles.plan = planModel;
+		settings.override("modelRoles", currentRoles);
 	}
 
 	await initTheme(settings.get("theme"), isInteractive, settings.get("symbolPreset"), settings.get("colorBlindMode"));

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

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
+import { copyToClipboard } from "@oh-my-pi/pi-natives";
 import { Loader, Markdown, padding, Spacer, Text, visibleWidth } from "@oh-my-pi/pi-tui";
 import { $ } from "bun";
 import { nanoid } from "nanoid";
@@ -18,7 +19,6 @@ import type { InteractiveModeContext } from "../../modes/types";
 import { createCompactionSummaryMessage } from "../../session/messages";
 import { outputMeta } from "../../tools/output-meta";
 import { getChangelogPath, parseChangelog } from "../../utils/changelog";
-import { copyToClipboard } from "../../utils/clipboard";
 
 export class CommandController {
 	constructor(private readonly ctx: InteractiveModeContext) {}

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

@@ -3,13 +3,13 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { readImageFromClipboard } from "@oh-my-pi/pi-natives";
 import { nanoid } from "nanoid";
 import { settings } from "../../config/settings";
 import { theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../../session/messages";
-import { readImageFromClipboard } from "../../utils/clipboard";
 import { resizeImage } from "../../utils/image-resize";
 import { generateSessionTitle, setTerminalTitle } from "../../utils/title-generator";
 
@@ -563,17 +563,18 @@ export class InputController {
 		try {
 			const image = await readImageFromClipboard();
 			if (image) {
-				let imageData = image;
+				const base64Data = Buffer.from(image.data).toString("base64");
+				let imageData = { data: base64Data, mimeType: image.mimeType };
 				if (settings.get("images.autoResize")) {
 					try {
 						const resized = await resizeImage({
 							type: "image",
-							data: image.data,
+							data: base64Data,
 							mimeType: image.mimeType,
 						});
 						imageData = { data: resized.data, mimeType: resized.mimeType };
 					} catch {
-						imageData = image;
+						imageData = { data: base64Data, mimeType: image.mimeType };
 					}
 				}
 

package/src/prompts/system/system-prompt.md

@@ -290,6 +290,31 @@ These are comfort. They are not clarity.
 {{appendSystemPrompt}}
 {{/if}}
 
+{{#if isCoordinator}}
+{{#has tools "task"}}
+<parallel_reflex>
+When the work forks, you fork.
+
+Notice the sequential habit:
+- The comfort of doing one thing at a time
+- The illusion that order means correctness
+- The assumption that you must finish A before starting B
+  **Triggers requiring Task tool:**
+- Editing 4+ files with no dependencies between edits
+- Investigating 2+ independent subsystems or questions
+- Any work that decomposes into pieces that don't need each other's results
+
+<critical>
+Sequential requires justification.
+If you cannot articulate why B depends on A's result, they are parallel.
+</critical>
+
+Do not carry the whole problem in one skull.
+Split the load. Bring back facts. Then cut code.
+</parallel_reflex>
+{{/has}}
+{{/if}}
+
 <stakes>
 This is not practice.
 
@@ -325,23 +350,4 @@ The question is not "Does this work?"
 but "Under what conditions does this work, and what happens outside them?"
 
 Write what you can defend.
-</critical>
-
-{{#if isCoordinator}}
-{{#has tools "task"}}
-<critical id="coordinator">
-Your context window is limited—especially the output. Work in discrete steps and run each step using Task tool. Avoid putting substantial work in the main context when possible. Run multiple tasks in parallel whenever possible.
-
-## Triggers requiring Task tool
-- Editing 4+ files with no dependencies → `Task`
-- Investigating 2+ independent questions → `Task`
-- Any work that decomposes into pieces that don't need each other's results → `Task`
-
-Sequential requires justification.
-If you cannot articulate why B depends on A's result, they are parallel.
-
-Do not carry the whole problem in one skull.
-Split the load. Bring back facts. Then synthesize.
-</critical>
-{{/has}}
-{{/if}}
+</critical>

package/src/session/agent-session.ts

@@ -3080,6 +3080,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			const result = await executeBashCommand(command, {
 				onChunk,
 				signal: this._bashAbortController.signal,
+				sessionKey: this.sessionId,
 			});
 
 			this.recordBashResult(command, result, options);