@oh-my-pi/pi-coding-agent 17.0.1 → 17.0.2

package/src/modes/warp-events.ts

@@ -0,0 +1,232 @@
+import * as path from "node:path";
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { isInsideTmux, wrapTmuxPassthrough } from "@oh-my-pi/pi-tui/terminal-capabilities";
+import { VERSION } from "@oh-my-pi/pi-utils/dirs";
+import type { ExtensionContext, ExtensionFactory } from "../extensibility/extensions/types";
+import { isSilentAbort, isUserInterruptAbort, SKILL_PROMPT_MESSAGE_TYPE } from "../session/messages";
+
+const WARP_CLI_AGENT_PROTOCOL_VERSION = 1;
+const WARP_CLI_AGENT_SENTINEL = "warp://cli-agent";
+const WARP_ATTENTION_EVENTS: Record<string, true> = {
+	stop: true,
+	stop_failure: true,
+	permission_request: true,
+	question_asked: true,
+};
+
+/** True when Warp has negotiated the structured CLI-agent OSC protocol. */
+export function isWarpCliAgentProtocolActive(): boolean {
+	return Number(process.env.WARP_CLI_AGENT_PROTOCOL_VERSION) >= WARP_CLI_AGENT_PROTOCOL_VERSION;
+}
+
+export type WarpEventValue =
+	| string
+	| number
+	| boolean
+	| null
+	| readonly WarpEventValue[]
+	| { readonly [key: string]: WarpEventValue | undefined };
+
+/** Fields added to the Warp CLI-agent event envelope by the event bridge. */
+export type WarpEvent = Readonly<Record<string, WarpEventValue | undefined>>;
+
+export interface WarpEventEmitterOptions {
+	sessionId: string;
+	getCwd?: () => string;
+}
+
+export interface WarpEventEmitter {
+	emit(event: WarpEvent): void;
+}
+
+/**
+ * Creates the Warp event transport for a top-level interactive TUI session.
+ * The caller MUST enforce that install-site invariant; the sole production
+ * caller is gated by `isInteractive`, so ACP, RPC, print, headless, and
+ * subagent sessions never construct an emitter.
+ */
+export function createWarpEventEmitter(options: WarpEventEmitterOptions): WarpEventEmitter | undefined {
+	if (!isWarpCliAgentProtocolActive()) {
+		return undefined;
+	}
+
+	return {
+		emit(event): void {
+			const cwd = options.getCwd?.() ?? process.cwd();
+			const body = {
+				...event,
+				v: WARP_CLI_AGENT_PROTOCOL_VERSION,
+				// Warp resolves this via CLIAgent.command_prefix(); OhMyPi is "omp".
+				agent: "omp",
+				session_id: options.sessionId,
+				cwd,
+				project: path.basename(cwd),
+				plugin_version: VERSION,
+			};
+			const osc = `\x1b]777;notify;${WARP_CLI_AGENT_SENTINEL};${JSON.stringify(body)}\x07`;
+			if (!isInsideTmux()) {
+				process.stdout.write(osc);
+				return;
+			}
+			// DCS-wrap every OSC so Warp can parse it under allow-passthrough.
+			// Outer BEL after DCS is only for attention-worthy events so tmux
+			// monitor-bell flags the pane; the OSC's own trailing \x07 is its
+			// terminator and does not drive the outer bell after wrapping.
+			const wrapped = wrapTmuxPassthrough(osc);
+			const eventName = event.event;
+			const ring = typeof eventName === "string" && Object.hasOwn(WARP_ATTENTION_EVENTS, eventName);
+			process.stdout.write(ring ? `${wrapped}\x07` : wrapped);
+		},
+	};
+}
+
+type LastAssistantStop = {
+	response: string;
+	event: "stop" | "stop_failure";
+	error_type?: "error" | "aborted";
+};
+
+function lastAssistantStop(messages: readonly AgentMessage[]): LastAssistantStop {
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index];
+		if (message.role !== "assistant") continue;
+
+		const text = message.content
+			.filter(content => content.type === "text")
+			.map(content => content.text)
+			.join("");
+
+		let response = "";
+		if (text.length > 0) {
+			response = text;
+		} else {
+			const errorMessage = message.errorMessage;
+			if (typeof errorMessage === "string" && errorMessage.length > 0 && !isSilentAbort(message)) {
+				if (message.stopReason === "error") {
+					response = errorMessage;
+				} else if (message.stopReason === "aborted" && !isUserInterruptAbort(message)) {
+					response = errorMessage;
+				}
+			}
+		}
+
+		if (message.stopReason === "error") {
+			return { response, event: "stop_failure", error_type: "error" };
+		}
+		if (
+			message.stopReason === "aborted" &&
+			!isSilentAbort(message) &&
+			!isUserInterruptAbort(message) &&
+			typeof message.errorMessage === "string" &&
+			message.errorMessage.length > 0
+		) {
+			return { response, event: "stop_failure", error_type: "aborted" };
+		}
+		return { response, event: "stop" };
+	}
+	return { response: "", event: "stop" };
+}
+
+function truncateEventText(text: string): string {
+	let end = 0;
+	let count = 0;
+	for (const codePoint of text) {
+		if (count === 200) break;
+		end += codePoint.length;
+		count++;
+	}
+	return text.slice(0, end);
+}
+
+function messageText(content: unknown): string {
+	if (typeof content === "string") {
+		return content;
+	}
+	if (!Array.isArray(content)) {
+		return "";
+	}
+	return content
+		.filter(
+			(block): block is { type: "text"; text: string } =>
+				!!block &&
+				typeof block === "object" &&
+				"type" in block &&
+				block.type === "text" &&
+				"text" in block &&
+				typeof block.text === "string",
+		)
+		.map(block => block.text)
+		.join("");
+}
+
+/** Internal event bridge installed only by the top-level interactive TUI runner. */
+export function createWarpEventBridgeExtension(): ExtensionFactory {
+	return api => {
+		let emitter: WarpEventEmitter | undefined;
+		let activePrompt: string | undefined;
+		let getCwd: (() => string) | undefined;
+
+		const rebuildEmitter = (_event: unknown, ctx: ExtensionContext): void => {
+			activePrompt = undefined;
+			getCwd = () => ctx.sessionManager.getCwd();
+			emitter = createWarpEventEmitter({ sessionId: ctx.sessionManager.getSessionId(), getCwd });
+			emitter?.emit({ event: "session_start" });
+		};
+
+		api.on("session_start", rebuildEmitter);
+		api.on("session_switch", rebuildEmitter);
+		api.on("session_branch", rebuildEmitter);
+
+		api.on("message_start", event => {
+			const message = event.message as AgentMessage;
+			if (message.role === "user") {
+				if (message.synthetic || message.attribution === "agent") {
+					return;
+				}
+			} else if (
+				message.role !== "custom" ||
+				message.customType !== SKILL_PROMPT_MESSAGE_TYPE ||
+				message.attribution !== "user"
+			) {
+				return;
+			}
+			activePrompt = truncateEventText(messageText(message.content));
+			emitter?.emit({ event: "prompt_submit", query: activePrompt });
+		});
+
+		api.on("tool_approval_requested", event => {
+			emitter?.emit({
+				event: "permission_request",
+				tool_name: event.toolName,
+				summary: `omp wants to run ${event.toolName}`,
+			});
+		});
+
+		api.on("tool_approval_resolved", () => {
+			emitter?.emit({ event: "permission_replied" });
+		});
+
+		api.on("tool_execution_start", event => {
+			if (event.toolName === "ask") {
+				emitter?.emit({ event: "question_asked", summary: "Waiting for your answer" });
+			}
+		});
+
+		api.on("tool_result", event => {
+			emitter?.emit({ event: "tool_complete", tool_name: event.toolName });
+		});
+
+		api.on("agent_end", event => {
+			if (event.willContinue) {
+				return;
+			}
+			const stop = lastAssistantStop(event.messages);
+			emitter?.emit({
+				event: stop.event,
+				query: activePrompt,
+				response: truncateEventText(stop.response),
+				...(stop.error_type !== undefined ? { error_type: stop.error_type } : {}),
+			});
+		});
+	};
+}

