@oh-my-pi/pi-coding-agent 17.0.8 → 17.1.0

package/src/session/prewalk.ts

@@ -0,0 +1,252 @@
+import type { Agent, AgentMessage, AgentToolResult, AgentTurnEndContext } from "@oh-my-pi/pi-agent-core";
+import { invalidateMessageCache } from "@oh-my-pi/pi-agent-core/compaction";
+import type { Model } from "@oh-my-pi/pi-ai";
+import { modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
+import { prompt } from "@oh-my-pi/pi-utils";
+import type { LocalProtocolOptions } from "../internal-urls";
+import { resolveApprovedPlan } from "../plan-mode/approved-plan";
+import { listPlanFiles, readPlanFile } from "../plan-mode/plan-files";
+import type { PlanModeState } from "../plan-mode/state";
+import planYoloHandoffPrompt from "../prompts/system/plan-yolo-handoff.md" with { type: "text" };
+import prewalkChecklistPrompt from "../prompts/system/prewalk-checklist.md" with { type: "text" };
+import prewalkContinuePrompt from "../prompts/system/prewalk-continue.md" with { type: "text" };
+import prewalkPlanPrompt from "../prompts/system/prewalk-plan.md" with { type: "text" };
+import type { ConfiguredThinkingLevel } from "../thinking";
+import type { PlanProposalHandler } from "../tools/resolve";
+import { ToolError } from "../tools/tool-errors";
+import type { PlanYolo, Prewalk } from "./agent-session-types";
+import type { SessionManager } from "./session-manager";
+
+const PREWALK_PLAN_MESSAGE_TYPE = "prewalk-plan";
+const PREWALK_CONTINUE_MESSAGE_TYPE = "prewalk-continue";
+const PREWALK_CHECKLIST_MESSAGE_TYPE = "prewalk-checklist";
+const PREWALK_ACTION_TOOLS: Record<string, true> = {
+	edit: true,
+	write: true,
+};
+const PLAN_YOLO_HANDOFF_MESSAGE_TYPE = "plan-yolo-handoff";
+
+/** Capabilities the prewalk coordinator borrows from its owning session. */
+export interface PrewalkCoordinatorHost {
+	agent: Agent;
+	sessionManager: SessionManager;
+	model(): Model | undefined;
+	emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
+	setModelTemporary(
+		model: Model,
+		thinkingLevel?: ConfiguredThinkingLevel,
+		options?: { ephemeral?: boolean },
+	): Promise<void>;
+	setActiveToolsByName(names: string[]): Promise<void>;
+	getActiveToolNames(): string[];
+	getEnabledToolNames(): string[];
+	hasBuiltInTool(name: string): boolean;
+	getPlanModeState(): PlanModeState | undefined;
+	setPlanModeState(state: PlanModeState | undefined): void;
+	getPlanReferencePath(): string;
+	setPlanProposalHandler(handler: PlanProposalHandler | null): void;
+	waitForSessionMessagePersistence(message: AgentMessage): Promise<void>;
+	localProtocolOptions(): LocalProtocolOptions;
+}
+
+/** Initial state for prewalk and plan-yolo startup flows. */
+export interface PrewalkCoordinatorOptions {
+	prewalk?: Prewalk;
+	planYolo?: PlanYolo;
+}
+
+/** Coordinates one-way model prewalks and automatic plan-yolo handoffs. */
+export class PrewalkCoordinator {
+	readonly #host: PrewalkCoordinatorHost;
+	#prewalk: Prewalk | undefined;
+	#planInjected = false;
+	#continuePending = false;
+	#todoSeen = false;
+	#planYolo: PlanYolo | undefined;
+	#planYoloPreviousTools: string[] | undefined;
+	#planYoloArmed = false;
+
+	constructor(host: PrewalkCoordinatorHost, options: PrewalkCoordinatorOptions = {}) {
+		this.#host = host;
+		this.#prewalk = options.prewalk;
+		this.#planYolo = options.planYolo;
+	}
+
+	/** Current prewalk target, if the one-way switch remains armed. */
+	get state(): Prewalk | undefined {
+		return this.#prewalk;
+	}
+
+	/** Advances the one-way prewalk switch at a completed assistant-turn boundary. */
+	async advanceAtTurnEnd(liveMessages: AgentMessage[], context: AgentTurnEndContext | undefined): Promise<void> {
+		const prewalk = this.#prewalk;
+		if (!prewalk || context?.message.role !== "assistant") return;
+		if (context.toolResults.some(result => result.toolName === "todo" && !result.isError)) this.#todoSeen = true;
+
+		const hasToolResults = context.toolResults.length > 0;
+		if (this.#planInjected && hasToolResults) {
+			this.#continuePending = true;
+		} else if (this.#continuePending) {
+			this.#continuePending = false;
+			this.#host.agent.steer({
+				role: "custom",
+				customType: PREWALK_CONTINUE_MESSAGE_TYPE,
+				content: prewalkContinuePrompt,
+				attribution: "agent",
+				display: false,
+				timestamp: Date.now(),
+			});
+		}
+
+		const todoGateOpen = this.#todoSeen || !this.#host.getActiveToolNames().includes("todo");
+		const action = todoGateOpen
+			? context.toolResults.find(result => PREWALK_ACTION_TOOLS[result.toolName])
+			: undefined;
+		if (!action) {
+			if (!this.#planInjected) {
+				this.#planInjected = true;
+				this.#continuePending = true;
+				this.#host.agent.steer({
+					role: "custom",
+					customType: PREWALK_PLAN_MESSAGE_TYPE,
+					content: prewalkPlanPrompt,
+					display: false,
+					attribution: "agent",
+					timestamp: Date.now(),
+				});
+				this.#host.emitNotice("info", "Prewalk: injected deep-plan nudge.", "prewalk");
+			}
+			return;
+		}
+
+		await this.#host.waitForSessionMessagePersistence(context.message);
+		for (const toolResult of context.toolResults) {
+			await this.#host.waitForSessionMessagePersistence(toolResult);
+		}
+		this.#scrubPlanNudge(liveMessages);
+		const target = prewalk.target;
+		const currentModel = this.#host.model();
+		if (currentModel && modelsAreEqual(currentModel, target)) {
+			this.#prewalk = undefined;
+			return;
+		}
+		await this.#host.setModelTemporary(target, prewalk.thinkingLevel, { ephemeral: true });
+		this.#prewalk = undefined;
+		this.#host.emitNotice(
+			"info",
+			`Prewalk: switched to ${target.provider}/${target.id} after first ${action.toolName} call.`,
+			"prewalk",
+		);
+		this.#host.agent.steer({
+			role: "custom",
+			customType: PREWALK_CHECKLIST_MESSAGE_TYPE,
+			content: prewalkChecklistPrompt,
+			attribution: "agent",
+			display: false,
+			timestamp: Date.now(),
+		});
+	}
+
+	/** Arms a prewalk immediately for an explicit slash-command request. */
+	arm(target: Model, thinkingLevel?: ConfiguredThinkingLevel): void {
+		if (this.#prewalk) {
+			this.#host.emitNotice(
+				"info",
+				`Prewalk: already armed for ${this.#prewalk.target.provider}/${this.#prewalk.target.id}, waiting for the first edit/write.`,
+				"prewalk",
+			);
+			return;
+		}
+		this.#prewalk = { target, thinkingLevel };
+		this.#planInjected = true;
+		this.#continuePending = true;
+		this.#host.agent.steer({
+			role: "custom",
+			customType: PREWALK_PLAN_MESSAGE_TYPE,
+			content: prewalkPlanPrompt,
+			display: false,
+			attribution: "agent",
+			timestamp: Date.now(),
+		});
+		this.#host.emitNotice(
+			"info",
+			`Prewalk: armed for ${target.provider}/${target.id} — will switch at the first edit/write once the todo list exists.`,
+			"prewalk",
+		);
+	}
+
+	/** Lazily enables plan-yolo's plan phase before the first prompt is built. */
+	async armPlanYoloIfNeeded(): Promise<void> {
+		if (!this.#planYolo || this.#planYoloArmed) return;
+		this.#planYoloArmed = true;
+		const previousTools = this.#host.getEnabledToolNames();
+		const augmentations = this.#host.hasBuiltInTool("write") ? ["write"] : [];
+		await this.#host.setActiveToolsByName([...new Set([...previousTools, ...augmentations])]);
+		this.#planYoloPreviousTools = previousTools;
+		this.#host.setPlanModeState({
+			enabled: true,
+			planFilePath: this.#host.getPlanReferencePath() || "local://PLAN.md",
+			workflow: "parallel",
+		});
+		this.#host.setPlanProposalHandler(title => this.#finalizePlanYoloProposal(title));
+	}
+
+	#scrubPlanNudge(liveMessages: AgentMessage[]): void {
+		if (!this.#planInjected) return;
+		const isPlanNudge = (message: AgentMessage): boolean =>
+			message.role === "custom" && message.customType === PREWALK_PLAN_MESSAGE_TYPE;
+		for (let index = liveMessages.length - 1; index >= 0; index--) {
+			if (!isPlanNudge(liveMessages[index])) continue;
+			invalidateMessageCache(liveMessages[index]);
+			liveMessages.splice(index, 1);
+		}
+		const stateMessages = this.#host.agent.state.messages;
+		const filtered = stateMessages.filter(message => !isPlanNudge(message));
+		if (filtered.length !== stateMessages.length) this.#host.agent.replaceMessages(filtered);
+	}
+
+	async #finalizePlanYoloProposal(title: string): Promise<AgentToolResult<unknown>> {
+		const planYolo = this.#planYolo;
+		const state = this.#host.getPlanModeState();
+		if (!planYolo || !state?.enabled) throw new ToolError("Plan mode is not active.");
+		const { planFilePath, title: resolvedTitle } = await resolveApprovedPlan({
+			suppliedTitle: title,
+			statePlanFilePath: state.planFilePath,
+			readPlan: url =>
+				readPlanFile(url, {
+					localProtocolOptions: this.#host.localProtocolOptions(),
+					cwd: this.#host.sessionManager.getCwd(),
+				}),
+			listPlanFiles: () => listPlanFiles({ localProtocolOptions: this.#host.localProtocolOptions() }),
+		});
+		this.#host.setPlanModeState(undefined);
+		const previousTools = this.#planYoloPreviousTools;
+		try {
+			if (previousTools) await this.#host.setActiveToolsByName(previousTools);
+		} catch (error) {
+			this.#host.setPlanModeState(state);
+			throw error;
+		}
+		this.#host.setPlanProposalHandler(null);
+		this.#planYolo = undefined;
+		this.#planYoloPreviousTools = undefined;
+		await this.#host.setModelTemporary(planYolo.target, planYolo.thinkingLevel, { ephemeral: true });
+		this.#host.emitNotice(
+			"info",
+			`Plan-yolo: plan approved, switched to ${planYolo.target.provider}/${planYolo.target.id} to implement "${resolvedTitle}".`,
+			"plan-yolo",
+		);
+		this.#host.agent.steer({
+			role: "custom",
+			customType: PLAN_YOLO_HANDOFF_MESSAGE_TYPE,
+			content: prompt.render(planYoloHandoffPrompt, { planFilePath, title: resolvedTitle }),
+			attribution: "agent",
+			display: false,
+			timestamp: Date.now(),
+		});
+		return {
+			content: [{ type: "text", text: `Plan approved. Implementing now with ${planYolo.target.id}.` }],
+			details: { planFilePath, title: resolvedTitle, planExists: true },
+		};
+	}
+}

