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

package/src/session/yield-queue.ts

@@ -1,4 +1,4 @@
-import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { type AgentMessage, ASIDE_MESSAGE_COMMIT, ASIDE_MESSAGE_DISCARD } from "@oh-my-pi/pi-agent-core";
 import { logger } from "@oh-my-pi/pi-utils";
 
 export interface YieldDispatcher<P> {
@@ -25,6 +25,17 @@ interface StoredDispatcher {
 	skipIdleFlush?: boolean;
 }
 
+interface StoredEntry {
+	value: unknown;
+	resolve?: () => void;
+	reject?: (error: Error) => void;
+}
+
+interface BuiltMessage {
+	message: AgentMessage;
+	entries: StoredEntry[];
+}
+
 function formatError(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -32,7 +43,7 @@ function formatError(error: unknown): string {
 export class YieldQueue {
 	readonly #options: YieldQueueOptions;
 	readonly #dispatchers = new Map<string, StoredDispatcher>();
-	readonly #entries = new Map<string, unknown[]>();
+	readonly #entries = new Map<string, StoredEntry[]>();
 	#idleFlushPending = false;
 
 	constructor(options: YieldQueueOptions) {
@@ -49,14 +60,27 @@ export class YieldQueue {
 		return () => {
 			if (this.#dispatchers.get(kind) !== stored) return;
 			this.#dispatchers.delete(kind);
+			this.#rejectEntries(this.#entries.get(kind) ?? [], new Error(`Yield queue dispatcher removed: ${kind}`));
 			this.#entries.delete(kind);
 		};
 	}
 
 	enqueue<P>(kind: string, entry: P): void {
+		this.#enqueue(kind, { value: entry });
+	}
+
+	enqueueWithReceipt<P>(kind: string, entry: P): Promise<void> {
+		const { promise, resolve, reject } = Promise.withResolvers<void>();
+		if (!this.#enqueue(kind, { value: entry, resolve, reject })) {
+			reject(new Error(`Yield queue entry ignored for unregistered kind: ${kind}`));
+		}
+		return promise;
+	}
+
+	#enqueue(kind: string, entry: StoredEntry): boolean {
 		if (!this.#dispatchers.has(kind)) {
 			logger.warn("Yield queue entry ignored for unregistered kind", { kind });
-			return;
+			return false;
 		}
 		let entries = this.#entries.get(kind);
 		if (!entries) {
@@ -67,6 +91,7 @@ export class YieldQueue {
 		if (!this.#options.isStreaming() && !this.#dispatchers.get(kind)!.skipIdleFlush) {
 			this.#scheduleIdleFlush();
 		}
+		return true;
 	}
 
 	has(kind?: string): boolean {
@@ -77,30 +102,55 @@ export class YieldQueue {
 		return false;
 	}
 
+	/** Arrange an idle flush for entries queued near the end of a streaming run. */
+	requestIdleFlush(): void {
+		for (const [kind, dispatcher] of this.#dispatchers) {
+			if (!dispatcher.skipIdleFlush && this.has(kind)) {
+				this.#scheduleIdleFlush();
+				return;
+			}
+		}
+	}
+
 	async flush(mode: YieldFlushMode): Promise<void> {
 		if (mode === "idle") {
 			this.#idleFlushPending = false;
 		}
-		const idleMessages: AgentMessage[] = [];
+		const idleMessages: BuiltMessage[] = [];
 		for (const [kind, dispatcher] of this.#dispatchers) {
+			if (mode === "idle" && dispatcher.skipIdleFlush) continue;
 			const entries = this.#drain(kind);
 			if (entries.length === 0) continue;
-			const message = this.#build(kind, dispatcher, entries);
-			if (!message) continue;
+			const built = this.#build(kind, dispatcher, entries);
+			if (!built) continue;
 			if (mode === "streaming") {
 				try {
-					this.#options.injectStreaming?.(message);
+					if (!this.#options.injectStreaming) throw new Error("Streaming injection is unavailable");
+					this.#options.injectStreaming(built.message);
+					this.#resolveEntries(built.entries);
 				} catch (error) {
+					const dispatchError = error instanceof Error ? error : new Error(String(error));
+					this.#rejectEntries(built.entries, dispatchError);
 					logger.warn("Yield queue streaming dispatch failed", { kind, error: formatError(error) });
 				}
 			} else {
-				idleMessages.push(message);
+				idleMessages.push(built);
 			}
 		}
 		if (mode === "idle" && idleMessages.length > 0) {
+			for (const item of idleMessages) this.#attachEntrySettlement(item);
 			try {
-				await this.#options.injectIdle(idleMessages);
+				await this.#options.injectIdle(idleMessages.map(item => item.message));
+				for (const item of idleMessages) {
+					(item.message as AgentMessage & { [ASIDE_MESSAGE_COMMIT]?: () => void })[ASIDE_MESSAGE_COMMIT]?.();
+				}
 			} catch (error) {
+				const dispatchError = error instanceof Error ? error : new Error(String(error));
+				for (const item of idleMessages) {
+					(item.message as AgentMessage & { [ASIDE_MESSAGE_DISCARD]?: (error: Error) => void })[
+						ASIDE_MESSAGE_DISCARD
+					]?.(dispatchError);
+				}
 				logger.warn("Yield queue idle dispatch failed", { error: formatError(error) });
 			}
 		}
@@ -119,7 +169,12 @@ export class YieldQueue {
 		for (const [kind, dispatcher] of this.#dispatchers) {
 			const entries = this.#drain(kind);
 			if (entries.length === 0) continue;
-			thunks.push(() => this.#build(kind, dispatcher, entries));
+			thunks.push(() => {
+				const built = this.#build(kind, dispatcher, entries);
+				if (!built) return null;
+				this.#attachEntrySettlement(built);
+				return built.message;
+			});
 		}
 		return thunks;
 	}
@@ -127,14 +182,22 @@ export class YieldQueue {
 	/** Drop queued entries. With `kind`, drop only that kind's entries (leaving
 	 *  any pending idle-flush for other kinds intact); otherwise drop everything. */
 	clear(kind?: string): void {
+		const error = new Error("Yield queue entry cleared before dispatch");
 		if (kind !== undefined) {
+			this.#rejectEntries(this.#entries.get(kind) ?? [], error);
 			this.#entries.delete(kind);
 			return;
 		}
+		for (const entries of this.#entries.values()) this.#rejectEntries(entries, error);
 		this.#entries.clear();
 		this.#idleFlushPending = false;
 	}
 
+	/** Clear a scheduled-flush latch when its host task is cancelled before running. */
+	cancelIdleFlushScheduling(): void {
+		this.#idleFlushPending = false;
+	}
+
 	#scheduleIdleFlush(): void {
 		if (this.#idleFlushPending) return;
 		this.#idleFlushPending = true;
@@ -150,34 +213,76 @@ export class YieldQueue {
 		}
 	}
 
-	#drain(kind: string): unknown[] {
+	#drain(kind: string): StoredEntry[] {
 		const entries = this.#entries.get(kind);
 		if (!entries || entries.length === 0) return [];
 		this.#entries.delete(kind);
 		return entries;
 	}
 
-	#build(kind: string, dispatcher: StoredDispatcher, entries: unknown[]): AgentMessage | null {
-		const survivors: unknown[] = [];
+	#build(kind: string, dispatcher: StoredDispatcher, entries: StoredEntry[]): BuiltMessage | null {
+		const survivors: StoredEntry[] = [];
 		for (const entry of entries) {
 			if (dispatcher.isStale) {
 				let stale: boolean;
 				try {
-					stale = dispatcher.isStale(entry);
+					stale = dispatcher.isStale(entry.value);
 				} catch (error) {
+					const staleError = error instanceof Error ? error : new Error(String(error));
+					entry.reject?.(staleError);
 					logger.warn("Yield queue stale check failed", { kind, error: formatError(error) });
 					continue;
 				}
-				if (stale) continue;
+				if (stale) {
+					entry.reject?.(new Error(`Yield queue entry became stale: ${kind}`));
+					continue;
+				}
 			}
 			survivors.push(entry);
 		}
 		if (survivors.length === 0) return null;
 		try {
-			return dispatcher.build(survivors);
+			const message = dispatcher.build(survivors.map(entry => entry.value));
+			if (!message) {
+				this.#rejectEntries(survivors, new Error(`Yield queue dispatcher skipped entry: ${kind}`));
+				return null;
+			}
+			return { message, entries: survivors };
 		} catch (error) {
+			const buildError = error instanceof Error ? error : new Error(String(error));
+			this.#rejectEntries(survivors, buildError);
 			logger.warn("Yield queue build failed", { kind, error: formatError(error) });
 			return null;
 		}
 	}
+
+	#attachEntrySettlement(built: BuiltMessage): void {
+		let settled = false;
+		Object.defineProperties(built.message, {
+			[ASIDE_MESSAGE_COMMIT]: {
+				configurable: true,
+				value: () => {
+					if (settled) return;
+					settled = true;
+					this.#resolveEntries(built.entries);
+				},
+			},
+			[ASIDE_MESSAGE_DISCARD]: {
+				configurable: true,
+				value: (error: Error) => {
+					if (settled) return;
+					settled = true;
+					this.#rejectEntries(built.entries, error);
+				},
+			},
+		});
+	}
+
+	#resolveEntries(entries: StoredEntry[]): void {
+		for (const entry of entries) entry.resolve?.();
+	}
+
+	#rejectEntries(entries: StoredEntry[], error: Error): void {
+		for (const entry of entries) entry.reject?.(error);
+	}
 }

package/src/slash-commands/builtin-registry.ts

@@ -1719,6 +1719,16 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			await runtime.ctx.handleFreshCommand();
 		},
 	},
+	{
+		name: "reset",
+		description: "Reset the conversation context in place, keeping the session",
+		getTuiAutocompleteDescription: runtime =>
+			runtime.ctx.session.isStreaming ? "Reset: unavailable while streaming" : "Reset: drop context, keep session",
+		handleTui: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleResetContextCommand();
+		},
+	},
 	{
 		name: "drop",
 		description: "Delete the current session and start a new one",

package/src/tools/browser/cmux/cmux-tab.ts

@@ -254,6 +254,65 @@ export interface RunCmuxCodeOptions {
 	snapshot: SessionSnapshot;
 }
 
+interface ActiveCmuxRun {
+	filename: string;
+	floatingRejections: unknown[];
+}
+
+const RECENT_CMUX_RUN_FILES_MAX = 256;
+const activeCmuxRuns = new Map<string, ActiveCmuxRun>();
+const recentCmuxRunFiles = new Set<string>();
+
+function consumeCmuxRunRejection(reason: unknown): boolean {
+	// cmux runs guest JS in the shared main-process realm (TTS/STT/MCP and other
+	// subsystems live here too), so — like the eval inline fallback — only a
+	// guest-file stack frame can safely attribute a rejection. A stackless or
+	// non-run-stack reason is indistinguishable from a subsystem failure and
+	// keeps the default fatal path; worker isolation is the long-term fix.
+	const stack = reason instanceof Error && typeof reason.stack === "string" ? reason.stack : undefined;
+	if (!stack) return false;
+
+	let owner: ActiveCmuxRun | undefined;
+	let ownerIndex = -1;
+	for (const run of activeCmuxRuns.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 recentCmuxRunFiles) {
+		const index = stack.lastIndexOf(filename);
+		if (index > recentIndex) {
+			recentIndex = index;
+			recent = filename;
+		}
+	}
+	if (!recent) return false;
+	logger.warn("Unhandled rejection from a finished cmux browser run (missing await?)", {
+		filename: recent,
+		error: reason,
+	});
+	return true;
+}
+
+function rememberCmuxRunFile(filename: string): void {
+	recentCmuxRunFiles.delete(filename);
+	recentCmuxRunFiles.add(filename);
+	if (recentCmuxRunFiles.size <= RECENT_CMUX_RUN_FILES_MAX) return;
+	const oldest = recentCmuxRunFiles.values().next().value;
+	if (oldest !== undefined) recentCmuxRunFiles.delete(oldest);
+}
+
+postmortem.interceptUnhandledRejections(consumeCmuxRunRejection);
+
 export class CmuxTab {
 	readonly #client: CmuxSocketClient;
 	readonly #surfaceId: string;
@@ -1312,6 +1371,9 @@ export async function runCmuxCode(tab: CmuxTab, opts: RunCmuxCodeOptions): Promi
 	const output = new RunOutput();
 	const screenshots: ScreenshotResult[] = [];
 	const runId = crypto.randomUUID();
+	const filename = `cmux-run-${runId}.js`;
+	const activeRun: ActiveCmuxRun = { filename, floatingRejections: [] };
+	activeCmuxRuns.set(filename, activeRun);
 	tab.setRunContext({ session: opts.snapshot, output, screenshots, signal, timeoutMs: opts.timeoutMs });
 
 	const { promise: cancelRejection, reject } = Promise.withResolvers<never>();
@@ -1378,14 +1440,40 @@ export async function runCmuxCode(tab: CmuxTab, opts: RunCmuxCodeOptions): Promi
 		};
 		// Like the inline worker fallback, cmux runs user JS in-process: awaited cmux/tool calls
 		// observe this abort signal, but a synchronous infinite loop cannot be interrupted here.
-		const returnValue = await Promise.race([
-			runtime.run(opts.code, `cmux-run-${runId}.js`, hooks, { runId, cwd: opts.snapshot.cwd }),
-			cancelRejection,
-		]);
+		let returnValue: unknown;
+		let runError: unknown;
+		let runFailed = false;
+		try {
+			returnValue = await Promise.race([
+				runtime.run(opts.code, filename, hooks, { runId, cwd: opts.snapshot.cwd }),
+				cancelRejection,
+			]);
+		} catch (error) {
+			runFailed = true;
+			runError = error;
+		}
+		// Let rejection callbacks run while this run can still own guest-created promises.
+		await Bun.sleep(0);
+		if (runFailed) {
+			for (const reason of activeRun.floatingRejections) {
+				logger.warn("Unhandled rejection accompanied a failed cmux browser run", { filename, error: reason });
+			}
+			throw runError;
+		}
+		if (activeRun.floatingRejections.length > 0) {
+			const messages = activeRun.floatingRejections.map(reason =>
+				reason instanceof Error ? reason.message : String(reason),
+			);
+			throw new ToolError(`Unhandled rejection (missing await?): ${messages.join("\n[unhandled rejection] ")}`, {
+				rejections: activeRun.floatingRejections,
+			});
+		}
 		return { displays: output.finish(), returnValue: cloneSafe(returnValue), screenshots };
 	} finally {
 		signal.removeEventListener("abort", onAbort);
 		runAc.abort(postmortem.markExpectedCleanupError(new ToolAbortError("Browser run ended")));
+		activeCmuxRuns.delete(filename);
+		rememberCmuxRunFile(filename);
 		tab.clearRunContext();
 	}
 }

package/src/tools/hub/launch.ts

@@ -10,7 +10,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import { daemonClientForProject } from "../../launch/client";
+import { type DaemonBrokerClient, DaemonBrokerRejectedError, daemonClientForProject } from "../../launch/client";
 import type { DaemonOperation, DaemonRpcResult, DaemonSnapshot, DaemonSpec, DaemonState } from "../../launch/protocol";
 import { renderTerminalOutputIsolated } from "../../launch/terminal-output-worker-client";
 import type { Theme, ThemeColor } from "../../modes/theme/theme";
@@ -35,6 +35,81 @@ import {
 import { styleTerminalRow } from "../terminal-output";
 import { ToolError } from "../tool-errors";
 
+interface CompletionRegistration {
+	inFlight: number;
+	retained: boolean;
+	active: boolean;
+	cleanup: (preservePending?: boolean) => void;
+}
+
+interface CompletionLease {
+	retain: () => void;
+	reject: (preservePending?: boolean) => void;
+	hasConcurrentRequest: () => boolean;
+}
+
+const completionRegistrations = new WeakMap<
+	ToolSession,
+	Map<DaemonBrokerClient, Map<string, CompletionRegistration>>
+>();
+
+function registerCompletionSink(
+	session: ToolSession,
+	client: DaemonBrokerClient,
+	owner: string,
+): CompletionLease | undefined {
+	if (!session.queueLaunchCompletion) return undefined;
+	let clients = completionRegistrations.get(session);
+	if (!clients) {
+		clients = new Map();
+		completionRegistrations.set(session, clients);
+	}
+	let owners = clients.get(client);
+	if (!owners) {
+		owners = new Map();
+		clients.set(client, owners);
+	}
+	let registration = owners.get(owner);
+	if (!registration) {
+		const unregister = client.onCompletion(owner, notification => {
+			if (session.isDisposed?.()) throw new Error("Session disposed before launch completion delivery");
+			const delivery = session.queueLaunchCompletion?.(notification);
+			if (!delivery) throw new Error("Session cannot accept launch completion delivery");
+			return delivery;
+		});
+		let unregisterDispose: (() => void) | void;
+		let unregisterSessionChange: (() => void) | void;
+		const cleanup = (preservePending = false): void => {
+			if (!registration?.active) return;
+			registration.active = false;
+			unregister({ preservePending });
+			unregisterDispose?.();
+			unregisterSessionChange?.();
+			owners.delete(owner);
+			if (owners.size === 0) clients.delete(client);
+			if (clients.size === 0) completionRegistrations.delete(session);
+		};
+		registration = { inFlight: 0, retained: false, active: true, cleanup };
+		owners.set(owner, registration);
+		unregisterDispose = session.registerDisposeCallback?.(() => cleanup(true));
+		unregisterSessionChange = session.registerSessionChangeCallback?.(() => cleanup(true));
+	}
+	registration.inFlight++;
+	let settled = false;
+	const settle = (retain: boolean, preservePending = false): void => {
+		if (settled || !registration.active) return;
+		settled = true;
+		registration.inFlight--;
+		if (retain) registration.retained = true;
+		if (!registration.retained && registration.inFlight === 0) registration.cleanup(preservePending);
+	};
+	return {
+		retain: () => settle(true),
+		hasConcurrentRequest: () => registration.active && registration.inFlight > 1,
+		reject: preservePending => settle(false, preservePending),
+	};
+}
+
 /** Broker-facing launch parameters; the hub adapts its `ps` op to `list` before calling in. */
 export interface LaunchParams {
 	op: "start" | "list" | "logs" | "wait" | "send" | "stop" | "restart" | "describe";
@@ -321,11 +396,52 @@ export async function executeLaunch(
 	signal?: AbortSignal,
 ): Promise<AgentToolResult<LaunchToolDetails>> {
 	const client = await daemonClientForProject(session.cwd);
-	const result = await client.request(operationFor(params, session), signal);
-	return {
-		content: [{ type: "text", text: replaceTabs(toolContent(result, params)) }],
-		details: await toolDetails(result, params),
-	};
+	const operation = operationFor(params, session);
+	const owner = operation.op === "start" ? operation.owner : undefined;
+	const resumedOwner = params.op !== "start" ? (session.getSessionId?.() ?? undefined) : undefined;
+	const completionLease = owner
+		? registerCompletionSink(session, client, owner)
+		: resumedOwner
+			? registerCompletionSink(session, client, resumedOwner)
+			: undefined;
+	try {
+		const result = await client.request(operation, signal);
+		const sessionOwner = session.getSessionId?.();
+		let resumedDaemonFound = false;
+		const daemons =
+			result.op === "list" ? result.daemons : "daemon" in result && result.daemon ? [result.daemon] : [];
+		for (const daemon of daemons) {
+			if (!daemon.owner || daemon.owner !== sessionOwner || TERMINAL_STATES[daemon.state]) continue;
+			resumedDaemonFound = true;
+			if (daemon.owner !== resumedOwner) registerCompletionSink(session, client, daemon.owner)?.retain();
+		}
+		if (params.op === "list" && resumedOwner && !resumedDaemonFound) completionLease?.reject(true);
+		else completionLease?.retain();
+		return {
+			content: [{ type: "text", text: replaceTabs(toolContent(result, params)) }],
+			details: await toolDetails(result, params),
+		};
+	} catch (error) {
+		if (error instanceof DaemonBrokerRejectedError && owner) {
+			if (completionLease?.hasConcurrentRequest()) {
+				completionLease.reject();
+			} else {
+				try {
+					const listed = await client.request({ op: "list" }, signal);
+					const ownerStillRunning =
+						listed.op === "list" &&
+						listed.daemons.some(daemon => daemon.owner === owner && !TERMINAL_STATES[daemon.state]);
+					if (ownerStillRunning) completionLease?.retain();
+					else completionLease?.reject(true);
+				} catch {
+					completionLease?.retain();
+				}
+			}
+		} else {
+			completionLease?.retain();
+		}
+		throw error;
+	}
 }
 
 // =============================================================================

package/src/tools/index.ts

@@ -16,6 +16,7 @@ import type { GoalModeState, GoalRuntime } from "../goals";
 import { GoalTool } from "../goals/tools/goal-tool";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
+import type { DaemonCompletionNotification } from "../launch/protocol";
 import { LspTool } from "../lsp";
 import type { MCPManager } from "../mcp";
 import type { MnemopiSessionState } from "../mnemopi/state";
@@ -155,6 +156,8 @@ export interface ToolSession {
 	additionalDirectories?: string[];
 	/** Whether UI is available */
 	hasUI: boolean;
+	/** Whether this session has begun disposal. */
+	isDisposed?: () => boolean;
 	/**
 	 * Suppress the spawn specialization/coordination advisory appended to `task`
 	 * results. Set by internal/programmatic callers (e.g. the commit agent's
@@ -380,6 +383,12 @@ export interface ToolSession {
 
 	/** Queue a hidden message to be injected at the next agent turn. */
 	queueDeferredMessage?(message: CustomMessage): void;
+	/** Queue a broker supervised-process completion for the owning session. */
+	queueLaunchCompletion?(notification: DaemonCompletionNotification): Promise<void>;
+	/** Register cleanup that runs when this session is disposed; returns a handle that removes the cleanup. */
+	registerDisposeCallback?(callback: () => void): (() => void) | void;
+	/** Register cleanup that runs when this ToolSession adopts a different session ID. */
+	registerSessionChangeCallback?(callback: () => void): (() => void) | void;
 	/** Queue late LSP diagnostics (arrived after an edit/write returned) to be shown
 	 *  in the transcript and delivered to the model at the next yield, like background
 	 *  job results. */

package/dist/types/config/file-lock.d.ts

@@ -1,29 +0,0 @@
-export interface FileLockOptions {
-    staleMs?: number;
-    retries?: number;
-    retryDelayMs?: number;
-}
-interface LockInfo {
-    pid: number;
-    timestamp: number;
-    token: string;
-}
-declare function getLockPath(filePath: string): string;
-declare function readLockInfo(lockPath: string): Promise<LockInfo | null>;
-declare function isLockStale(lockPath: string, staleMs: number): Promise<boolean>;
-declare function tryAcquireLock(lockPath: string): Promise<string | null>;
-declare function releaseLock(lockPath: string, expectedToken?: string): Promise<void>;
-export declare function withFileLock<T>(filePath: string, fn: () => Promise<T>, options?: FileLockOptions): Promise<T>;
-/**
- * Test-only handles for the internal lock primitives. These are NOT part of
- * the public API — they exist so the contract tests can validate token-keyed
- * release semantics and the mkdir-race window without re-implementing them.
- */
-export declare const __internalsForTesting: {
-    tryAcquireLock: typeof tryAcquireLock;
-    releaseLock: typeof releaseLock;
-    readLockInfo: typeof readLockInfo;
-    isLockStale: typeof isLockStale;
-    getLockPath: typeof getLockPath;
-};
-export {};