package/src/plan-mode/model-transition.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "bun:test";
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { ResolvedModelRoleValue } from "../config/model-resolver";
+import { AUTO_THINKING } from "../thinking";
+import { resolvePlanModelTransition } from "./model-transition";
+
+/**
+ * Plan-mode model transition policy (issue #5657). The active model in plan
+ * mode IS the plan-role model, so reassigning that role mid-planning must move
+ * the session onto the new model — or defer the switch when a turn is streaming.
+ */
+const model = (provider: string, id: string): Model => ({ provider, id }) as unknown as Model;
+
+const resolved = (
+	m: Model | undefined,
+	thinking?: ResolvedModelRoleValue["thinkingLevel"],
+): ResolvedModelRoleValue => ({
+	model: m,
+	thinkingLevel: thinking,
+	explicitThinkingLevel: thinking !== undefined,
+	warning: undefined,
+});
+
+describe("resolvePlanModelTransition", () => {
+	it("switches to the resolved plan model when it differs from the active one", () => {
+		const plan = model("anthropic", "opus");
+		const transition = resolvePlanModelTransition(model("openai", "gpt"), resolved(plan), false);
+		expect(transition).toEqual({ kind: "apply", model: plan, thinkingLevel: undefined, deferred: false });
+	});
+
+	it("defers the switch while the session is streaming", () => {
+		const plan = model("anthropic", "opus");
+		const transition = resolvePlanModelTransition(model("openai", "gpt"), resolved(plan), true);
+		expect(transition).toEqual({ kind: "apply", model: plan, thinkingLevel: undefined, deferred: true });
+	});
+
+	it("carries the plan role's explicit thinking level into the switch", () => {
+		const plan = model("anthropic", "opus");
+		const transition = resolvePlanModelTransition(model("openai", "gpt"), resolved(plan, ThinkingLevel.High), false);
+		expect(transition).toEqual({ kind: "apply", model: plan, thinkingLevel: ThinkingLevel.High, deferred: false });
+	});
+
+	it("only adjusts thinking when the model is unchanged but the level is explicit", () => {
+		const plan = model("anthropic", "opus");
+		const transition = resolvePlanModelTransition(plan, resolved(model("anthropic", "opus"), AUTO_THINKING), false);
+		expect(transition).toEqual({ kind: "thinking", thinkingLevel: AUTO_THINKING });
+	});
+
+	it("is a no-op when the model matches and no explicit thinking level is set", () => {
+		const plan = model("anthropic", "opus");
+		const transition = resolvePlanModelTransition(plan, resolved(model("anthropic", "opus")), false);
+		expect(transition).toEqual({ kind: "none" });
+	});
+
+	it("is a no-op when the plan role resolves to no model", () => {
+		const transition = resolvePlanModelTransition(model("openai", "gpt"), resolved(undefined), false);
+		expect(transition).toEqual({ kind: "none" });
+	});
+});