package/src/session/queued-messages.ts

@@ -0,0 +1,93 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
+import type { RestoredQueuedMessage } from "./agent-session-types";
+import { type CustomMessage, readQueueChipText } from "./messages";
+
+function queuedTextContent(message: AgentMessage): string | undefined {
+	if (!("content" in message)) return undefined;
+	const content = message.content;
+	if (typeof content === "string") return content;
+	for (const part of content) {
+		if (part.type === "text") return part.text;
+	}
+	return undefined;
+}
+
+function queuedImageContent(message: AgentMessage): ImageContent[] | undefined {
+	if (!("content" in message) || typeof message.content === "string") return undefined;
+	const images: ImageContent[] = [];
+	for (const part of message.content) {
+		if (part.type === "image" && typeof part.data === "string" && typeof part.mimeType === "string") {
+			images.push(part);
+		}
+	}
+	return images.length > 0 ? images : undefined;
+}
+
+/** Whether a queued message should render in the queue UI. */
+export function isDisplayableQueuedMessage(message: AgentMessage): boolean {
+	return !(message.role === "custom" && message.display === false);
+}
+
+/** Whether a queued message is an advisor card. */
+export function isAdvisorCard(message: AgentMessage): message is CustomMessage {
+	return message.role === "custom" && message.customType === "advisor";
+}
+
+/** Whether a message is a terminal assistant answer containing text and no tools. */
+export function isTerminalTextAssistantAnswer(message: AgentMessage | undefined): message is AssistantMessage {
+	if (message?.role !== "assistant" || message.stopReason !== "stop") return false;
+	let hasText = false;
+	for (const part of message.content) {
+		if (part.type === "toolCall") return false;
+		if (part.type === "text") {
+			if (part.text.trim().length > 0) hasText = true;
+			continue;
+		}
+		if (part.type === "thinking" || part.type === "redactedThinking" || part.type === "fallback") continue;
+		return false;
+	}
+	return hasText;
+}
+
+/** Whether queued content was authored by the user and can be restored to the editor. */
+export function isUserQueuedMessage(message: AgentMessage): boolean {
+	if (message.role === "user") return true;
+	return message.role === "custom" && message.attribution === "user" && message.display !== false;
+}
+
+/** Hidden magic-keyword notices queued alongside a user prompt. */
+export const MAGIC_KEYWORD_NOTICE_TYPES: Record<string, true> = {
+	"ultrathink-notice": true,
+	"orchestrate-notice": true,
+	"workflow-notice": true,
+};
+
+/** Hidden companion carrying vision descriptions for a text-only model. */
+export const IMAGE_ATTACHMENT_DESCRIPTION_TYPE = "image-attachment-description";
+
+/** Whether a hidden queued message is a companion of an adjacent user prompt. */
+export function isHiddenUserCompanion(message: AgentMessage): boolean {
+	return (
+		message.role === "custom" &&
+		message.attribution === "user" &&
+		message.display === false &&
+		(MAGIC_KEYWORD_NOTICE_TYPES[message.customType] === true ||
+			message.customType === IMAGE_ATTACHMENT_DESCRIPTION_TYPE)
+	);
+}
+
+/** Human-readable text shown for a queued-message chip. */
+export function queueChipText(message: AgentMessage): string {
+	if (message.role === "custom") {
+		return readQueueChipText(message.details) ?? queuedTextContent(message) ?? "";
+	}
+	const text = queuedTextContent(message) ?? "";
+	if (text) return text;
+	return queuedImageContent(message) ? "[Image]" : "";
+}
+
+/** Converts a queued user message to editor-restorable content. */
+export function toRestoredQueuedMessage(message: AgentMessage): RestoredQueuedMessage {
+	return { text: queueChipText(message), images: queuedImageContent(message) };
+}

