@oh-my-pi/pi-coding-agent 14.9.3 → 14.9.5

package/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 ## [Unreleased]
 
+## [14.9.5] - 2026-05-12
+### Breaking Changes
+
+- Removed the `jobs://` internal URL protocol; inspect background jobs via the `job` tool's `list: true` operation instead
+
+### Added
+
+- Added `since` and `until` date-range filters to `search_issues`, `search_prs`, `search_commits`, and `search_repos`, accepting relative durations (`m`/`h`/`d`/`w`/`mo`/`y`), ISO dates, and ISO datetimes
+- Added `dateField` support for date filtering (`created` or `updated`) so search results can be constrained by creation, update, pushed (for repos), or committer date (for commits)
+- Added owner-based scoping to async job registration and queries so background jobs can be registered with an `ownerId` and filtered per agent in `getRunningJobs`, `getRecentJobs`, `getAllJobs`, and `cancelAll`
+- Added agent ownership metadata to async jobs started by `task` and `bash` tools so their lifecycle and cancellation is attributed to the creating agent
+- Added `list: true` operation to the `job` tool, returning an immediate snapshot of every job spawned by the calling agent without waiting (replaces the deleted `jobs://` URL)
+- Added per-agent visibility scoping to the `job` tool so `list`, `poll`, and `cancel` only see and act on jobs owned by the calling agent; cross-agent operations now return `not_found`
+
+### Changed
+
+- Changed `search_issues`, `search_prs`, `search_commits`, and `search_repos` to allow date-only queries where `query` is omitted if `since`/`until` is provided
+- Changed `search_code` to return a validation error when `since`/`until` is supplied because GitHub code search does not support date qualifiers
+- Changed async job manager ownership so subagents inherit the parent session’s global `AsyncJobManager` instead of creating and owning separate instances
+- Changed session lifecycle cleanup so the global async-job manager is disposed only by the owning top-level session
+- Changed subagent session switches and handoff paths to stop global async-job cancellation and cancel only jobs owned by that session
+- Changed `agent://` and `artifact://` URL resolution to search artifact outputs across all active sessions instead of only the current session, allowing parent and subagent sessions to read each other’s generated outputs by ID
+- Changed `memory://` URL resolution to walk all active sessions’ memory roots and return the first matching file, so worktree-based subagents can access their own memory views as well as shared roots
+- Changed internal URL routing to use a shared process-global `InternalUrlRouter` and protocol handlers, so built-in tools resolve `agent://`, `artifact://`, `memory://`, `skill://`, `rule://`, `mcp://`, and `local://` URLs without requiring session-specific router wiring
+- Changed `mcp://` handler to use the globally registered MCP manager so MCP resource links work for agents sharing session context
+
+### Changed
+
+- Changed the `ask.timeout` default from `30` (seconds) to `0` (wait indefinitely). Auto-selecting the recommended option after a fixed delay was surprising users mid-deliberation; the timer is now strictly opt-in. The legacy auto-select behavior is preserved when `ask.timeout` is set to a non-zero value, and the `ask` tool's prompt has been updated so the model expects unlimited reply time by default.
+
+### Fixed
+
+- Added `ModelRegistry.hasConfiguredAuth(model)` to mirror the upstream `@mariozechner/pi-coding-agent` API surface; external plugins and downstream wrappers that pre-flight auth before launching a subagent no longer crash with `this._modelRegistry.hasConfiguredAuth is not a function` on the direct agent-launch path. ([#993](https://github.com/can1357/oh-my-pi/issues/993))
+- Fixed an ESM circular-import TDZ that crashed test suites when modules from the `task/` and `tools/` graphs were evaluated together (e.g. `executor-warnings.test.ts` + `task-simple-mode.test.ts`) by deferring `BUILTIN_TOOLS.task`'s `TaskTool.create` dereference to factory-call time and sourcing `truncateTail` from `session/streaming-output` instead of the `tools/` barrel
+- Treat keyless-by-design providers (llama.cpp, ollama, lm-studio) as authenticated in subagent model resolution; fixes silent fallback to parent remote model when a local model is configured. ([#1008](https://github.com/can1357/oh-my-pi/issues/1008))
+- Fixed subagent disposal and session transitions that previously canceled all running async jobs, preventing inadvertent termination of a parent agent’s background work
+- Fixed multi-entry edits silently rendering a fake success when every entry failed (e.g. all hit the auto-generated guard), by surfacing `isError: true` from the single-path edit orchestrator so the renderer takes the error branch instead of falling through to the streaming-preview fallback that displays the *proposed* diff
+- Fixed the auto-generated streaming guard being gated behind `edit.streamingAbort` (default false), so it now pre-empts streaming edit tool calls targeting auto-generated files regardless of that setting
+- Fixed subagents launched in the same parallel batch not seeing each other in their initial `# IRC Peers` system-prompt block by pre-registering the agent in the global `AgentRegistry` before `rebuildSystemPrompt` runs and attaching the live session afterwards
+- Fixed plugin manifest extensions whose entry points at a directory (e.g. `pi-goal`'s `"pi": { "extensions": [".pi/extensions/pi-goal"] }`) failing to load with `Failed to load extension: Directories cannot be read like files`. The plugin path resolver now resolves directory entries to their `index.{ts,js,mjs,cjs}` file, matching the behavior of native auto-discovery via `resolveExtensionEntries`.
+- Fixed the SSH tool on native Windows by avoiding OpenSSH ControlMaster multiplexing, which Win32-OpenSSH does not support and reports as `getsockname failed` ([#154](https://github.com/can1357/oh-my-pi/issues/154)).
+- Fixed `/export` and `/tree` not showing developer-role messages (including the plan content injected after `/plan` approval) so the HTML export and TUI session tree now render developer messages dimmed with their actual content instead of hiding them entirely ([#753](https://github.com/can1357/oh-my-pi/issues/753))
+- Fixed `Timed out initializing browser tab worker` on prebuilt binaries by rewriting `spawnTabWorker` to import the worker entry with `with { type: "file" }` so Bun's `--compile` bundler statically discovers and embeds `tab-worker-entry.ts` in the single-file binary ([#1011](https://github.com/can1357/oh-my-pi/issues/1011))
+
 ## [14.9.3] - 2026-05-10
 ### Breaking Changes
 

package/package.json

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

package/src/async/job-manager.ts

@@ -16,6 +16,13 @@ export interface AsyncJob {
 	promise: Promise<void>;
 	resultText?: string;
 	errorText?: string;
+	/**
+	 * Registry id of the agent that registered the job (e.g. "0-Main",
+	 * "3-AuthLoader"). Used by scoped cancel/list APIs so a subagent's teardown
+	 * does not cancel its parent's jobs. Undefined for callers that don't
+	 * supply an id (e.g. legacy tests, SDK consumers without an agent context).
+	 */
+	ownerId?: string;
 }
 
 export interface AsyncJobManagerOptions {
@@ -41,10 +48,38 @@ export interface AsyncJobDeliveryState {
 
 export interface AsyncJobRegisterOptions {
 	id?: string;
+	/** Registry id of the agent that owns this job; used to scope cancelAll. */
+	ownerId?: string;
 	onProgress?: (text: string, details?: Record<string, unknown>) => void | Promise<void>;
 }
 
+/**
+ * Filter applied to job query/cancel APIs. With `ownerId`, results are
+ * restricted to jobs registered by that agent (registry id from
+ * `AgentRegistry`, e.g. "0-Main", "3-AuthLoader").
+ */
+export interface AsyncJobFilter {
+	ownerId?: string;
+}
+
 export class AsyncJobManager {
+	static #instance: AsyncJobManager | undefined;
+
+	/** Process-global instance shared by internal URL protocol handlers and tools. */
+	static instance(): AsyncJobManager | undefined {
+		return AsyncJobManager.#instance;
+	}
+
+	/** Install or clear the process-global instance. */
+	static setInstance(value: AsyncJobManager | undefined): void {
+		AsyncJobManager.#instance = value;
+	}
+
+	/** Reset the process-global instance. Test-only. */
+	static resetForTests(): void {
+		AsyncJobManager.#instance = undefined;
+	}
+
 	readonly #jobs = new Map<string, AsyncJob>();
 	readonly #deliveries: AsyncJobDelivery[] = [];
 	readonly #suppressedDeliveries = new Set<string>();
@@ -56,6 +91,16 @@ export class AsyncJobManager {
 	#deliveryLoop: Promise<void> | undefined;
 	#disposed = false;
 
+	#filterJobs(jobs: Iterable<AsyncJob>, filter?: AsyncJobFilter): AsyncJob[] {
+		const ownerId = filter?.ownerId;
+		if (!ownerId) return Array.from(jobs);
+		const out: AsyncJob[] = [];
+		for (const job of jobs) {
+			if (job.ownerId === ownerId) out.push(job);
+		}
+		return out;
+	}
+
 	constructor(options: AsyncJobManagerOptions) {
 		this.#onJobComplete = options.onJobComplete;
 		this.#maxRunningJobs = Math.max(1, Math.floor(options.maxRunningJobs ?? DEFAULT_MAX_RUNNING_JOBS));
@@ -95,6 +140,7 @@ export class AsyncJobManager {
 			label,
 			abortController,
 			promise: Promise.resolve(),
+			ownerId: options?.ownerId,
 		};
 
 		const reportProgress = async (text: string, details?: Record<string, unknown>): Promise<void> => {
@@ -138,9 +184,15 @@ export class AsyncJobManager {
 		return id;
 	}
 
-	cancel(id: string): boolean {
+	/**
+	 * Cancel a single job by id. When `filter.ownerId` is set and does not
+	 * match the job's owner, the call is treated as not-found (returns false)
+	 * so cross-agent cancellation is rejected at the manager level.
+	 */
+	cancel(id: string, filter?: AsyncJobFilter): boolean {
 		const job = this.#jobs.get(id);
 		if (!job) return false;
+		if (filter?.ownerId && job.ownerId !== filter.ownerId) return false;
 		if (job.status !== "running") return false;
 		job.status = "cancelled";
 		job.abortController.abort();
@@ -152,19 +204,19 @@ export class AsyncJobManager {
 		return this.#jobs.get(id);
 	}
 
-	getRunningJobs(): AsyncJob[] {
-		return Array.from(this.#jobs.values()).filter(job => job.status === "running");
+	getRunningJobs(filter?: AsyncJobFilter): AsyncJob[] {
+		return this.#filterJobs(this.#jobs.values(), filter).filter(job => job.status === "running");
 	}
 
-	getRecentJobs(limit = 10): AsyncJob[] {
-		return Array.from(this.#jobs.values())
+	getRecentJobs(limit = 10, filter?: AsyncJobFilter): AsyncJob[] {
+		return this.#filterJobs(this.#jobs.values(), filter)
 			.filter(job => job.status !== "running")
 			.sort((a, b) => b.startTime - a.startTime)
 			.slice(0, limit);
 	}
 
-	getAllJobs(): AsyncJob[] {
-		return Array.from(this.#jobs.values());
+	getAllJobs(filter?: AsyncJobFilter): AsyncJob[] {
+		return this.#filterJobs(this.#jobs.values(), filter);
 	}
 
 	getDeliveryState(): AsyncJobDeliveryState {
@@ -221,8 +273,13 @@ export class AsyncJobManager {
 		return before - this.#deliveries.length;
 	}
 
-	cancelAll(): void {
-		for (const job of this.getRunningJobs()) {
+	/**
+	 * Cancel running jobs. With `filter.ownerId` set, cancels only jobs the
+	 * matching agent registered; with no filter, cancels every running job
+	 * (used by `dispose()` to nuke the manager's state).
+	 */
+	cancelAll(filter?: AsyncJobFilter): void {
+		for (const job of this.getRunningJobs(filter)) {
 			job.status = "cancelled";
 			job.abortController.abort();
 			this.#scheduleEviction(job.id);

package/src/capability/rule.ts

@@ -209,6 +209,26 @@ export function parseRuleConditionAndScope(frontmatter: RuleFrontmatter): Pick<R
 	};
 }
 
+let activeRules: readonly Rule[] = [];
+
+/**
+ * Process-global snapshot of rules the active session loaded.
+ * Read by internal URL protocol handlers (rule://).
+ */
+export function getActiveRules(): readonly Rule[] {
+	return activeRules;
+}
+
+/** Replace the active rule snapshot. Called once per top-level session. */
+export function setActiveRules(value: readonly Rule[]): void {
+	activeRules = value;
+}
+
+/** Reset the active rule snapshot. Test-only. */
+export function resetActiveRulesForTests(): void {
+	activeRules = [];
+}
+
 export const ruleCapability = defineCapability<Rule>({
 	id: "rules",
 	displayName: "Rules",

package/src/config/model-registry.ts

@@ -2072,6 +2072,19 @@ export class ModelRegistry {
 		return this.#models.filter(model => this.#isModelAvailable(model));
 	}
 
+	/**
+	 * Check whether auth is configured for a model's provider.
+	 *
+	 * Mirrors the upstream `@mariozechner/pi-coding-agent` API surface so that
+	 * external plugins/extensions and downstream wrappers (e.g. subagent launch
+	 * paths that pre-flight auth before model resolution) can probe a model
+	 * without resolving an API key. Returns true for keyless providers as well
+	 * as providers with stored credentials. See issue #993.
+	 */
+	hasConfiguredAuth(model: Model<Api>): boolean {
+		return this.#keylessProviders.has(model.provider) || this.authStorage.hasAuth(model.provider);
+	}
+
 	getDiscoverableProviders(): string[] {
 		const disabledProviders = getDisabledProviderIdsFromSettings();
 		return this.#discoverableProviders

package/src/config/model-resolver.ts

@@ -16,7 +16,7 @@ import chalk from "chalk";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
 import { parseThinkingLevel, resolveThinkingLevelForModel } from "../thinking";
 import { fuzzyMatch } from "../utils/fuzzy";
-import { isAuthenticated, MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
+import { isAuthenticated, kNoAuth, MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
 import type { Settings } from "./settings";
 
 /** Default model IDs for each known provider */
@@ -743,6 +743,12 @@ export function resolveModelOverride(
  * `modelRoles.task` pointing at an unqualified id whose only available
  * provider variant has no configured credentials — see #985).
  *
+ * Keyless-by-design providers (llama.cpp, ollama, lm-studio) advertise the
+ * `kNoAuth` sentinel from `getApiKey` to signal that they do not require
+ * credentials. Those are treated as authenticated here so an explicitly
+ * configured local model is never silently rerouted to the parent's remote
+ * provider (see #1008).
+ *
  * If neither the subagent nor the parent has working auth, returns the
  * primary resolution unchanged so the existing error path still surfaces
  * a meaningful failure downstream.
@@ -764,7 +770,7 @@ export async function resolveModelOverrideWithAuthFallback(
 	}
 
 	const primaryKey = await modelRegistry.getApiKey(primary.model);
-	if (isAuthenticated(primaryKey)) {
+	if (primaryKey === kNoAuth || isAuthenticated(primaryKey)) {
 		return { ...primary, authFallbackUsed: false };
 	}
 

package/src/config/settings-schema.ts

@@ -905,7 +905,7 @@ export const SETTINGS_SCHEMA = {
 
 	"ask.timeout": {
 		type: "number",
-		default: 30,
+		default: 0,
 		ui: {
 			tab: "interaction",
 			label: "Ask Timeout",

package/src/edit/index.ts

@@ -204,6 +204,7 @@ async function executeSinglePathEntries(
 	const contentTexts: string[] = [];
 	const diffTexts: string[] = [];
 	let firstChangedLine: number | undefined;
+	let errorCount = 0;
 
 	for (let i = 0; i < runs.length; i++) {
 		const isLast = i === runs.length - 1;
@@ -221,6 +222,7 @@ async function executeSinglePathEntries(
 		} catch (err) {
 			const errorText = err instanceof Error ? err.message : String(err);
 			contentTexts.push(`Error editing ${path}: ${errorText}`);
+			errorCount++;
 		}
 
 		if (!isLast && onUpdate) {
@@ -230,6 +232,7 @@ async function executeSinglePathEntries(
 					diff: diffTexts.join("\n"),
 					firstChangedLine,
 				},
+				...(errorCount > 0 ? { isError: true } : {}),
 			});
 		}
 	}
@@ -240,6 +243,11 @@ async function executeSinglePathEntries(
 			diff: diffTexts.join("\n"),
 			firstChangedLine,
 		},
+		// Any per-entry failure marks the aggregate result as an error so the
+		// renderer takes the error branch instead of falling through to the
+		// streaming-edit preview (which displays the *proposed* diff and looks
+		// indistinguishable from success).
+		...(errorCount > 0 ? { isError: true } : {}),
 	};
 }
 

package/src/edit/renderer.ts

@@ -148,6 +148,8 @@ export interface EditRenderContext {
 	editDiffPreview?: DiffResult | DiffError;
 	/** Multi-file streaming diff preview (edits spanning several files) */
 	perFileDiffPreview?: PerFileDiffPreview[];
+	/** Raw in-flight edit text shown while a computed diff preview is unavailable */
+	editStreamingFallback?: string;
 	/** Function to render diff text with syntax highlighting */
 	renderDiff?: (diffText: string, options?: { filePath?: string }) => string;
 }
@@ -272,7 +274,7 @@ function formatMultiFileStreamingDiff(previews: PerFileDiffPreview[], uiTheme: T
 	const parts: string[] = [];
 	for (const preview of previews) {
 		if (!preview.diff && !preview.error) continue;
-		const header = uiTheme.fg("dim", `\n\n\u2500\u2500 ${shortenPath(preview.path)} \u2500\u2500`);
+		const header = uiTheme.fg("dim", `\n\n── ${shortenPath(preview.path)} ──`);
 		if (preview.error) {
 			parts.push(`${header}\n${uiTheme.fg("error", replaceTabs(preview.error, preview.path))}`);
 			continue;
@@ -306,6 +308,9 @@ function getCallPreview(
 	if (args.newText || args.patch) {
 		return renderPlainTextPreview(args.newText ?? args.patch ?? "", uiTheme, rawPath);
 	}
+	if (renderContext?.editStreamingFallback) {
+		return renderContext.editStreamingFallback;
+	}
 	return "";
 }
 

package/src/edit/streaming.ts

@@ -13,14 +13,19 @@
  * the injected `editMode` rather than probing argument shape.
  */
 
+import { sanitizeText } from "@oh-my-pi/pi-natives";
 import {
+	ABORT_MARKER,
+	BEGIN_PATCH_MARKER,
 	computeHashlineDiff,
 	computeHashlineSectionDiff,
 	containsRecognizableHashlineOperations,
+	END_PATCH_MARKER,
 	type HashlineInputSection,
 	splitHashlineInputs,
 } from "../hashline";
 import type { Theme } from "../modes/theme/theme";
+import { replaceTabs, truncateToWidth } from "../tools/render-utils";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
@@ -61,6 +66,52 @@ export interface EditStreamingStrategy<Args = unknown> {
 	renderStreamingFallback(args: Args, uiTheme: Theme): string;
 }
 
+const STREAMING_FALLBACK_LINES = 12;
+const STREAMING_FALLBACK_WIDTH = 80;
+
+function isHashlineHeaderLine(line: string): boolean {
+	const trimmed = line.trimEnd();
+	return trimmed.startsWith("@") && trimmed.length > 1;
+}
+
+function isHashlineEnvelopeMarkerLine(line: string): boolean {
+	const trimmed = line.trimEnd();
+	return trimmed === BEGIN_PATCH_MARKER || trimmed === END_PATCH_MARKER || trimmed === ABORT_MARKER;
+}
+
+function trimHashlineStreamingSyntax(lines: string[]): string[] {
+	let index = lines.findIndex(line => line.trim().length > 0);
+	if (index === -1) return [];
+
+	if (lines[index].trimEnd() === BEGIN_PATCH_MARKER) {
+		index++;
+		while (index < lines.length && lines[index].trim().length === 0) index++;
+	}
+	if (index < lines.length && isHashlineHeaderLine(lines[index])) {
+		index++;
+	}
+
+	return lines.slice(index).filter(line => !isHashlineEnvelopeMarkerLine(line));
+}
+
+function renderHashlineInputFallback(input: string, uiTheme: Theme): string {
+	const lines = trimHashlineStreamingSyntax(sanitizeText(input).split("\n"));
+	if (!lines.some(line => line.trim().length > 0)) return "";
+
+	const displayLines = lines.slice(-STREAMING_FALLBACK_LINES);
+	const hidden = lines.length - displayLines.length;
+	let text = "\n\n";
+	text += displayLines
+		.map(line => uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), STREAMING_FALLBACK_WIDTH)))
+		.join("\n");
+	if (hidden > 0) {
+		text += uiTheme.fg("dim", `\n… (streaming +${hidden} lines)`);
+	} else {
+		text += uiTheme.fg("dim", "\n(streaming)");
+	}
+	return text;
+}
+
 // -----------------------------------------------------------------------------
 // Partial-JSON handling
 // -----------------------------------------------------------------------------
@@ -273,8 +324,8 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		}
 		return previews.length > 0 ? previews : null;
 	},
-	renderStreamingFallback() {
-		return "";
+	renderStreamingFallback(args, uiTheme) {
+		return typeof args.input === "string" ? renderHashlineInputFallback(args.input, uiTheme) : "";
 	},
 };
 

package/src/eval/js/context-manager.ts

@@ -32,9 +32,6 @@ interface VmHelperOptions {
 	reverse?: boolean;
 	unique?: boolean;
 	count?: boolean;
-	cwd?: string;
-	timeoutMs?: number;
-	timeout?: number;
 }
 
 interface VmContextState {
@@ -303,41 +300,6 @@ async function createHelpers(state: VmContextState) {
 			emitStatus(state, { op: "tree", path: root, entries: entryCount, preview: result.slice(0, 1000) });
 			return result;
 		},
-		run: async (
-			command: string,
-			options: VmHelperOptions = {},
-		): Promise<{ stdout: string; stderr: string; exit_code: number }> => {
-			const cwd = options.cwd ? resolvePath(state, options.cwd) : state.cwd;
-			const timeoutMs =
-				typeof options.timeoutMs === "number"
-					? options.timeoutMs
-					: typeof options.timeout === "number"
-						? options.timeout * 1000
-						: undefined;
-			const timeoutSignal =
-				typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0
-					? AbortSignal.timeout(timeoutMs)
-					: undefined;
-			const signal =
-				state.currentRun?.signal && timeoutSignal
-					? AbortSignal.any([state.currentRun.signal, timeoutSignal])
-					: (state.currentRun?.signal ?? timeoutSignal);
-			const child = Bun.spawn(["bash", "-lc", command], {
-				cwd,
-				env: getMergedEnv(state),
-				stdout: "pipe",
-				stderr: "pipe",
-				signal,
-			});
-			const [stdout, stderr, exit_code] = await Promise.all([
-				new Response(child.stdout as ReadableStream<Uint8Array>).text(),
-				new Response(child.stderr as ReadableStream<Uint8Array>).text(),
-				child.exited,
-			]);
-			const output = `${stdout}${stderr}`.slice(0, 500);
-			emitStatus(state, { op: "run", cmd: command.slice(0, 120), code: exit_code, output });
-			return { stdout, stderr, exit_code };
-		},
 		env: (key?: string, value?: string): string | Record<string, string> | undefined => {
 			if (!key) {
 				const env = Object.fromEntries(Object.entries(getMergedEnv(state)).sort(([a], [b]) => a.localeCompare(b)));
@@ -419,6 +381,7 @@ async function createVmState(
 		atob,
 		btoa,
 		Buffer,
+		Bun,
 		process: createProcessSubset(cwd),
 		require: buildRequire(cwd),
 		createRequire,

package/src/eval/js/prelude.txt

@@ -12,7 +12,6 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	const counter = (items, opts = {}) => callHelper("counter", items, toOptions(opts));
 	const diff = (a, b) => callHelper("diff", a, b);
 	const tree = (path = ".", opts = {}) => callHelper("tree", path, toOptions(opts));
-	const run = (cmd, opts = {}) => callHelper("run", cmd, toOptions(opts));
 	const env = (key, value) => callHelper("env", key, value);
 
 	const tool = new Proxy(
@@ -67,6 +66,5 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	globalThis.counter = counter;
 	globalThis.diff = diff;
 	globalThis.tree = tree;
-	globalThis.run = run;
 	globalThis.env = env;
 }

package/src/eval/py/executor.ts

@@ -39,6 +39,13 @@ export interface PythonExecutorOptions {
 	useSharedGateway?: boolean;
 	/** Session file path for accessing task outputs */
 	sessionFile?: string;
+	/**
+	 * Effective artifacts directory for the current session. Subagents share
+	 * the parent's directory, so this can differ from `sessionFile`'s sibling
+	 * dir. When present, exported to the kernel as `PI_ARTIFACTS_DIR` and
+	 * preferred over `PI_SESSION_FILE`-derived paths.
+	 */
+	artifactsDir?: string;
 	/** Artifact path/id for full output storage */
 	artifactPath?: string;
 	artifactId?: string;
@@ -102,6 +109,7 @@ let cleanupTimer: NodeJS.Timeout | null = null;
 interface KernelSessionExecutionOptions {
 	useSharedGateway?: boolean;
 	sessionFile?: string;
+	artifactsDir?: string;
 	signal?: AbortSignal;
 	deadlineMs?: number;
 	kernelOwnerId?: string;
@@ -123,6 +131,19 @@ function getExecutionDeadlineMs(options?: Pick<PythonExecutorOptions, "deadlineM
 	return Date.now() + options.timeoutMs;
 }
 
+/**
+ * Build the env block exposed to the Python kernel. Includes the session file
+ * (for things that need the raw session path) and the effective artifacts
+ * directory (preferred by the prelude when resolving output IDs, so subagents
+ * see the parent's flat dir instead of a non-existent sibling).
+ */
+function buildKernelEnv(options: { sessionFile?: string; artifactsDir?: string }): Record<string, string> | undefined {
+	const env: Record<string, string> = {};
+	if (options.sessionFile) env.PI_SESSION_FILE = options.sessionFile;
+	if (options.artifactsDir) env.PI_ARTIFACTS_DIR = options.artifactsDir;
+	return Object.keys(env).length > 0 ? env : undefined;
+}
+
 function getRemainingTimeoutMs(deadlineMs?: number): number | undefined {
 	if (deadlineMs === undefined) return undefined;
 	return deadlineMs - Date.now();
@@ -523,9 +544,7 @@ async function createKernelSession(
 	isRetry?: boolean,
 ): Promise<KernelSession> {
 	requireRemainingTimeoutMs(options.deadlineMs);
-	const env: Record<string, string> | undefined = options.sessionFile
-		? { PI_SESSION_FILE: options.sessionFile }
-		: undefined;
+	const env = buildKernelEnv(options);
 	const startOptions = buildKernelStartOptions(cwd, env, options);
 
 	let kernel: PythonKernel;
@@ -586,9 +605,7 @@ async function restartKernelSession(
 				});
 			}
 		}
-		const env: Record<string, string> | undefined = options.sessionFile
-			? { PI_SESSION_FILE: options.sessionFile }
-			: undefined;
+		const env = buildKernelEnv(options);
 		const startOptions = buildKernelStartOptions(cwd, env, options);
 		const kernel = await PythonKernel.start(startOptions);
 		session.kernel = kernel;
@@ -936,10 +953,9 @@ export async function executePython(code: string, options?: PythonExecutorOption
 		await ensureKernelAvailable(cwd);
 
 		const kernelMode = executionOptions.kernelMode ?? "session";
-		const sessionFile = executionOptions.sessionFile;
 
 		if (kernelMode === "per-call") {
-			const env: Record<string, string> | undefined = sessionFile ? { PI_SESSION_FILE: sessionFile } : undefined;
+			const env = buildKernelEnv(executionOptions);
 			requireRemainingTimeoutMs(deadlineMs);
 			const startOptions = buildKernelStartOptions(cwd, env, executionOptions);
 			const kernel = await PythonKernel.start(startOptions);

package/src/eval/py/index.ts

@@ -35,6 +35,7 @@ export default {
 			kernelMode,
 			useSharedGateway,
 			sessionFile: opts.sessionFile,
+			artifactsDir: opts.session.getArtifactsDir?.() ?? undefined,
 			kernelOwnerId: opts.kernelOwnerId,
 			reset: opts.reset,
 			artifactPath: opts.artifactPath,