@oh-my-pi/pi-coding-agent 15.0.2 → 15.1.0

package/src/session/agent-session.ts

@@ -26,6 +26,23 @@ import {
 	type AgentTool,
 	ThinkingLevel,
 } from "@oh-my-pi/pi-agent-core";
+import {
+	AUTO_HANDOFF_THRESHOLD_FOCUS,
+	CompactionCancelledError,
+	type CompactionPreparation,
+	type CompactionResult,
+	calculateContextTokens,
+	calculatePromptTokens,
+	collectEntriesForBranchSummary,
+	compact,
+	estimateTokens,
+	generateBranchSummary,
+	generateHandoff,
+	prepareCompaction,
+	type SummaryOptions,
+	shouldCompact,
+} from "@oh-my-pi/pi-agent-core/compaction";
+import { DEFAULT_PRUNE_CONFIG, pruneToolOutputs } from "@oh-my-pi/pi-agent-core/compaction/pruning";
 import type {
 	AssistantMessage,
 	Context,
@@ -126,9 +143,7 @@ import { resolveMemoryBackend } from "../memory-backend";
 import { getCurrentThemeName, theme } from "../modes/theme/theme";
 import type { PlanModeState } from "../plan-mode/state";
 import autoContinuePrompt from "../prompts/system/auto-continue.md" with { type: "text" };
-import autoHandoffThresholdFocusPrompt from "../prompts/system/auto-handoff-threshold-focus.md" with { type: "text" };
 import eagerTodoPrompt from "../prompts/system/eager-todo.md" with { type: "text" };
-import handoffDocumentPrompt from "../prompts/system/handoff-document.md" with { type: "text" };
 import ircIncomingTemplate from "../prompts/system/irc-incoming.md" with { type: "text" };
 import planModeActivePrompt from "../prompts/system/plan-mode-active.md" with { type: "text" };
 import planModeReferencePrompt from "../prompts/system/plan-mode-reference.md" with { type: "text" };
@@ -160,21 +175,6 @@ import { extractFileMentions, generateFileMentionMessages } from "../utils/file-
 import { buildNamedToolChoice } from "../utils/tool-choice";
 import type { AuthStorage } from "./auth-storage";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome } from "./client-bridge";