package/src/session/redis-session-storage.ts

@@ -13,6 +13,7 @@ import type { SessionTitleUpdate } from "./session-title-slot";
  * without dragging the entire Bun typings into this module.
  */
 export interface RedisSessionStorageClient {
+	send(command: string, args: string[]): Promise<unknown>;
 	get(key: string): Promise<string | null>;
 	getrange(key: string, start: number, end: number): Promise<string>;
 	strlen(key: string): Promise<number>;
@@ -45,6 +46,26 @@ export interface RedisSessionStorageOptions {
 const DEFAULT_PREFIX = "omp:sessions:";
 const DEFAULT_SCAN_COUNT = 500;
 
+const WRITE_FULL_SCRIPT = `-- OMP_WRITE_FULL
+redis.call("SET", KEYS[1], ARGV[1])
+redis.call("HSET", KEYS[2], ARGV[2], ARGV[3])
+if ARGV[4] == "1" then
+	redis.call("HSET", KEYS[3], ARGV[2], ARGV[5])
+else
+	redis.call("HDEL", KEYS[3], ARGV[2])
+end
+return 1`;
+
+const APPEND_SCRIPT = `-- OMP_APPEND
+local size = redis.call("APPEND", KEYS[1], ARGV[1])
+redis.call("HSET", KEYS[2], ARGV[2], ARGV[3])
+return size`;
+
+const UPDATE_TITLE_SCRIPT = `-- OMP_UPDATE_TITLE
+redis.call("HSET", KEYS[1], ARGV[1], ARGV[2])
+redis.call("HSET", KEYS[2], ARGV[1], ARGV[3])
+return 1`;
+
 function encodeTitleMeta(title: SessionTitleUpdate): string {
 	return JSON.stringify(title);
 }
@@ -155,23 +176,42 @@ class RedisSessionStorageBackend implements SessionStorageBackend {
 	}
 
 	async writeFull(path: string, content: string, mtimeMs: number, title?: SessionTitleUpdate): Promise<void> {
-		await this.#client.set(this.#fileKey(path), content);
-		await this.#client.hset(this.#metaKey(), path, String(mtimeMs));
-		if (title) {
-			await this.#client.hset(this.#titleMetaKey(), path, encodeTitleMeta(title));
-		} else {
-			await this.#client.hdel(this.#titleMetaKey(), path);
-		}
+		await this.#client.send("EVAL", [
+			WRITE_FULL_SCRIPT,
+			"3",
+			this.#fileKey(path),
+			this.#metaKey(),
+			this.#titleMetaKey(),
+			content,
+			path,
+			String(mtimeMs),
+			title ? "1" : "0",
+			title ? encodeTitleMeta(title) : "",
+		]);
 	}
 
 	async append(path: string, line: string, mtimeMs: number): Promise<void> {
-		await this.#client.append(this.#fileKey(path), line);
-		await this.#client.hset(this.#metaKey(), path, String(mtimeMs));
+		await this.#client.send("EVAL", [
+			APPEND_SCRIPT,
+			"2",
+			this.#fileKey(path),
+			this.#metaKey(),
+			line,
+			path,
+			String(mtimeMs),
+		]);
 	}
 
 	async updateSessionTitle(path: string, title: SessionTitleUpdate, mtimeMs: number): Promise<void> {
-		await this.#client.hset(this.#metaKey(), path, String(mtimeMs));
-		await this.#client.hset(this.#titleMetaKey(), path, encodeTitleMeta(title));
+		await this.#client.send("EVAL", [
+			UPDATE_TITLE_SCRIPT,
+			"2",
+			this.#metaKey(),
+			this.#titleMetaKey(),
+			path,
+			String(mtimeMs),
+			encodeTitleMeta(title),
+		]);
 	}
 
 	async truncate(path: string, mtimeMs: number): Promise<void> {