@oh-my-pi/pi-coding-agent 16.3.10 → 16.3.12

package/src/eval/js/worker-core.ts

@@ -1,6 +1,15 @@
+import { isMainThread } from "node:worker_threads";
+import { postmortem } from "@oh-my-pi/pi-utils";
 import { ToolError } from "../../tools/tool-errors";
 import { JsRuntime, type RuntimeHooks } from "./shared/runtime";
-import type { RunErrorPayload, SessionSnapshot, ToolReply, Transport, WorkerInbound } from "./worker-protocol";
+import type {
+	RunErrorPayload,
+	SessionSnapshot,
+	ToolReply,
+	Transport,
+	WorkerInbound,
+	WorkerOutbound,
+} from "./worker-protocol";
 
 interface PendingTool {
 	runId: string;
@@ -10,9 +19,17 @@ interface PendingTool {
 
 interface ActiveRun {
 	runId: string;
+	filename: string;
 	pendingTools: Map<string, PendingTool>;
+	/** Rejections floated by this run's cell code, captured before its result was sent. */
+	floatingRejections: unknown[];
 }
 
+type RunResult = Extract<WorkerOutbound, { type: "result" }>;
+
+/** Finished-cell filenames retained for attributing rejections that surface after the run settled. */
+const RECENT_CELL_FILES_MAX = 256;
+
 function errorPayload(error: unknown): RunErrorPayload {
 	if (error instanceof Error) {
 		return {
@@ -34,15 +51,134 @@ function errorFromPayload(payload: RunErrorPayload): Error {
 	return error;
 }
 
+/**
+ * Fold rejections floated by cell code into the run result: an otherwise
+ * successful run fails with the first floating rejection (an unawaited promise
+ * failing is a cell failure, not a success with noise); the rest surface as
+ * output text so nothing is silently dropped.
+ */
+function foldFloatingRejections(active: ActiveRun, result: RunResult, hooks: RuntimeHooks): RunResult {
+	const rejections = active.floatingRejections;
+	if (rejections.length === 0) return result;
+	let folded = result;
+	let reported = rejections;
+	if (result.ok) {
+		const error = errorPayload(rejections[0]);
+		error.message = `Unhandled rejection (missing await?): ${error.message}`;
+		folded = { type: "result", runId: active.runId, ok: false, error };
+		reported = rejections.slice(1);
+	}
+	for (const reason of reported) {
+		const payload = errorPayload(reason);
+		hooks.onText(`[unhandled rejection] ${payload.name ?? "Error"}: ${payload.message}\n`);
+	}
+	return folded;
+}
+
 export class WorkerCore {
 	#transport: Transport;
 	#runtime: JsRuntime | null = null;
 	#runs = new Map<string, ActiveRun>();
+	#recentCellFiles = new Set<string>();
 	#unsubscribe: () => void;
+	#uninstallRejectionGuard: () => void;
 
 	constructor(transport: Transport) {
 		this.#transport = transport;
 		this.#unsubscribe = transport.onMessage(msg => this.#handle(msg));
+		this.#uninstallRejectionGuard = this.#installRejectionGuard();
+	}
+
+	/**
+	 * Capture unhandled rejections floated by eval-cell code (unawaited async
+	 * calls) so they fail the owning run instead of tearing down the worker or —
+	 * via the global postmortem handler — the whole session. On the main thread
+	 * (inline fallback) only cell-attributable rejections are consumed; in the
+	 * dedicated worker realm a rejection during a live run is cell activity even
+	 * without a usable stack, while anything else keeps its default fatality.
+	 */
+	#installRejectionGuard(): () => void {
+		if (isMainThread) {
+			return postmortem.interceptUnhandledRejections(reason => this.#consumeRejection(reason));
+		}
+		const onRejection = (reason: unknown): void => {
+			if (this.#consumeRejection(reason)) return;
+			// Not cell-attributable: restore default fatality. Rethrowing from a
+			// timer surfaces it as an uncaught exception, which reaches the host
+			// as a worker `error` event exactly like an unhandled rejection did
+			// before this listener existed.
+			setTimeout(() => {
+				throw reason;
+			}, 0);
+		};
+		process.on("unhandledRejection", onRejection);
+		return () => {
+			process.off("unhandledRejection", onRejection);
+		};
+	}
+
+	/**
+	 * Attribute an unhandled rejection to eval-cell code. Live runs are stashed
+	 * on the run (folded into its result after the settle drain); finished cells
+	 * downgrade to a host-side warn log. Returns false when the rejection is not
+	 * cell activity and must keep the default fatal path.
+	 */
+	#consumeRejection(reason: unknown): boolean {
+		const stack = reason instanceof Error && typeof reason.stack === "string" ? reason.stack : undefined;
+		if (stack) {
+			// The stack can name several cells (helper defined by an earlier cell,
+			// called from the live one); the outermost matching frame is the caller
+			// that owns the floating promise.
+			let owner: ActiveRun | undefined;
+			let ownerIndex = -1;
+			for (const run of this.#runs.values()) {
+				const index = stack.lastIndexOf(run.filename);
+				if (index > ownerIndex) {
+					ownerIndex = index;
+					owner = run;
+				}
+			}
+			if (owner) {
+				owner.floatingRejections.push(reason);
+				return true;
+			}
+			let recent: string | undefined;
+			let recentIndex = -1;
+			for (const filename of this.#recentCellFiles) {
+				const index = stack.lastIndexOf(filename);
+				if (index > recentIndex) {
+					recentIndex = index;
+					recent = filename;
+				}
+			}
+			if (recent) {
+				this.#transport.send({
+					type: "log",
+					level: "warn",
+					msg: "Unhandled rejection from a finished eval cell (missing await?)",
+					meta: { filename: recent, error: errorPayload(reason) },
+				});
+				return true;
+			}
+		}
+		if (!isMainThread && this.#runs.size > 0) {
+			// Dedicated eval worker: during a live run, a rejection without a cell
+			// frame (e.g. `Promise.reject("msg")` or a library-created reason) is
+			// still cell activity — nothing else runs user code in this realm.
+			if (this.#runs.size === 1) {
+				const only = this.#runs.values().next().value;
+				only?.floatingRejections.push(reason);
+				return true;
+			}
+			this.#transport.send({
+				type: "log",
+				level: "warn",
+				msg: "Unhandled rejection during concurrent eval runs; cannot attribute to a cell",
+				meta: { error: errorPayload(reason) },
+			});
+			return true;
+		}
+		return false;
 	}
 
 	#handle(msg: WorkerInbound): void {
@@ -77,23 +213,42 @@ export class WorkerCore {
 	}
 
 	async #runOne(runId: string, code: string, filename: string, snapshot: SessionSnapshot): Promise<void> {
-		const runtime = this.#ensureRuntime(snapshot);
-		runtime.setCwd(snapshot.cwd);
-		const active: ActiveRun = { runId, pendingTools: new Map() };
+		const active: ActiveRun = { runId, filename, pendingTools: new Map(), floatingRejections: [] };
 		this.#runs.set(runId, active);
 		const hooks: RuntimeHooks = {
 			onText: chunk => this.#transport.send({ type: "text", runId, chunk }),
 			onDisplay: output => this.#transport.send({ type: "display", runId, output }),
 			callTool: (name, args) => this.#callTool(active, name, args),
 		};
+		let result: RunResult;
 		try {
+			const runtime = this.#ensureRuntime(snapshot);
+			runtime.setCwd(snapshot.cwd);
 			const value = await runtime.run(code, filename, hooks, { runId, cwd: snapshot.cwd });
 			runtime.displayValue(value, hooks);
-			this.#transport.send({ type: "result", runId, ok: true });
+			result = { type: "result", runId, ok: true };
 		} catch (error) {
-			this.#transport.send({ type: "result", runId, ok: false, error: errorPayload(error) });
+			result = { type: "result", runId, ok: false, error: errorPayload(error) };
+		}
+		try {
+			// One event-loop turn so rejections the cell already floated surface
+			// while this run can still own them (rejection callbacks run before
+			// timers fire).
+			await Bun.sleep(0);
+			result = foldFloatingRejections(active, result, hooks);
 		} finally {
 			this.#runs.delete(runId);
+			this.#rememberCellFile(filename);
+			this.#transport.send(result);
+		}
+	}
+
+	#rememberCellFile(filename: string): void {
+		this.#recentCellFiles.delete(filename);
+		this.#recentCellFiles.add(filename);
+		if (this.#recentCellFiles.size > RECENT_CELL_FILES_MAX) {
+			const oldest = this.#recentCellFiles.values().next().value;
+			if (oldest !== undefined) this.#recentCellFiles.delete(oldest);
 		}
 	}
 