package/src/plan-mode/model-transition.ts

@@ -0,0 +1,51 @@
+/**
+ * Plan-mode model transition policy.
+ *
+ * Plan mode drives the active session model from the `plan` role: it switches
+ * to the plan model on entry and restores the pre-plan model on exit. The same
+ * policy also runs when the `plan` role is reassigned mid-planning, so a
+ * correction to the wrong plan model takes effect at the next turn boundary
+ * (issue #5657).
+ *
+ * This module holds only the pure decision — what transition a given
+ * (current model, resolved role, streaming) triple implies — so the branching
+ * is testable without a live session or TUI. The interactive mode performs the
+ * resulting side effect.
+ */
+import type { Model } from "@oh-my-pi/pi-ai";
+import { modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
+import type { ResolvedModelRoleValue } from "../config/model-resolver";
+import type { ConfiguredThinkingLevel } from "../thinking";
+
+/** The action implied by resolving the `plan` role against the active model. */
+export type PlanModelTransition =
+	/** Already on the plan model with no thinking-level change to apply. */
+	| { kind: "none" }
+	/** Same model; only the plan role's explicit thinking level differs. */
+	| { kind: "thinking"; thinkingLevel: ConfiguredThinkingLevel }
+	/**
+	 * Switch to `model`. `deferred` is set when the session is mid-stream: the
+	 * switch must wait for the current turn to end (a live `setModelTemporary`
+	 * resets the provider session), so the caller queues it instead.
+	 */
+	| { kind: "apply"; model: Model; thinkingLevel: ConfiguredThinkingLevel | undefined; deferred: boolean };
+
+/**
+ * Decide how to reconcile the active model with the resolved `plan` role.
+ *
+ * @param currentModel - The session's active model, or `undefined` before one is set.
+ * @param resolved - The `plan` role resolved against the available models.
+ * @param isStreaming - Whether the session is mid-turn (forces a deferred switch).
+ */
+export function resolvePlanModelTransition(
+	currentModel: Model | undefined,
+	resolved: ResolvedModelRoleValue,
+	isStreaming: boolean,
+): PlanModelTransition {
+	if (!resolved.model) return { kind: "none" };
+	const planThinkingLevel = resolved.explicitThinkingLevel ? resolved.thinkingLevel : undefined;
+	if (modelsAreEqual(currentModel, resolved.model)) {
+		return planThinkingLevel ? { kind: "thinking", thinkingLevel: planThinkingLevel } : { kind: "none" };
+	}
+	return { kind: "apply", model: resolved.model, thinkingLevel: planThinkingLevel, deferred: isStreaming };
+}

package/src/registry/agent-lifecycle.ts

@@ -8,6 +8,12 @@
  * sessionFile), and revives it on demand through
  * {@link AgentLifecycleManager.ensureLive}. Only this manager flips
  * `parked` ↔ `idle`.
