@oh-my-pi/pi-coding-agent 15.10.11 → 15.11.0

package/src/session/messages.ts

@@ -8,8 +8,7 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import {
 	type BranchSummaryMessage,
 	type CompactionSummaryMessage,
-	renderBranchSummaryContext,
-	renderCompactionSummaryContext,
+	convertMessageToLlm,
 } from "@oh-my-pi/pi-agent-core/compaction/messages";
 import type {
 	AssistantMessage,
@@ -17,7 +16,6 @@ import type {
 	Message,
 	MessageAttribution,
 	TextContent,
-	ToolResultMessage,
 	UserMessage,
 } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
@@ -28,6 +26,7 @@ export {
 	type CompactionSummaryMessage,
 	createBranchSummaryMessage,
 	createCompactionSummaryMessage,
+	createCustomMessage,
 } from "@oh-my-pi/pi-agent-core/compaction/messages";
 
 import type { OutputMeta } from "../tools/output-meta";
@@ -59,7 +58,7 @@ export interface SkillPromptDetails {
  *
  *  Consumers: `AgentSession.#handleAgentEvent` (stamper) writes this value;
  *  `EventController.#handleMessageEnd`, `AssistantMessageComponent`,
- *  `ui-helpers.addMessageToChat` (renderers), `SessionObserverOverlay
+ *  `ui-helpers.addMessageToChat` (renderers), `AgentHubOverlayComponent
  *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
  *  (fallback error emission) read it via `isSilentAbort`. */
 export const SILENT_ABORT_MARKER = "__omp.silent_abort__";
@@ -220,15 +219,6 @@ export function wrapSteeringForModel(messages: AgentMessage[]): AgentMessage[] {
 	return wrappedMessages ?? messages;
 }
 
-function getPrunedToolResultContent(message: ToolResultMessage): (TextContent | ImageContent)[] {
-	if (message.prunedAt === undefined) {
-		return message.content;
-	}
-	const textBlocks = message.content.filter((content): content is TextContent => content.type === "text");
-	const text = textBlocks.map(block => block.text).join("") || "[Output truncated]";
-	return [{ type: "text", text }];
-}
-
 /** Result of filtering image blocks out of a `(TextContent | ImageContent)[]` array. */
 interface StripContentResult {
 	content: (TextContent | ImageContent)[];
@@ -478,26 +468,6 @@ export function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: Assis
 	};
 }
 
-/** Convert CustomMessageEntry to AgentMessage format */
-export function createCustomMessage(
-	customType: string,
-	content: string | (TextContent | ImageContent)[],
-	display: boolean,
-	details: unknown | undefined,
-	timestamp: string,
-	attribution?: MessageAttribution,
-): CustomMessage {
-	return {
-		role: "custom",
-		customType,
-		content,
-		display,
-		details,
-		attribution,
-		timestamp: new Date(timestamp).getTime(),
-	};
-}
-
 /**
  * Transform AgentMessages (including custom types) to LLM-compatible Messages.
  *
@@ -530,43 +500,6 @@ export function convertToLlm(messages: AgentMessage[]): Message[] {
 						attribution: "user",
 						timestamp: m.timestamp,
 					};
-				case "custom":
-				case "hookMessage": {
-					const content = typeof m.content === "string" ? [{ type: "text" as const, text: m.content }] : m.content;
-					const role = "developer";
-					const attribution = m.attribution;
-					return {
-						role,
-						content,
-						attribution,
-						timestamp: m.timestamp,
-					};
-				}
-				case "branchSummary":
-					return {
-						role: "user",
-						content: [
-							{
-								type: "text" as const,
-								text: renderBranchSummaryContext(m.summary),
-							},
-						],
-						attribution: "agent",
-						timestamp: m.timestamp,
-					};
-				case "compactionSummary":
-					return {
-						role: "user",
-						content: [
-							{
-								type: "text" as const,
-								text: renderCompactionSummaryContext(m.summary),
-							},
-						],
-						attribution: "agent",
-						providerPayload: m.providerPayload,
-						timestamp: m.timestamp,
-					};
 				case "fileMention": {
 					const fileContents = m.files
 						.map(file => {
@@ -587,18 +520,18 @@ export function convertToLlm(messages: AgentMessage[]): Message[] {
 						timestamp: m.timestamp,
 					};
 				}
+				case "custom":
+				case "hookMessage":
+				case "branchSummary":
+				case "compactionSummary":
 				case "user":
-					return { ...m, attribution: m.attribution ?? "user" };
 				case "developer":
-					return { ...m, attribution: m.attribution ?? "agent" };
 				case "assistant":
-					return m;
 				case "toolResult":
-					return {
-						...m,
-						content: getPrunedToolResultContent(m as ToolResultMessage),
-						attribution: m.attribution ?? "agent",
-					};
+					// Core roles share one transformer with agent-core —
+					// duplicating them here is how snapcompact frames once
+					// silently fell off the provider request.
+					return convertMessageToLlm(m);
 				default:
 					m satisfies never;
 					return undefined;

package/src/session/session-history-format.ts

@@ -0,0 +1,246 @@
+/**
+ * Concise markdown transcript serializer for `history://` URLs.
+ *
+ * Unlike `session-dump-format.ts` (verbose `/dump` export), this emits a
+ * compressed transcript: full user/assistant/developer text, tool call +
+ * result pairs collapsed to single lines, thinking elided, custom messages
+ * as one-liners. No system prompt, no tool catalog, no config sections.
+ */
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage, ImageContent, TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import type {
+	BashExecutionMessage,
+	BranchSummaryMessage,
+	CompactionSummaryMessage,
+	CustomMessage,
+	FileMentionMessage,
+	HookMessage,
+	PythonExecutionMessage,
+} from "./messages";
+
+export interface HistoryFormatOptions {
+	/** Optional H1 prepended to the transcript. */
+	title?: string;
+}
+
+/** Max length of the primary-arg summary inside `→ tool(...)` lines. */
+const PRIMARY_ARG_MAX = 120;
+
+/** Per-tool preference order for the most informative scalar argument. */
+const PRIMARY_ARG_KEYS = [
+	"path",
+	"file_path",
+	"filePath",
+	"command",
+	"cmd",
+	"pattern",
+	"url",
+	"query",
+	"prompt",
+	"assignment",
+	"message",
+	"op",
+	"name",
+	"id",
+] as const;
+
+/** Collapse whitespace runs and truncate to `max` chars with an ellipsis. */
+function oneLine(text: string, max = PRIMARY_ARG_MAX): string {
+	const flat = text.replace(/\s+/g, " ").trim();
+	return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+
+/** Join the text blocks of a string-or-blocks content field. Images become `[image]`. */
+function contentToText(content: string | readonly (TextContent | ImageContent)[]): string {
+	if (typeof content === "string") return content;
+	const parts: string[] = [];
+	for (const block of content) {
+		if (block.type === "text") parts.push(block.text);
+		else parts.push("[image]");
+	}
+	return parts.join("\n");
+}
+
+function lineCount(text: string): number {
+	if (!text) return 0;
+	return text.split("\n").length;
+}
+
+/** Pick the most informative scalar argument of a tool call. */
+function primaryArg(args: Record<string, unknown> | undefined): string {
+	if (!args || typeof args !== "object") return "";
+	for (const key of PRIMARY_ARG_KEYS) {
+		const value = args[key];
+		if (typeof value === "string" && value.length > 0) return oneLine(value);
+		if (Array.isArray(value) && value.length > 0 && value.every(v => typeof v === "string")) {
+			return oneLine(value.join(", "));
+		}
+	}
+	// Fallback: first non-intent string arg, then a compact JSON of the args.
+	const rest: Record<string, unknown> = {};
+	let restCount = 0;
+	for (const key in args) {
+		if (key === INTENT_FIELD) continue;
+		const value = args[key];
+		if (typeof value === "string" && value.length > 0) return oneLine(value);
+		rest[key] = value;
+		restCount++;
+	}
+	if (restCount === 0) return "";
+	try {
+		return oneLine(JSON.stringify(rest));
+	} catch {
+		return "";
+	}
+}
+
+/** One line per tool call: `→ read(src/foo.ts:50-80) ⇒ ok · 31 lines`. */
+function toolCallLine(
+	name: string,
+	args: Record<string, unknown> | undefined,
+	result: ToolResultMessage | undefined,
+): string {
+	const head = `→ ${name}(${primaryArg(args)})`;
+	if (!result) return `${head} ⇒ pending`;
+	const text = contentToText(result.content);
+	const lines = lineCount(text);
+	const count = `${lines} ${lines === 1 ? "line" : "lines"}`;
+	if (result.isError) {
+		const firstLine = oneLine(text.split("\n", 1)[0] ?? "");
+		return firstLine ? `${head} ⇒ error · ${count} — ${firstLine}` : `${head} ⇒ error · ${count}`;
+	}
+	return `${head} ⇒ ok · ${count}`;
+}
+
+/** One line for a user-initiated `!`/`$` execution. */
+function executionLine(
+	kind: "bash" | "python",
+	source: string,
+	msg: BashExecutionMessage | PythonExecutionMessage,
+): string {
+	const status = msg.cancelled
+		? "cancelled"
+		: msg.exitCode !== undefined && msg.exitCode !== 0
+			? `error · exit ${msg.exitCode}`
+			: "ok";
+	const lines = lineCount(msg.output);
+	return `→ ${kind}! ${oneLine(source)} ⇒ ${status} · ${lines} ${lines === 1 ? "line" : "lines"}`;
+}
+
+/** One-liner for custom/hook messages: `[irc] A → B: body…`. */
+function customOneLiner(msg: CustomMessage | HookMessage): string {
+	const details = (msg.details ?? {}) as Record<string, unknown>;
+	const str = (key: string): string => (typeof details[key] === "string" ? (details[key] as string) : "");
+	switch (msg.customType) {
+		case "irc:incoming":
+			return `[irc] ${str("from") || "?"} → me: ${oneLine(str("message"))}`;
+		case "irc:relay":
+			return `[irc] ${str("from") || "?"} → ${str("to") || "?"}: ${oneLine(str("body"))}`;
+		case "async-result": {
+			const jobs = Array.isArray(details.jobs) && details.jobs.length > 0 ? details.jobs : [details];
+			const labels = jobs
+				.map(job => {
+					const j = (job ?? {}) as Record<string, unknown>;
+					return typeof j.label === "string" && j.label ? j.label : typeof j.jobId === "string" ? j.jobId : "job";
+				})
+				.join(", ");
+			return `[async-result] ${oneLine(labels)}`;
+		}
+		default:
+			return `[${msg.customType}] ${oneLine(contentToText(msg.content))}`;
+	}
+}
+
+/**
+ * Format a session's message array as a concise markdown transcript.
+ *
+ * `messages` is the session's in-memory message array (or the read-only
+ * equivalent loaded from a session file) — the same shapes
+ * `session-dump-format.ts` consumes.
+ */
+export function formatSessionHistoryMarkdown(messages: unknown[], opts?: HistoryFormatOptions): string {
+	const typed = messages as AgentMessage[];
+	const lines: string[] = [];
+	if (opts?.title) {
+		lines.push(`# ${opts.title}`, "");
+	}
+
+	// Index tool results by call id so each toolCall collapses to one line.
+	const resultsByCallId = new Map<string, ToolResultMessage>();
+	for (const msg of typed) {
+		if (msg.role === "toolResult") {
+			resultsByCallId.set(msg.toolCallId, msg);
+		}
+	}
+	const consumed = new Set<string>();
+
+	for (const msg of typed) {
+		switch (msg.role) {
+			case "user":
+			case "developer": {
+				const text = contentToText(msg.content);
+				if (!text.trim()) break;
+				lines.push(`## ${msg.role}`, "", text, "");
+				break;
+			}
+			case "assistant": {
+				const assistantMsg = msg as AssistantMessage;
+				const body: string[] = [];
+				for (const block of assistantMsg.content) {
+					if (block.type === "text") {
+						if (block.text.trim()) body.push(block.text);
+					} else if (block.type === "toolCall") {
+						const result = resultsByCallId.get(block.id);
+						if (result) consumed.add(block.id);
+						body.push(toolCallLine(block.name, block.arguments, result));
+					}
+					// thinking / redactedThinking elided entirely
+				}
+				if (body.length === 0) break;
+				lines.push("## assistant", "", ...body, "");
+				break;
+			}
+			case "toolResult": {
+				// Normally consumed by its toolCall; orphans (e.g. truncated history) get their own line.
+				if (consumed.has(msg.toolCallId)) break;
+				lines.push(toolCallLine(msg.toolName, undefined, msg), "");
+				break;
+			}
+			case "bashExecution": {
+				const bashMsg = msg as BashExecutionMessage;
+				if (bashMsg.excludeFromContext) break;
+				lines.push(executionLine("bash", bashMsg.command, bashMsg), "");
+				break;
+			}
+			case "pythonExecution": {
+				const pythonMsg = msg as PythonExecutionMessage;
+				if (pythonMsg.excludeFromContext) break;
+				lines.push(executionLine("python", pythonMsg.code, pythonMsg), "");
+				break;
+			}
+			case "custom":
+			case "hookMessage": {
+				lines.push(customOneLiner(msg as CustomMessage | HookMessage), "");
+				break;
+			}
+			case "branchSummary": {
+				const branchMsg = msg as BranchSummaryMessage;
+				lines.push(`[branch] from ${branchMsg.fromId}: ${oneLine(branchMsg.summary)}`, "");
+				break;
+			}
+			case "compactionSummary": {
+				const compactMsg = msg as CompactionSummaryMessage;
+				lines.push(`[compaction] ${oneLine(compactMsg.summary)}`, "");
+				break;
+			}
+			case "fileMention": {
+				const fileMsg = msg as FileMentionMessage;
+				lines.push(`[file-mention] ${oneLine(fileMsg.files.map(f => f.path).join(", "))}`, "");
+				break;
+			}
+		}
+	}
+
+	return `${lines.join("\n").trim()}\n`;
+}

package/src/session/session-manager.ts

@@ -27,6 +27,7 @@ import {
 	Snowflake,
 	toError,
 } from "@oh-my-pi/pi-utils";
+import { getPreservedSnapcompactArchive, snapcompactImages } from "@oh-my-pi/snapcompact";
 import { ArtifactManager } from "./artifacts";
 import {
 	type BlobPutOptions,
@@ -544,6 +545,17 @@ export function getLatestCompactionEntry(entries: SessionEntry[]): CompactionEnt
 	return null;
 }
 
+export interface BuildSessionContextOptions {
+	/**
+	 * Build the full-history display transcript instead of the LLM context:
+	 * every path entry in chronological order, with each compaction emitted
+	 * inline as a `compactionSummary` message at the position it fired rather
+	 * than replacing the history before it. Display-only — never send the
+	 * result to a provider.
+	 */
+	transcript?: boolean;
+}
+
 /**
  * Build the session context from entries using tree traversal.
  * If leafId is provided, walks from that entry to root.
@@ -553,6 +565,7 @@ export function buildSessionContext(
 	entries: SessionEntry[],
 	leafId?: string | null,
 	byId?: Map<string, SessionEntry>,
+	options?: BuildSessionContextOptions,
 ): SessionContext {
 	// Build uuid index if not available
 	if (!byId) {
@@ -692,7 +705,29 @@ export function buildSessionContext(
 		}
 	};
 
-	if (compaction) {
+	if (options?.transcript) {
+		// Display transcript: every entry in chronological order. Compactions do
+		// not erase prior history here — each renders inline (as a divider in the
+		// TUI) at the point it fired, with any snapcompact frames re-attached so
+		// the component can report them.
+		for (const entry of path) {
+			if (entry.type === "compaction") {
+				const snapcompactArchive = getPreservedSnapcompactArchive(entry.preserveData);
+				messages.push(
+					createCompactionSummaryMessage(
+						entry.summary,
+						entry.tokensBefore,
+						entry.timestamp,
+						entry.shortSummary,
+						undefined,
+						snapcompactArchive ? snapcompactImages(snapcompactArchive) : undefined,
+					),
+				);
+			} else {
+				appendMessage(entry);
+			}
+		}
+	} else if (compaction) {
 		const providerPayload: ProviderPayload | undefined = (() => {
 			const candidate = compaction.preserveData?.openaiRemoteCompaction;
 			if (!candidate || typeof candidate !== "object") return undefined;
@@ -707,7 +742,9 @@ export function buildSessionContext(
 		})();
 		const remoteReplacementHistory = providerPayload?.items;
 
-		// Emit summary first
+		// Emit summary first; re-attach any archived snapcompact frames so the
+		// model can keep reading the archived history after every context rebuild.
+		const snapcompactArchive = getPreservedSnapcompactArchive(compaction.preserveData);
 		messages.push(
 			createCompactionSummaryMessage(
 				compaction.summary,
@@ -715,6 +752,7 @@ export function buildSessionContext(
 				compaction.timestamp,
 				compaction.shortSummary,
 				providerPayload,
+				snapcompactArchive ? snapcompactImages(snapcompactArchive) : undefined,
 			),
 		);
 
@@ -957,6 +995,21 @@ async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobSto
 	await Promise.all(promises);
 }
 
+/**
+ * Read-only message view of a session file: load entries, migrate to the
+ * current version, resolve blob refs, and build the context along the
+ * persisted leaf path (last entry). Does NOT create a writer or take the
+ * session lock — safe to call against a file another session is writing.
+ */
+export async function loadSessionMessagesReadOnly(filePath: string): Promise<AgentMessage[]> {
+	const entries = await loadEntriesFromFile(filePath);
+	if (entries.length === 0) return [];
+	migrateToCurrentVersion(entries);
+	await resolveBlobRefsInEntries(entries, new BlobStore(getBlobsDir()));
+	const sessionEntries = entries.filter((e): e is SessionEntry => e.type !== "session");
+	return buildSessionContext(sessionEntries).messages;
+}
+
 /**
  * Lightweight metadata for a session file, used in session picker UI.
  * Uses lazy getters to defer string formatting until actually displayed.
@@ -3205,11 +3258,12 @@ export class SessionManager {
 	}
 
 	/**
-	 * Build the session context (what gets sent to the LLM).
+	 * Build the session context (what gets sent to the LLM), or — with
+	 * `{ transcript: true }` — the full-history display transcript.
 	 * Uses tree traversal from current leaf.
 	 */
-	buildSessionContext(): SessionContext {
-		return buildSessionContext(this.getEntries(), this.#leafId, this.#byId);
+	buildSessionContext(options?: BuildSessionContextOptions): SessionContext {
+		return buildSessionContext(this.getEntries(), this.#leafId, this.#byId, options);
 	}
 
 	/** Strip stale OpenAI Responses assistant replay metadata from loaded in-memory entries. */