@@ -127,6 +282,7 @@ export class WorkerCore {
 		this.#runtime?.dispose?.();
 		this.#runtime = null;
 		this.#transport.send({ type: "closed" });
+		this.#uninstallRejectionGuard();
 		this.#unsubscribe();
 		this.#transport.close();
 	}
@@ -141,6 +297,7 @@ export class WorkerCore {
 		this.#runs.clear();
 		this.#runtime?.dispose?.();
 		this.#runtime = null;
+		this.#uninstallRejectionGuard();
 		this.#unsubscribe();
 		try {
 			this.#transport.close();

package/src/exec/bash-executor.ts

@@ -14,6 +14,7 @@ import { buildNonInteractiveEnv } from "./non-interactive-env";
 
 export interface BashExecutorOptions {
 	cwd?: string;
+	/** Milliseconds before aborting the command; 0 disables the executor deadline. */
 	timeout?: number;
 	onChunk?: (chunk: string) => void;
 	chunkThrottleMs?: number;
@@ -296,11 +297,15 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 
 	let timeoutTimer: NodeJS.Timeout | undefined;
 	const timeoutDeferred = Promise.withResolvers<"timeout">();
-	const baseTimeoutMs = Math.max(1_000, options?.timeout ?? 300_000);
-	timeoutTimer = setTimeout(() => {
-		abortCurrentExecution();
-		timeoutDeferred.resolve("timeout");
-	}, baseTimeoutMs);
+	const requestedTimeoutMs = options?.timeout;
+	const deadlineTimeoutMs = requestedTimeoutMs === 0 ? undefined : Math.max(1_000, requestedTimeoutMs ?? 300_000);
+	const nativeTimeoutMs = requestedTimeoutMs !== undefined && requestedTimeoutMs > 0 ? requestedTimeoutMs : undefined;
+	if (deadlineTimeoutMs !== undefined) {
+		timeoutTimer = setTimeout(() => {
+			abortCurrentExecution();
+			timeoutDeferred.resolve("timeout");
+		}, deadlineTimeoutMs);
+	}
 
 	let resetSession = false;
 
@@ -311,7 +316,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 						command: finalCommand,
 						cwd: commandCwd,
 						env: commandEnv,
-						timeoutMs: options?.timeout,
+						timeoutMs: nativeTimeoutMs,
 						signal: runAbortController.signal,
 					},
 					(err, chunk) => {
@@ -328,7 +333,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 						sessionEnv: shellEnv,
 						snapshotPath: snapshotPath ?? undefined,
 						minimizer,
-						timeoutMs: options?.timeout,
+						timeoutMs: nativeTimeoutMs,
 						signal: runAbortController.signal,
 					},
 					(err, chunk) => {
@@ -359,8 +364,8 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 				exitCode: undefined,
 				cancelled: true,
 				...(await sink.dump(
-					winner.kind === "timeout"
-						? `Command timed out after ${Math.round(baseTimeoutMs / 1000)} seconds`
+					winner.kind === "timeout" && deadlineTimeoutMs !== undefined
+						? `Command timed out after ${Math.round(deadlineTimeoutMs / 1000)} seconds`
 						: "Command cancelled",
 				)),
 			};

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

@@ -1059,7 +1059,8 @@ async function collectExtensionModules(entryRealPath: string): Promise<Map<strin
 				let resolved: string | null = null;
 				let nextFollowsBareDependencies = followBareDependencies;
 				if (specifier.startsWith(".")) {
-					resolved = await realpathOrSelf(Bun.resolveSync(specifier, dir));
+					const candidate = Bun.resolveSync(specifier, dir);
+					resolved = hasSourceModuleExtension(candidate) ? await realpathOrSelf(candidate) : null;
 				} else if (specifier.startsWith("#")) {
 					resolved = await resolvePackageImportSpecifier(specifier, file);
 				} else if (
@@ -1078,7 +1079,10 @@ async function collectExtensionModules(entryRealPath: string): Promise<Map<strin
 						dependencyExtension === ".cjs" ||
 						dependencyExtension === ".cts" ||
 						((dependencyExtension === ".js" || dependencyExtension === ".jsx") && manifest?.type !== "module");
-					resolved = dependencyEntry && !isCommonJsEntry ? await realpathOrSelf(dependencyEntry) : null;
+					resolved =
+						dependencyEntry && hasSourceModuleExtension(dependencyEntry) && !isCommonJsEntry
+							? await realpathOrSelf(dependencyEntry)
+							: null;
 					nextFollowsBareDependencies = false;
 				}
 				if (resolved && !modules.has(resolved)) {

package/src/extensibility/plugins/marketplace/fetcher.ts

@@ -196,19 +196,20 @@ export function parseMarketplaceCatalog(content: string, filePath: string): Mark
  * Catalog paths tried in priority order: omp-namespaced override first, then
  * the Claude Code-compatible fallback so existing marketplaces keep loading.
  */
-const CATALOG_RELATIVE_PATHS: readonly string[] = [
-	path.join(".omp-plugin", "marketplace.json"),
-	path.join(".claude-plugin", "marketplace.json"),
-];
+const CATALOG_RELATIVE_PATHS: readonly string[] = [".omp-plugin/marketplace.json", ".claude-plugin/marketplace.json"];
 
-async function readMarketplaceCatalog(root: string): Promise<{ catalogPath: string; content: string }> {
+async function readMarketplaceCatalog(
+	root: string,
+	options: { relativeDisplayPaths?: boolean } = {},
+): Promise<{ catalogPath: string; displayPath: string; content: string }> {
 	const tried: string[] = [];
 	for (const rel of CATALOG_RELATIVE_PATHS) {
-		const catalogPath = path.join(root, rel);
-		tried.push(catalogPath);
+		const catalogPath = path.join(root, ...rel.split("/"));
+		const displayPath = options.relativeDisplayPaths ? rel : catalogPath;
+		tried.push(displayPath);
 		try {
 			const content = await Bun.file(catalogPath).text();
-			return { catalogPath, content };
+			return { catalogPath, displayPath, content };
 		} catch (err) {
 			if (isEnoent(err)) continue;
 			throw err;
@@ -252,11 +253,11 @@ export async function fetchMarketplace(source: string, cacheDir: string): Promis
 
 	if (type === "github") {
 		const url = `https://github.com/${source}.git`;
-		return cloneAndReadCatalog(url, cacheDir);
+		return cloneAndReadCatalog(url, source, cacheDir);
 	}
 
 	if (type === "git") {
-		return cloneAndReadCatalog(source, cacheDir);
+		return cloneAndReadCatalog(source, source, cacheDir);
 	}
 
 	// type === "url"
@@ -284,7 +285,7 @@ export async function fetchMarketplace(source: string, cacheDir: string): Promis
  * responsible for promoting the clone to its final cache location via
  * `promoteCloneToCache` after any duplicate/drift checks pass.
  */
-async function cloneAndReadCatalog(url: string, cacheDir: string): Promise<FetchResult> {
+async function cloneAndReadCatalog(url: string, source: string, cacheDir: string): Promise<FetchResult> {
 	const tmpDir = path.join(cacheDir, `.tmp-clone-${Date.now()}`);
 	await fs.mkdir(cacheDir, { recursive: true });
 
@@ -292,12 +293,12 @@ async function cloneAndReadCatalog(url: string, cacheDir: string): Promise<Fetch
 	await git.clone(url, tmpDir);
 
 	try {
-		const { catalogPath, content } = await readMarketplaceCatalog(tmpDir);
-		const catalog = parseMarketplaceCatalog(content, catalogPath);
+		const { displayPath, content } = await readMarketplaceCatalog(tmpDir, { relativeDisplayPaths: true });
+		const catalog = parseMarketplaceCatalog(content, displayPath);
 		return { catalog, clonePath: tmpDir };
 	} catch (err) {
 		await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
-		throw new Error(`Cloned repository ${url}: ${(err as Error).message}`, { cause: err });
+		throw new Error(`Cloned repository ${url}: ${(err as Error).message} (source: ${source})`, { cause: err });
 	}
 }
 

package/src/extensibility/shared-events.ts

@@ -33,7 +33,7 @@ export interface SessionStartEvent {
 export interface SessionBeforeSwitchEvent {
 	type: "session_before_switch";
 	/** Reason for the switch */
-	reason: "new" | "resume" | "fork";
+	reason: "new" | "resume" | "fork" | "handoff";
 	/** Session file we're switching to (only for "resume") */
 	targetSessionFile?: string;
 }
@@ -42,7 +42,7 @@ export interface SessionBeforeSwitchEvent {
 export interface SessionSwitchEvent {
 	type: "session_switch";
 	/** Reason for the switch */
-	reason: "new" | "resume" | "fork";
+	reason: "new" | "resume" | "fork" | "handoff";
 	/** Session file we came from */
 	previousSessionFile: string | undefined;
 }

package/src/internal-urls/__tests__/agent-protocol-nested.test.ts

@@ -0,0 +1,68 @@
+import { afterAll, afterEach, expect, it } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { TempDir } from "@oh-my-pi/pi-utils";
+import { AgentRegistry } from "../../registry/agent-registry";
+import type { AgentSession } from "../../session/agent-session";
+import { ArtifactManager } from "../../session/artifacts";
+import { AgentProtocolHandler } from "../agent-protocol";
+import { resetRegisteredArtifactDirsForTests } from "../registry-helpers";
+
+const tempDir = TempDir.createSync("omp-nested-agent-repro-");
+afterEach(() => {
+	AgentRegistry.resetGlobalForTests();
+	resetRegisteredArtifactDirsForTests();
+});
+afterAll(() => {
+	tempDir.removeSync();
+});
+
+it("agent:// resolves a depth-2 subagent's .md output while its session is live and artifact-manager-adopted", async () => {
+	const root = tempDir.path();
+	const rootSessionFile = path.join(root, "session.jsonl");
+	const rootArtifactsDir = rootSessionFile.slice(0, -6);
+	await fs.mkdir(rootArtifactsDir, { recursive: true });
+	// Every subagent adopts the root ArtifactManager and reports its dir.
+	const sharedArtifactManager = new ArtifactManager(rootArtifactsDir);
+
+	// A depth-1 subagent's OWN children are written under its own
+	// sessionFile.slice(0, -6) (task/index.ts), i.e. one level deeper.
+	const midSessionFile = path.join(rootArtifactsDir, "CodexDeepDive.jsonl");
+	const midOwnArtifactsDir = midSessionFile.slice(0, -6);
+	await fs.mkdir(midOwnArtifactsDir, { recursive: true });
+
+	const grandchildId = "CodexDeepDive.GraphStore";
+	const grandchildSessionFile = path.join(midOwnArtifactsDir, `${grandchildId}.jsonl`);
+	await fs.writeFile(path.join(midOwnArtifactsDir, `${grandchildId}.md`), "full report content");
+
+	const fakeSession = {
+		sessionManager: { getArtifactsDir: () => sharedArtifactManager.dir },
+	} as unknown as AgentSession;
+	const registry = AgentRegistry.global();
+	registry.register({
+		id: "Main",
+		displayName: "main",
+		kind: "main",
+		session: fakeSession,
+		sessionFile: rootSessionFile,
+	});
+	registry.register({
+		id: "CodexDeepDive",
+		displayName: "sub",
+		kind: "sub",
+		parentId: "Main",
+		session: fakeSession,
+		sessionFile: midSessionFile,
+	});
+	registry.register({
+		id: grandchildId,
+		displayName: "sub",
+		kind: "sub",
+		parentId: "CodexDeepDive",
+		session: fakeSession,
+		sessionFile: grandchildSessionFile,
+	});
+
+	const resource = await new AgentProtocolHandler().resolve(new URL(`agent://${grandchildId}`) as never);
+	expect(resource.content).toBe("full report content");
+});