+ *
+ * Park/dispose is gated against concurrent ensureLive/hub-send:
+ * - A disposing session is never handed out.
+ * - ensureLive during an in-flight park either cancels the park (session still
+ *   live) or waits for detach+park and then revives.
+ * - Concurrent ensureLive/park operations coalesce per id.
  */
 
 import { logger } from "@oh-my-pi/pi-utils";
@@ -38,6 +44,17 @@ interface AdoptedAgent {
 	timer?: NodeJS.Timeout;
 }
 
+interface ParkInFlight {
+	/** Resolves when the park attempt finishes (success, cancel, or dispose error). */
+	promise: Promise<void>;
+	/** Cancel before the session is detached. Returns true if cancel took effect. */
+	cancel: () => boolean;
+	/** True once cancel() succeeded (ensureLive kept the live session). */
+	cancelled: boolean;
+	/** True once the live session has been detached and status is parked. */
+	detached: boolean;
+}
+
 export class AgentLifecycleManager {
 	static #global: AgentLifecycleManager | undefined;
 
@@ -59,7 +76,7 @@ export class AgentLifecycleManager {
 			}
 			current.#adopted.clear();
 			current.#revivals.clear();
-			current.#parking.clear();
+			current.#parks.clear();
 			current.#persistedReviverFactory = undefined;
 		}
 		AgentLifecycleManager.#global = undefined;