-import {
-	CompactionCancelledError,
-	type CompactionPreparation,
-	type CompactionResult,
-	calculateContextTokens,
-	calculatePromptTokens,
-	collectEntriesForBranchSummary,
-	compact,
-	estimateTokens,
-	generateBranchSummary,
-	prepareCompaction,
-	type SummaryOptions,
-	shouldCompact,
-} from "./compaction";
-import { DEFAULT_PRUNE_CONFIG, pruneToolOutputs } from "./compaction/pruning";
 import {
 	type BashExecutionMessage,
 	type CompactionSummaryMessage,
@@ -334,6 +334,17 @@ export interface PromptOptions {
 	skipCompactionCheck?: boolean;
 }
 
+/** Result from a handoff operation. */
+export interface HandoffResult {
+	document: string;
+	savedPath?: string;
+}
+
+export interface SessionHandoffOptions {
+	autoTriggered?: boolean;
+	signal?: AbortSignal;
+}
+
 /** Result from cycleModel() */
 export interface ModelCycleResult {
 	model: Model;
@@ -369,17 +380,6 @@ export interface SessionStats {
 	cost: number;
 }
 
-/** Result from handoff() */
-export interface HandoffResult {
-	document: string;
-	savedPath?: string;
-}
-
-interface HandoffOptions {
-	autoTriggered?: boolean;
-	signal?: AbortSignal;
-}
-
 /** Internal marker for hook messages queued through the agent loop */
 // ============================================================================
 // Constants
@@ -387,8 +387,6 @@ interface HandoffOptions {
 
 /** Standard thinking levels */
 
-const AUTO_HANDOFF_THRESHOLD_FOCUS = prompt.render(autoHandoffThresholdFocusPrompt);
-
 type RetryFallbackChains = Record<string, string[]>;
 
 type RetryFallbackRevertPolicy = "never" | "cooldown-expiry";
@@ -512,6 +510,15 @@ const noOpUIContext: ExtensionUIContext = {
 	setToolsExpanded: () => {},
 };
 
+function createHandoffContext(document: string): string {
+	return `<handoff-context>\n${document}\n</handoff-context>\n\nThe above is a handoff document from a previous session. Use this context to continue the work seamlessly.`;
+}
+
+function createHandoffFileName(date = new Date()): string {
+	const fileTimestamp = date.toISOString().replace(/[:.]/g, "-");
+	return `handoff-${fileTimestamp}.md`;
+}
+
 // ============================================================================
 // ACP Permission Gate
 // ============================================================================
@@ -4999,6 +5006,7 @@ export class AgentSession {
 							promptOverride: compactionPrep.hookPrompt,
 							extraContext: compactionPrep.hookContext,
 							remoteInstructions: this.#baseSystemPrompt.join("\n\n"),
+							convertToLlm,
 						},
 					);
 					summary = result.summary;
@@ -5135,16 +5143,13 @@ export class AgentSession {
 	}
 
 	/**
-	 * Generate a handoff document by asking the agent, then start a new session with it.
-	 *
-	 * This prompts the current agent to write a comprehensive handoff document,
-	 * waits for completion, then starts a fresh session with the handoff as context.
+	 * Generate a handoff document with a oneshot LLM call, then start a new session with it.
 	 *
 	 * @param customInstructions Optional focus for the handoff document
 	 * @param options Handoff execution options
 	 * @returns The handoff document text, or undefined if cancelled/failed
 	 */
-	async handoff(customInstructions?: string, options?: HandoffOptions): Promise<HandoffResult | undefined> {
+	async handoff(customInstructions?: string, options?: SessionHandoffOptions): Promise<HandoffResult | undefined> {
 		const entries = this.sessionManager.getBranch();
 		const messageCount = entries.filter(e => e.type === "message").length;
 
@@ -5158,10 +5163,6 @@ export class AgentSession {
 		const handoffAbortController = this.#handoffAbortController;
 		const handoffSignal = handoffAbortController.signal;
 		const sourceSignal = options?.signal;
-		const onHandoffAbort = () => {
-			this.agent.abort();
-		};
-		handoffSignal.addEventListener("abort", onHandoffAbort, { once: true });
 		const onSourceAbort = () => {
 			if (!handoffSignal.aborted) {
 				handoffAbortController.abort();
@@ -5174,71 +5175,36 @@ export class AgentSession {
 			}
 		}
 
-		// Build the handoff prompt
-		const handoffPrompt = prompt.render(handoffDocumentPrompt, {
-			additionalFocus: customInstructions,
-		});
-
-		// Create a promise that resolves when the agent completes
-		let handoffText: string | undefined;
-		const { promise: completionPromise, resolve: resolveCompletion } = Promise.withResolvers<void>();
-		let handoffCancelled = false;
-		let unsubscribe: (() => void) | undefined;
-		const onCompletionAbort = () => {
-			unsubscribe?.();
-			handoffCancelled = true;
-			resolveCompletion();
-		};
-		if (handoffSignal.aborted) {
-			onCompletionAbort();
-		} else {
-			handoffSignal.addEventListener("abort", onCompletionAbort, { once: true });
-		}
-		unsubscribe = this.subscribe(event => {
-			if (event.type === "agent_end") {
-				unsubscribe?.();
-				handoffSignal.removeEventListener("abort", onCompletionAbort);
-				// Extract text from the last assistant message
-				const messages = this.agent.state.messages;
-				for (let i = messages.length - 1; i >= 0; i--) {
-					const msg = messages[i];
-					if (msg.role === "assistant") {
-						const content = (msg as AssistantMessage).content;
-						const textParts = content
-							.filter((c): c is { type: "text"; text: string } => c.type === "text")
-							.map(c => c.text);
-						if (textParts.length > 0) {
-							handoffText = textParts.join("\n");
-							break;
-						}
-					}
-				}
-				resolveCompletion();
-			}
-		});
-
 		try {
-			// Send the prompt and wait for completion
 			if (handoffSignal.aborted) {
 				throw new Error("Handoff cancelled");
 			}
-			this.#beginInFlight();
-			try {
-				this.agent.setSystemPrompt(this.#baseSystemPrompt);
-				await this.#promptAgentWithIdleRetry([
-					{
-						role: "developer",
-						content: [{ type: "text", text: handoffPrompt }],
-						attribution: "agent",
-						timestamp: Date.now(),
-					},
-				]);
-			} finally {
-				this.#endInFlight();
+
+			const model = this.model;
+			if (!model) {
+				throw new Error("No model selected for handoff");
 			}
-			await completionPromise;
+			const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
+			if (!apiKey) {
+				throw new Error(`No API key for ${model.provider}`);
+			}
+
+			const handoffText = await generateHandoff(
+				this.agent.state.messages,
+				model,
+				apiKey,
+				{
+					systemPrompt: this.#baseSystemPrompt,
+					tools: this.agent.state.tools,
+					customInstructions,
+					convertToLlm,
+					initiatorOverride: "agent",
+					metadata: this.agent.metadataForProvider(model.provider),
+				},
+				handoffSignal,
+			);
 
-			if (handoffCancelled || handoffSignal.aborted) {
+			if (handoffSignal.aborted) {
 				throw new Error("Handoff cancelled");
 			}
 			if (!handoffText) {
@@ -5261,15 +5227,14 @@ export class AgentSession {
 			this.#todoReminderCount = 0;
 
 			// Inject the handoff document as a custom message
-			const handoffContent = `<handoff-context>\n${handoffText}\n</handoff-context>\n\nThe above is a handoff document from a previous session. Use this context to continue the work seamlessly.`;
+			const handoffContent = createHandoffContext(handoffText);
 			this.sessionManager.appendCustomMessageEntry("handoff", handoffContent, true, undefined, "agent");
 			await this.sessionManager.ensureOnDisk();
 			let savedPath: string | undefined;
 			if (options?.autoTriggered && this.settings.get("compaction.handoffSaveToDisk")) {
 				const artifactsDir = this.sessionManager.getArtifactsDir();
 				if (artifactsDir) {
-					const fileTimestamp = new Date().toISOString().replace(/[:.]/g, "-");
-					const handoffFilePath = path.join(artifactsDir, `handoff-${fileTimestamp}.md`);
+					const handoffFilePath = path.join(artifactsDir, createHandoffFileName());
 					try {
 						await Bun.write(handoffFilePath, `${handoffText}\n`);
 						savedPath = handoffFilePath;
@@ -5290,10 +5255,12 @@ export class AgentSession {
 			this.#syncTodoPhasesFromBranch();
 
 			return { document: handoffText, savedPath };
+		} catch (error) {
+			if (handoffSignal.aborted || (error instanceof Error && error.name === "AbortError")) {
+				throw new Error("Handoff cancelled");
+			}
+			throw error;
 		} finally {
-			unsubscribe?.();
-			handoffSignal.removeEventListener("abort", onCompletionAbort);
-			handoffSignal.removeEventListener("abort", onHandoffAbort);
 			sourceSignal?.removeEventListener("abort", onSourceAbort);
 			this.#handoffAbortController = undefined;
 		}
@@ -5954,6 +5921,7 @@ export class AgentSession {
 				return await compact(preparation, candidate, apiKey, customInstructions, signal, {
 					...options,
 					metadata: this.agent.metadataForProvider(candidate.provider),
+					convertToLlm,
 				});
 			} catch (error) {
 				if (!this.#isCompactionAuthFailure(error)) {
@@ -6206,6 +6174,7 @@ export class AgentSession {
 								remoteInstructions: this.#baseSystemPrompt.join("\n\n"),
 								metadata: this.agent.metadataForProvider(candidate.provider),
 								initiatorOverride: "agent",
+								convertToLlm,
 							});
 							break;
 						} catch (error) {
@@ -7809,6 +7778,7 @@ export class AgentSession {
 				customInstructions: options.customInstructions,
 				reserveTokens: branchSummarySettings.reserveTokens,
 				metadata: this.agent.metadataForProvider(model.provider),
+				convertToLlm,
 			});
 			this.#branchSummaryAbortController = undefined;
 			if (result.aborted) {

package/src/session/messages.ts

@@ -5,24 +5,31 @@
  * and provides a transformer to convert them to LLM-compatible messages.
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import {
+	type BranchSummaryMessage,
+	type CompactionSummaryMessage,
+	renderBranchSummaryContext,
+	renderCompactionSummaryContext,
+} from "@oh-my-pi/pi-agent-core/compaction/messages";
 import type {
 	AssistantMessage,
 	ImageContent,
 	Message,
 	MessageAttribution,
-	ProviderPayload,
 	TextContent,
 	ToolResultMessage,
 } from "@oh-my-pi/pi-ai";
-import { prompt } from "@oh-my-pi/pi-utils";
-import branchSummaryContextPrompt from "../prompts/compaction/branch-summary-context.md" with { type: "text" };
-import compactionSummaryContextPrompt from "../prompts/compaction/compaction-summary-context.md" with { type: "text" };
+
+export {
+	type BranchSummaryMessage,
+	type CompactionSummaryMessage,
+	createBranchSummaryMessage,
+	createCompactionSummaryMessage,
+} from "@oh-my-pi/pi-agent-core/compaction/messages";
+
 import type { OutputMeta } from "../tools/output-meta";
 import { formatOutputNotice } from "../tools/output-meta";
 
-const COMPACTION_SUMMARY_TEMPLATE = compactionSummaryContextPrompt;
-const BRANCH_SUMMARY_TEMPLATE = branchSummaryContextPrompt;
-
 export const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
 
 export interface SkillPromptDetails {
@@ -168,22 +175,6 @@ export interface HookMessage<T = unknown> {
 	timestamp: number;
 }
 
-export interface BranchSummaryMessage {
-	role: "branchSummary";
-	summary: string;
-	fromId: string;
-	timestamp: number;
-}
-
-export interface CompactionSummaryMessage {
-	role: "compactionSummary";
-	summary: string;
-	shortSummary?: string;
-	tokensBefore: number;
-	providerPayload?: ProviderPayload;
-	timestamp: number;
-}
-
 /**
  * Message type for auto-read file mentions via @filepath syntax.
  */
@@ -254,32 +245,6 @@ export function pythonExecutionToText(msg: PythonExecutionMessage): string {
 	return text;
 }
 
-export function createBranchSummaryMessage(summary: string, fromId: string, timestamp: string): BranchSummaryMessage {
-	return {
-		role: "branchSummary",
-		summary,
-		fromId,
-		timestamp: new Date(timestamp).getTime(),
-	};
-}
-
-export function createCompactionSummaryMessage(
-	summary: string,
-	tokensBefore: number,
-	timestamp: string,
-	shortSummary?: string,
-	providerPayload?: ProviderPayload,
-): CompactionSummaryMessage {
-	return {
-		role: "compactionSummary",
-		summary,
-		shortSummary,
-		tokensBefore,
-		providerPayload,
-		timestamp: new Date(timestamp).getTime(),
-	};
-}
-
 export function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: AssistantMessage): AssistantMessage {
 	if (message.providerPayload?.type !== "openaiResponsesHistory") {
 		return message;
@@ -376,7 +341,7 @@ export function convertToLlm(messages: AgentMessage[]): Message[] {
 						content: [
 							{
 								type: "text" as const,
-								text: prompt.render(BRANCH_SUMMARY_TEMPLATE, { summary: m.summary }),
+								text: renderBranchSummaryContext(m.summary),
 							},
 						],
 						attribution: "agent",
@@ -388,7 +353,7 @@ export function convertToLlm(messages: AgentMessage[]): Message[] {
 						content: [
 							{
 								type: "text" as const,
-								text: prompt.render(COMPACTION_SUMMARY_TEMPLATE, { summary: m.summary }),
+								text: renderCompactionSummaryContext(m.summary),
 							},
 						],
 						attribution: "agent",

package/src/session/session-manager.ts

@@ -1351,6 +1351,11 @@ class NdjsonFileWriter {
 	getError(): Error | undefined {
 		return this.#error;
 	}
+
+	/** True while the writer accepts new writes (not closing or closed). */
+	isOpen(): boolean {
+		return !this.#closed && !this.#closing;
+	}
 }
 
 /** Get recent sessions for display in welcome screen */
@@ -2106,7 +2111,15 @@ export class SessionManager {
 	#ensurePersistWriter(): NdjsonFileWriter | undefined {
 		if (!this.persist || !this.#sessionFile) return undefined;
 		if (this.#persistError) throw this.#persistError;
-		if (this.#persistWriter && this.#persistWriterPath === this.#sessionFile) return this.#persistWriter;
+		if (this.#persistWriter && this.#persistWriterPath === this.#sessionFile) {
+			if (this.#persistWriter.isOpen()) return this.#persistWriter;
+			// Cached writer for the current file is mid-close (queued
+			// `#closePersistWriterInternal` has flipped `#closing` but not yet
+			// cleared `#persistWriter`). Returning it would make `writeSync`
+			// throw "Writer closed". Defer to the caller — `_persist` routes
+			// the entry through the async rewrite path so it still lands on disk.
+			return undefined;
+		}
 		// Note: caller must await _closePersistWriter() before calling this if switching files
 		this.#persistWriter = new NdjsonFileWriter(this.storage, this.#sessionFile, {
 			onError: err => {
@@ -2457,7 +2470,14 @@ export class SessionManager {
 		// line referencing them is written.
 		try {
 			const writer = this.#ensurePersistWriter();
-			if (!writer) return;
+			if (!writer) {
+				// `#ensurePersistWriter` returns undefined here only when the cached
+				// writer is mid-close (the `!persist`/`!sessionFile` cases are
+				// rejected above). Route through `#rewriteFile` so the entry — which
+				// is already in `#fileEntries` — persists once the close drains.
+				this.#rewriteFile().catch(() => {});
+				return;
+			}
 			const persistedEntry = prepareEntryForPersistenceSync(entry, this.#blobStore);
 			writer.writeSync(persistedEntry);
 		} catch (err) {

package/src/session/streaming-output.ts

@@ -644,6 +644,7 @@ export class OutputSink {
 	#head = "";
 	#headBytes = 0;
 	#headLines = 0; // newline count inside #head
+	#headRetentionDisabled = false;
 	#totalLines = 0; // newline count
 	#totalBytes = 0;
 	#sawData = false;
@@ -740,7 +741,7 @@ export class OutputSink {
 		// exhausted, then forward any leftover to the tail buffer.
 		let tailChunk = capped;
 		let tailBytes = cappedBytes;
-		if (this.#headLimit > 0 && this.#headBytes < this.#headLimit) {
+		if (this.#headLimit > 0 && !this.#headRetentionDisabled && this.#headBytes < this.#headLimit) {
 			const room = this.#headLimit - this.#headBytes;
 			if (cappedBytes <= room) {
 				this.#head += capped;
@@ -919,12 +920,16 @@ export class OutputSink {
 	}
 
 	/**
-	 * Replace the in-memory buffer with the given text while preserving the
-	 * streaming counters (totalLines/totalBytes reflect the raw chunks that
-	 * already reached the sink). Used when an upstream minimizer rewrites the
-	 * captured output after the raw bytes have already been streamed.
+	 * Replace the in-memory buffer with the given text. Used when an upstream
+	 * minimizer rewrites the captured output after the raw bytes have already
+	 * been streamed.
 	 *
-	 * Clears any retained head window — the minimized text is authoritative.
+	 * After this call the buffer is authoritative: streaming counters realign
+	 * to the replacement, the retained head window is cleared, and head
+	 * retention is disabled so subsequent `push()` calls append directly to the
+	 * tail buffer instead of repopulating the (now meaningless) head window
+	 * — which would otherwise reorder content and trip the middle-elision
+	 * branch in `dump()` against stale totals.
 	 */
 	replace(text: string): void {
 		this.#buffer = text;
@@ -932,6 +937,11 @@ export class OutputSink {
 		this.#head = "";
 		this.#headBytes = 0;
 		this.#headLines = 0;
+		this.#headRetentionDisabled = true;
+		this.#totalBytes = this.#bufferBytes;
+		this.#totalLines = countNewlines(text);
+		this.#sawData = text.length > 0;
+		this.#truncated = false;
 		this.#currentLineBytes = 0;
 		this.#columnEllipsisAdded = false;
 		this.#columnDroppedBytes = 0;