@@ -67,8 +84,11 @@ export class AgentLifecycleManager {
 
 	readonly #registry: AgentRegistry;
 	readonly #adopted = new Map<string, AdoptedAgent>();
-	/** Ids whose session is being disposed by {@link park} right now. */
-	readonly #parking = new Set<string>();
+	/**
+	 * In-flight park attempts. A park is cancelable until the live session is
+	 * detached; after detach, ensureLive waits for the park and revives.
+	 */
+	readonly #parks = new Map<string, ParkInFlight>();
 	/** In-flight revives, so concurrent {@link ensureLive} calls coalesce. */
 	readonly #revivals = new Map<string, Promise<AgentSession>>();
 	#unsubscribe: (() => void) | undefined;
@@ -114,44 +134,129 @@ export class AgentLifecycleManager {
 		return this.#adopted.has(id);
 	}
 
-	/** True while {@link park} is disposing this agent's session (lets dispose hooks distinguish park from teardown). */
+	/**
+	 * True when this manager owns `registry` — i.e. its adopt/park/revive state
+	 * describes that registry's refs. Lets a caller holding a specific registry
+	 * (e.g. a custom-registry {@link IrcBus} that fell back to the global
+	 * manager) skip lifecycle gating that would consult unrelated park state.
+	 */
+	manages(registry: AgentRegistry): boolean {
+		return this.#registry === registry;
+	}
+
+	/**
+	 * True while {@link park} is disposing this agent's session (lets dispose
+	 * hooks distinguish park from teardown). False once the park is cancelled
+	 * by ensureLive or after detach+dispose completes.
+	 */
 	isParking(id: string): boolean {
-		return this.#parking.has(id);
+		const park = this.#parks.get(id);
+		return Boolean(park && !park.cancelled);
 	}
 
 	/**
 	 * Dispose the live session, detach it from the registry, and mark the
 	 * agent `parked`. No-op unless the id is adopted and live.
+	 *
+	 * The session is detached (and status flipped to `parked`) *before*
+	 * `session.dispose()` so concurrent {@link ensureLive}/hub-send never
+	 * observe or inject into a disposing session. A concurrent ensureLive that
+	 * arrives before detach cancels the park and keeps the live session.
 	 */
 	async park(id: string): Promise<void> {
+		const existing = this.#parks.get(id);
+		if (existing) return existing.promise;
+
 		const adopted = this.#adopted.get(id);
 		if (!adopted) return;
 		const ref = this.#registry.get(id);
-		if (!ref?.session) return;
+		const session = ref?.session;
+		if (!session) return;
+
 		if (adopted.timer) {
 			clearTimeout(adopted.timer);
 			adopted.timer = undefined;
 		}
-		this.#parking.add(id);
-		try {
+
+		let cancelled = false;
+		const park: ParkInFlight = {
+			promise: undefined as unknown as Promise<void>,
+			cancel: () => {
+				// Cancel only before detach — once detached the old session is already
+				// leaving the registry and must finish disposing.
+				if (park.detached || cancelled) return cancelled;
+				cancelled = true;
+				park.cancelled = true;
+				return true;
+			},
+			cancelled: false,
+			detached: false,
+		};
+
+		park.promise = (async () => {
 			try {
-				await ref.session.dispose();
-			} catch (error) {
-				logger.warn("AgentLifecycleManager.park: session dispose failed", { id, error: String(error) });
+				// Yield so a same-tick ensureLive/hub-send can cancel before we
+				// commit to dispose. Deterministic with Promise microtasks; no timers.
+				await Promise.resolve();
+				if (cancelled) return;
+
+				// Re-check liveness: release/unregister may have raced us.
+				const live = this.#registry.get(id);
+				if (!live?.session || live.session !== session) return;
+				if (!this.#adopted.has(id)) return;
+
+				// Commit: detach + parked *before* dispose so callers never see a
+				// dying session via ref.session / idle status.
+				park.detached = true;
+				this.#registry.detachSession(id);
+				this.#registry.setStatus(id, "parked");
+
+				try {
+					await session.dispose();
+				} catch (error) {
+					logger.warn("AgentLifecycleManager.park: session dispose failed", { id, error: String(error) });
+				}
+			} finally {
+				// Only clear if we are still the in-flight entry (a later park would
+				// have replaced us only after we resolved).
+				if (this.#parks.get(id) === park) this.#parks.delete(id);
 			}
-			this.#registry.detachSession(id);
-			this.#registry.setStatus(id, "parked");
-		} finally {
-			this.#parking.delete(id);
-		}
+		})();
+
+		this.#parks.set(id, park);
+		return park.promise;
 	}
 
 	/**
 	 * Return the live session, reviving from the sessionFile if parked.
 	 * Throws a plain Error if the id is unknown or parked without a reviver.
 	 * Concurrent calls share one in-flight revive.
+	 *
+	 * Never returns a session that is mid-dispose: an in-flight park is either
+	 * cancelled (session still live) or awaited to completion before revive.
 	 */
 	async ensureLive(id: string): Promise<AgentSession> {
+		const park = this.#parks.get(id);
+		if (park) {
+			const ref = this.#registry.get(id);
+			// Cancel if the live session is still attached — keep it instead of
+			// thrashing dispose + revive.
+			if (ref?.session && !park.detached && park.cancel()) {
+				await park.promise;
+				const kept = this.#registry.get(id)?.session;
+				if (kept) {
+					// Park cleared the idle timer; re-arm so TTL park still works.
+					const adopted = this.#adopted.get(id);
+					if (adopted && ref.status === "idle") this.#armTimer(id, adopted);
+					return kept;
+				}
+			} else {
+				// Already committed to detach (or no live session): wait for park,
+				// then fall through to the revive path.
+				await park.promise;
+			}
+		}
+
 		const ref = this.#registry.get(id);
 		if (!ref) {
 			throw new Error(
@@ -208,6 +313,14 @@ export class AgentLifecycleManager {
 		const adopted = this.#adopted.get(id);
 		clearTimeout(adopted?.timer);
 		this.#adopted.delete(id);
+
+		const park = this.#parks.get(id);
+		if (park) {
+			// Prefer cancel when the session is still live so release owns dispose.
+			if (!park.detached) park.cancel();
+			await park.promise;
+		}
+
 		const ref = this.#registry.get(id);
 		if (ref?.session) {
 			try {
@@ -223,10 +336,10 @@ export class AgentLifecycleManager {
 	async dispose(): Promise<void> {
 		this.#unsubscribe?.();
 		this.#unsubscribe = undefined;
-		const ids = [...this.#adopted.keys()];
+		const ids = [...new Set([...this.#adopted.keys(), ...this.#parks.keys()])];
 		await Promise.all(ids.map(id => this.release(id)));
 		this.#revivals.clear();
-		this.#parking.clear();
+		this.#parks.clear();
 		this.#persistedReviverFactory = undefined;
 	}
 
@@ -264,6 +377,8 @@ export class AgentLifecycleManager {
 				adopted.timer = undefined;
 			}
 		} else if (event.ref.status === "idle") {
+			// Don't re-arm while a park is in flight — the park owns the transition.
+			if (this.#parks.has(event.ref.id)) return;
 			this.#armTimer(event.ref.id, adopted);
 		}
 	}