@giladbarnea/pi-user-agents 0.0.3 → 0.0.5

package/rebase.ts

@@ -0,0 +1,56 @@
+import { buildSessionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentMessage, ExtensionCommandContext } from "./shared.js";
+import { MESSAGE_TYPE } from "./shared.js";
+
+type MainSessionManager = ExtensionCommandContext["sessionManager"];
+
+/**
+ * Fingerprint a context snapshot for the rebase fast-forward precondition: the main session's
+ * live context must still fingerprint-equal the base the child was dispatched from.
+ *
+ * @example conversationFingerprint([]) === conversationFingerprint([]) // true
+ */
+export function conversationFingerprint(messages: readonly AgentMessage[]): string {
+	return JSON.stringify(messages);
+}
+
+/** Rebuilding a session-sized context string is only worth doing when the branch tip moved. */
+const contextFingerprintCache = new WeakMap<object, { leafId: string | null; fingerprint: string }>();
+
+/** Fingerprint of the main session's current LLM context, cached by branch leaf. */
+export function mainContextFingerprint(sessionManager: MainSessionManager): string {
+	const leafId = sessionManager.getLeafId();
+	const cached = contextFingerprintCache.get(sessionManager);
+	if (cached && cached.leafId === leafId) return cached.fingerprint;
+	const fingerprint = conversationFingerprint(
+		buildSessionContext(sessionManager.getBranch()).messages,
+	);
+	contextFingerprintCache.set(sessionManager, { leafId, fingerprint });
+	return fingerprint;
+}
+
+/**
+ * Select the child conversation messages to rebase onto the main session, so the record reads
+ * as if the user prompted the main session directly. The child's history passes through
+ * verbatim — compactions included, so main inherits the child's context boundary — except the
+ * first user message, which carries the extension's internal background-process prefix and is
+ * replaced by the plain task, and this extension's own custom messages, which are the one
+ * trace of the user-agents machinery.
+ */
+export function selectRebaseMessages(
+	task: string,
+	messages: readonly AgentMessage[],
+): AgentMessage[] {
+	let firstUserMessage = true;
+	const selected: AgentMessage[] = [];
+	for (const message of messages) {
+		if (message.role === "custom" && message.customType === MESSAGE_TYPE) continue;
+		if (message.role === "user" && firstUserMessage) {
+			firstUserMessage = false;
+			selected.push({ ...message, content: task });
+			continue;
+		}
+		selected.push(message);
+	}
+	return selected;
+}

package/runner.ts

@@ -5,29 +5,41 @@ import {
 	type AgentSessionServices,
 	type Args,
 	buildSessionContext,
+	estimateTokens,
 	createAgentSessionFromServices,
 	createAgentSessionServices,
 	getAgentDir,
 	type ModelRuntime,
 	parseArgs,
 	resolveCliModel,
+	sessionEntryToContextMessages,
 	SessionManager,
 	SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 import { type AgentValueValidator, parseAgentCommand } from "./command-line.js";
+import { conversationFingerprint, mainContextFingerprint } from "./rebase.js";
 import type {
 	AgentCommandName,
 	AgentMessage,
 	AgentResultMessage,
 	AgentSession,
+	ChildCompactionMessage,
 	ExtensionAPI,
 	ExtensionCommandContext,
 	Model,
 	ParsedAgentCommand,
+	RebaseDelivery,
+	RebasedEntryData,
 	RunningAgent,
 	ThinkingLevel,
 } from "./shared.js";
-import { errorMessage, formatModel, formatModelLabel, logSteering } from "./shared.js";
+import {
+	errorMessage,
+	formatModel,
+	formatModelLabel,
+	logSteering,
+	REBASED_ENTRY_TYPE,
+} from "./shared.js";
 import {
 	buildAgentResultMessage,
 	formatStartNotification,
@@ -96,7 +108,19 @@ async function startUserAgent(
 		services.modelRuntime.getModel(selectedModel.provider, selectedModel.id) ?? selectedModel;
 	const thinkingLevel = forwarded.thinkingLevel ?? pi.getThinkingLevel();
 	const inheritedMessages = parsed.isolate ? [] : buildInheritedMessages(ctx);
-	const runningAgent = createRunningAgent(nextAgentNumber(), command, model, parsed, invocation);
+	// A real session file from birth: the child outlives the widget row and stays resumable.
+	const childSessionManager = SessionManager.create(services.cwd, undefined, {
+		parentSession: ctx.sessionManager.getSessionFile(),
+	});
+	const runningAgent = createRunningAgent(
+		nextAgentNumber(),
+		childSessionManager.getSessionId(),
+		command,
+		model,
+		parsed,
+		invocation,
+		conversationFingerprint(inheritedMessages),
+	);
 
 	runningAgents.add(runningAgent);
 	logSteering(runningAgent.id, "agent-created", { command, taskLength: parsed.task.length });
@@ -117,6 +141,7 @@ async function startUserAgent(
 		forwarded,
 		inheritedMessages,
 		services,
+		childSessionManager,
 		runningAgent,
 		widget,
 	).finally(() => {
@@ -129,21 +154,25 @@ async function startUserAgent(
 
 function createRunningAgent(
 	sequenceNumber: number,
+	sessionId: string,
 	command: AgentCommandName,
 	model: Model,
 	parsed: ParsedAgentCommand,
 	invocation: string,
+	dispatchBaseFingerprint: string,
 ): RunningAgent {
 	return {
 		id: `user-${sequenceNumber.toString(36)}`,
+		sessionId,
 		command,
 		inheritedContext: !parsed.isolate,
 		model: formatModel(model),
 		modelLabel: formatModelLabel(model),
 		task: parsed.task,
 		invocation,
-		notifyMainAgent: parsed.context,
-		mainContextState: parsed.context ? "will-join" : "separate",
+		notifyMainAgent: parsed.squash,
+		dispatchBaseFingerprint,
+		mainContextState: parsed.squash ? "will-squash" : "separate",
 		status: "starting",
 		startedAt: Date.now(),
 		turnStartedAt: Date.now(),
@@ -173,6 +202,66 @@ function postUserAgentResult(
 	return true;
 }
 
+/**
+ * The rebase mechanism: fast-forward a child conversation onto the session that dispatched it.
+ *
+ * Delivery appends the messages to the main session file, drops a persisted breadcrumb naming
+ * the child session, and asks the host to switch to that same file — the one path that rebuilds
+ * both the live LLM context and the TUI transcript (see INTERNALS.md).
+ */
+export function createRebaseDelivery(
+	pi: ExtensionAPI,
+	getSessionContext: () => ExtensionCommandContext | undefined,
+): RebaseDelivery {
+	return {
+		canDeliver: (agent) => {
+			const ctx = getSessionContext();
+			return (
+				ctx !== undefined &&
+				mainContextFingerprint(ctx.sessionManager) === agent.dispatchBaseFingerprint
+			);
+		},
+		deliver: (agent, messages) => {
+			const ctx = getSessionContext();
+			if (!ctx) throw new Error("No dispatching session context to rebase onto");
+			// The runtime object behind the extension's readonly facade is the writable SessionManager.
+			const sessionManager = ctx.sessionManager as unknown as SessionManager;
+			// A replayed compaction's kept tail may reach back into main's existing context.
+			const priorContextEntryIds = sessionManager
+				.buildContextEntries()
+				.flatMap((entry) => sessionEntryToContextMessages(entry).map(() => entry.id));
+			persistMessages(sessionManager, messages, priorContextEntryIds);
+			pi.appendEntry<RebasedEntryData>(REBASED_ENTRY_TYPE, {
+				sessionId: agent.sessionId,
+				stats: {
+					messageCount: messages.length,
+					tokenEstimate: messages.reduce((total, message) => total + estimateTokens(message), 0),
+					compactionCount: messages.filter((message) => message.role === "compactionSummary")
+						.length,
+				},
+			});
+			const sessionFile = sessionManager.getSessionFile();
+			if (!sessionFile) throw new Error("The main session has no file to switch to");
+			void ctx.switchSession(sessionFile).then(
+				(result) => {
+					if (result.cancelled && ctx.hasUI)
+						ctx.ui.notify(
+							"The rebase is saved to the session file, but the session switch was cancelled — /resume this session to see it",
+							"warning",
+						);
+				},
+				(error) => {
+					if (ctx.hasUI)
+						ctx.ui.notify(
+							`The rebase is saved to the session file, but the session switch failed (${errorMessage(error)}) — /resume this session to see it`,
+							"error",
+						);
+				},
+			);
+		},
+	};
+}
+
 /** Session inputs derived from forwarded pi CLI options, ready to hand to the child session. */
 type ChildResourceLoaderOptions = {
 	systemPrompt?: string;
@@ -342,6 +431,7 @@ async function runAgentLifecycle(
 	forwarded: ForwardedOptions,
 	inheritedMessages: AgentMessage[],
 	services: AgentSessionServices,
+	childSessionManager: SessionManager,
 	runningAgent: RunningAgent,
 	widget: UserAgentWidget,
 ): Promise<void> {
@@ -354,6 +444,7 @@ async function runAgentLifecycle(
 			forwarded,
 			inheritedMessages,
 			services,
+			childSessionManager,
 			runningAgent,
 			widget,
 		);
@@ -378,7 +469,7 @@ async function runAgentLifecycle(
 			{ ok: false, error: message },
 			{ display: runningAgent.notifyMainAgent },
 		);
-		widget.addCompleted(runningAgent, resultMessage, { joinable: !runningAgent.notifyMainAgent });
+		widget.addCompleted(runningAgent, resultMessage, { squashable: !runningAgent.notifyMainAgent });
 		if (postUserAgentResult(pi, isShuttingDown, runningAgent.notifyMainAgent, resultMessage))
 			runningAgent.status = "posted";
 	} finally {
@@ -422,7 +513,7 @@ export async function runChildTurns(
 				{ display: false },
 			);
 			postUserAgentResult(pi, isShuttingDown, false, resultMessage);
-			runningAgent.pendingJoinMessage = runningAgent.notifyMainAgent
+			runningAgent.pendingSquashMessage = runningAgent.notifyMainAgent
 				? undefined
 				: resultMessage;
 			if (isShuttingDown()) return;
@@ -454,13 +545,13 @@ export async function runChildTurns(
 				resultMessage.details.mainContextState = "separate";
 				return;
 			}
-			widget.addCompleted(runningAgent, resultMessage, { joinable: false });
+			widget.addCompleted(runningAgent, resultMessage, { squashable: false });
 			const posted = postUserAgentResult(pi, isShuttingDown, true, resultMessage);
 			runningAgent.status = posted ? "posted" : runningAgent.status;
 			return;
 		}
 		postUserAgentResult(pi, isShuttingDown, false, resultMessage);
-		runningAgent.pendingJoinMessage = resultMessage;
+		runningAgent.pendingSquashMessage = resultMessage;
 		if (isShuttingDown()) return;
 		runningAgent.status = "idle";
 		logSteering(runningAgent.id, "agent-idle", { turnCount: runningAgent.turnCount });
@@ -487,12 +578,15 @@ async function createChildSession(
 	forwarded: ForwardedOptions,
 	inheritedMessages: AgentMessage[],
 	services: AgentSessionServices,
+	childSessionManager: SessionManager,
 	runningAgent: RunningAgent,
 	widget: UserAgentWidget,
 ): Promise<AgentSession> {
+	// Built while the session is still empty: that is the only path on which pi records the
+	// model and thinking level, and without those entries a resumed child falls back to defaults.
 	const { session } = await createAgentSessionFromServices({
 		services,
-		sessionManager: SessionManager.inMemory(services.cwd),
+		sessionManager: childSessionManager,
 		model,
 		thinkingLevel,
 		tools: forwarded.tools,
@@ -509,12 +603,53 @@ async function createChildSession(
 	await session.bindExtensions({ mode: "print" });
 	logSteering(runningAgent.id, "session-bound", { streaming: session.isStreaming });
 	if (inheritedMessages.length > 0) {
+		persistMessages(childSessionManager, inheritedMessages, []);
 		session.agent.state.messages = inheritedMessages;
 		logSteering(runningAgent.id, "context-inherited", { messageCount: inheritedMessages.length });
 	}
 	return session;
 }
 
+/**
+ * Mirror a message stream into a session file, each role through its own append method.
+ * Seeds a child with its inherited snapshot (leading summary), and replays a rebase onto the
+ * main session. A compaction with a keptTailCount maps its kept-tail boundary onto this file's
+ * own entry ids, so the rebuilt context keeps the same messages verbatim the child kept — the
+ * tail may reach back into the pre-replay context, whose per-message ids arrive as
+ * priorContextEntryIds (empty when seeding a child).
+ */
+export function persistMessages(
+	sessionManager: SessionManager,
+	messages: readonly AgentMessage[],
+	priorContextEntryIds: readonly string[],
+): void {
+	// One id per context message, prior context first; every appended entry projects to one message.
+	const entryIdsPerMessage: string[] = [...priorContextEntryIds];
+	for (const message of messages) {
+		if (message.role === "compactionSummary") {
+			const keptTailCount = (message as ChildCompactionMessage).keptTailCount ?? 0;
+			const firstKeptEntryId =
+				keptTailCount > 0 ? (entryIdsPerMessage[entryIdsPerMessage.length - keptTailCount] ?? "") : "";
+			entryIdsPerMessage.push(
+				sessionManager.appendCompaction(message.summary, firstKeptEntryId, message.tokensBefore),
+			);
+		} else if (message.role === "branchSummary")
+			entryIdsPerMessage.push(
+				sessionManager.branchWithSummary(sessionManager.getLeafId(), message.summary),
+			);
+		else if (message.role === "custom")
+			entryIdsPerMessage.push(
+				sessionManager.appendCustomMessageEntry(
+					message.customType,
+					message.content,
+					message.display,
+					message.details,
+				),
+			);
+		else entryIdsPerMessage.push(sessionManager.appendMessage(message));
+	}
+}
+
 /** Parks an idle agent until the user resumes it with another instruction (resolves with it) or retires it (resolves undefined). */
 export function waitForInstruction(
 	agent: RunningAgent,
@@ -528,7 +663,7 @@ export function waitForInstruction(
 		};
 		agent.resume = (instruction) => {
 			logSteering(agent.id, "agent-resumed", { instructionLength: instruction.length });
-			agent.mainContextState = agent.notifyMainAgent ? "will-join" : "separate";
+			agent.mainContextState = agent.notifyMainAgent ? "will-squash" : "separate";
 			agent.status = "running";
 			agent.turnStartedAt = Date.now();
 			agent.completedAt = undefined;
@@ -542,12 +677,26 @@ export function waitForInstruction(
 	});
 }
 
-function subscribeToChildSession(
+export function subscribeToChildSession(
 	session: AgentSession,
 	runningAgent: RunningAgent,
 	widget: UserAgentWidget,
 ): () => void {
 	return session.subscribe((event: AgentSessionEvent) => {
+		if (event.type === "compaction_end" && !event.aborted && event.result) {
+			// Compaction never emits message events; capture it here or the rebase stream misses it.
+			// At this instant the live context is exactly [summary, kept tail], so the tail is countable.
+			const keptTailCount = Math.max(0, session.agent.state.messages.length - 1);
+			const compactionMessage: ChildCompactionMessage = {
+				role: "compactionSummary",
+				summary: event.result.summary,
+				tokensBefore: event.result.tokensBefore,
+				timestamp: Date.now(),
+				keptTailCount,
+			};
+			runningAgent.conversationMessages.push(compactionMessage);
+			logSteering(runningAgent.id, "child-compacted", { keptTailCount });
+		}
 		if (event.type === "agent_start")
 			logSteering(runningAgent.id, "child-agent-started", { streaming: session.isStreaming });
 		if (event.type === "agent_end")

package/shared.ts

@@ -16,7 +16,7 @@ export type Theme = ExtensionCommandContext["ui"]["theme"];
 export type UIContext = ExtensionCommandContext["ui"];
 
 export type AgentCommandName = "agent";
-export type MainContextState = "separate" | "will-join" | "joined";
+export type MainContextState = "separate" | "will-squash" | "squashed" | "rebased";
 export type AgentStatus =
 	| "starting"
 	| "running"
@@ -27,7 +27,7 @@ export type AgentStatus =
 
 export type ParsedAgentCommand = {
 	isolate: boolean;
-	context: boolean;
+	squash: boolean;
 	/** Leading pi CLI tokens (minus the extension's own options) to forward to the child, e.g. ["--thinking", "high"]. */
 	forwardedArgs: string[];
 	task: string;
@@ -40,6 +40,30 @@ export type AgentEntryData = {
 	details: AgentCommandDetails;
 };
 
+export type DetachedEntryData = {
+	sessionId: string;
+};
+
+export type RebaseStats = {
+	messageCount: number;
+	tokenEstimate: number;
+	compactionCount: number;
+};
+
+export type RebasedEntryData = {
+	sessionId: string;
+	/** Absent on entries persisted before stats existed. */
+	stats?: RebaseStats;
+};
+
+/**
+ * A child compaction captured from its compaction_end event. keptTailCount records how many
+ * messages the compaction kept verbatim, so a rebase replay can restore the exact boundary.
+ */
+export type ChildCompactionMessage = Extract<AgentMessage, { role: "compactionSummary" }> & {
+	keptTailCount?: number;
+};
+
 export type AgentResultMessage = {
 	customType: string;
 	content: string;
@@ -67,15 +91,19 @@ export type AgentCommandDetails = {
 
 export type RunningAgent = {
 	id: string;
+	/** The child's own Pi session, resumable with `/resume <sessionId>` after the agent is detached. */
+	sessionId: string;
 	command: AgentCommandName;
 	inheritedContext: boolean;
 	model: string;
 	modelLabel: string;
 	task: string;
-	/** The slash command line as the user typed it, e.g. `/agent -j fix the bug`. */
+	/** The slash command line as the user typed it, e.g. `/agent -s fix the bug`. */
 	invocation: string;
-	/** -j/--join: post invocation+result to the main agent and trigger its turn, instead of waiting quietly for the next user prompt. */
+	/** -s/--squash: post invocation+result to the main agent and trigger its turn, instead of waiting quietly for the next user prompt. */
 	notifyMainAgent: boolean;
+	/** Fingerprint of the main context the child was dispatched from ("[]" for -i); the rebase fast-forward base. */
+	dispatchBaseFingerprint: string;
 	mainContextState: MainContextState;
 	status: AgentStatus;
 	startedAt: number;
@@ -91,8 +119,8 @@ export type RunningAgent = {
 	latestFinalizedMessage?: AgentMessage;
 	error?: string;
 	session?: AgentSession;
-	/** Latest completed turn's result message, deliverable to the main agent via the overlay's join action. */
-	pendingJoinMessage?: AgentResultMessage;
+	/** Latest completed turn's result message, deliverable to the main agent via the overlay's squash action. */
+	pendingSquashMessage?: AgentResultMessage;
 	/** Starts another turn on an idle agent; assigned while the lifecycle loop awaits the next instruction. */
 	resume?: (instruction: string) => void;
 	/** Ends an idle agent's lifecycle without another turn; assigned alongside resume. */
@@ -106,11 +134,13 @@ export type RunningAgent = {
 
 export type CompletedAgent = {
 	id: string;
+	sessionId: string;
 	command: AgentCommandName;
 	modelLabel: string;
 	task: string;
+	dispatchBaseFingerprint: string;
 	mainContextState: MainContextState;
-	pendingJoinMessage?: AgentResultMessage;
+	pendingSquashMessage?: AgentResultMessage;
 	ok: boolean;
 	responseText: string;
 	messages: AgentMessage[];
@@ -122,7 +152,61 @@ export type CompletedAgent = {
 	contextPercent?: number;
 };
 
+/** The mechanism that fast-forwards a child conversation onto the main session, injected into the widget. */
+export type RebaseDelivery = {
+	/** Whether the main session's live context still equals this agent's dispatch base. */
+	canDeliver(agent: RunningAgent | CompletedAgent): boolean;
+	/** Append the processed child conversation onto the main session. */
+	deliver(agent: RunningAgent | CompletedAgent, messages: AgentMessage[]): void;
+};
+
+/** How long a confirmation stays armed, and how long a transient footer notice shows. */
+export const CONFIRMATION_WINDOW_MS = 4000;
+
+/**
+ * A two-press confirmation with a timeout: the first press arms it, a repeat press on the
+ * same target within the window confirms. A press on another target re-arms, cancel or
+ * expiry disarms. One instance serves every confirmable action on a surface.
+ */
+export class TimedConfirmation<Target> {
+	private armedOn: Target | undefined;
+	private expiry: ReturnType<typeof setTimeout> | undefined;
+
+	constructor(
+		private readonly onExpire: () => void,
+		private readonly windowMs: number = CONFIRMATION_WINDOW_MS,
+	) {}
+
+	/** One press of the action key: true means confirmed, false means armed and waiting. */
+	press(target: Target): boolean {
+		if (this.armedOn === target) {
+			this.cancel();
+			return true;
+		}
+		this.armedOn = target;
+		if (this.expiry) clearTimeout(this.expiry);
+		this.expiry = setTimeout(() => {
+			this.armedOn = undefined;
+			this.expiry = undefined;
+			this.onExpire();
+		}, this.windowMs);
+		return false;
+	}
+
+	cancel(): void {
+		this.armedOn = undefined;
+		if (this.expiry) clearTimeout(this.expiry);
+		this.expiry = undefined;
+	}
+
+	isArmedOn(target: Target): boolean {
+		return this.armedOn !== undefined && this.armedOn === target;
+	}
+}
+
 export const MESSAGE_TYPE = "pi-user-agents";
+export const DETACHED_ENTRY_TYPE = "pi-user-agents-detached";
+export const REBASED_ENTRY_TYPE = "pi-user-agents-rebased";
 export const WIDGET_KEY = "pi-user-agents";
 export const STEERING_LOG_PATH = `${tmpdir()}/pi-user-agents-steer.log`;
 
@@ -162,8 +246,9 @@ export function contextLabel(inheritedContext: boolean): string {
 }
 
 export function mainContextLabel(state: MainContextState | undefined): string | undefined {
-	if (state === "will-join") return "will join context";
-	if (state === "joined") return "joined context";
+	if (state === "will-squash") return "will squash into context";
+	if (state === "squashed") return "squashed messages into context";
+	if (state === "rebased") return "rebased into context";
 	return undefined;
 }
 

package/transcript.ts

@@ -6,13 +6,16 @@ import type {
 	AgentEntryData,
 	AgentMessage,
 	AgentResultMessage,
+	DetachedEntryData,
 	ExtensionAPI,
 	ExtensionCommandContext,
+	RebasedEntryData,
 	RunningAgent,
 	Theme,
 } from "./shared.js";
 import {
 	contextLabel,
+	DETACHED_ENTRY_TYPE,
 	escapeAttribute,
 	extractTag,
 	formatMs,
@@ -20,6 +23,7 @@ import {
 	formatTurns,
 	mainContextLabel,
 	MESSAGE_TYPE,
+	REBASED_ENTRY_TYPE,
 	truncatePlain,
 } from "./shared.js";
 
@@ -51,14 +55,14 @@ export function reportCommandError(
 }
 
 /**
- * Select the joined role messages from a child transcript.
+ * Select the squashed role messages from a child transcript.
  *
- * @example selectJoinedMessages([{ role: "user", content: "hello", timestamp: 0 }]).length // 1
+ * @example selectSquashedMessages([{ role: "user", content: "hello", timestamp: 0 }]).length // 1
  */
-type JoinedMessage = Extract<AgentMessage, { role: "user" | "assistant" }>;
+type SquashedMessage = Extract<AgentMessage, { role: "user" | "assistant" }>;
 
-export function selectJoinedMessages(messages: readonly AgentMessage[]): JoinedMessage[] {
-	const selected: JoinedMessage[] = [];
+export function selectSquashedMessages(messages: readonly AgentMessage[]): SquashedMessage[] {
+	const selected: SquashedMessage[] = [];
 	let latestAssistant: Extract<AgentMessage, { role: "assistant" }> | undefined;
 	for (const message of messages) {
 		if (message.role === "assistant" && roleMessageText(message).trim()) {
@@ -108,13 +112,13 @@ export function buildAgentResultMessage(
 	};
 }
 
-const JOINED_CONVERSATION_PREFACE =
+const SQUASHED_CONVERSATION_PREFACE =
 	"The user has dispatched a background sub-agent with a task. The sub-agent is done. The following is the back and forth between them:";
 
 export function formatResultMessage(agent: RunningAgent): string {
-	const messages = selectJoinedMessages(agent.conversationMessages);
+	const messages = selectSquashedMessages(agent.conversationMessages);
 	const lines = [
-		JOINED_CONVERSATION_PREFACE,
+		SQUASHED_CONVERSATION_PREFACE,
 		`<user_agent model="${escapeAttribute(agent.model)}" inherited_context="${agent.inheritedContext}">`,
 	];
 	let firstUserMessage = true;
@@ -133,7 +137,7 @@ export function formatResultMessage(agent: RunningAgent): string {
 	return lines.join("\n");
 }
 
-function roleMessageText(message: JoinedMessage): string {
+function roleMessageText(message: SquashedMessage): string {
 	if (typeof message.content === "string") return message.content;
 	return message.content
 		.flatMap((part) => (part.type === "text" ? [part.text] : []))
@@ -212,6 +216,37 @@ export function registerUserAgentRenderer(pi: ExtensionAPI): void {
 					)
 				: undefined,
 	);
+	// Pi's chat container does not pad renderer components; its own chat lines self-pad with paddingX 1.
+	pi.registerEntryRenderer<DetachedEntryData>(DETACHED_ENTRY_TYPE, (entry, _state, theme) =>
+		entry.data
+			? new Text(theme.fg("dim", `Detached session ${entry.data.sessionId}`), 1, 0)
+			: undefined,
+	);
+	pi.registerEntryRenderer<RebasedEntryData>(REBASED_ENTRY_TYPE, (entry, _state, theme) =>
+		entry.data ? new Text(theme.fg("dim", formatRebasedLine(entry.data)), 1, 0) : undefined,
+	);
+}
+
+function formatRebasedLine(data: RebasedEntryData): string {
+	const base = `Rebased session ${data.sessionId} into this conversation`;
+	if (!data.stats) return base;
+	const parts = [
+		`added ${data.stats.messageCount} message${data.stats.messageCount === 1 ? "" : "s"}`,
+		`~${formatTokenCount(data.stats.tokenEstimate)} tokens`,
+	];
+	if (data.stats.compactionCount > 0)
+		parts.push(
+			`${data.stats.compactionCount} compaction event${data.stats.compactionCount === 1 ? "" : "s"}`,
+		);
+	return `${base} (${parts.join(", ")})`;
+}
+
+/**
+ * @example formatTokenCount(135_264) // "135K"
+ * @example formatTokenCount(12) // "12"
+ */
+function formatTokenCount(tokens: number): string {
+	return tokens < 1000 ? `${tokens}` : `${Math.round(tokens / 1000)}K`;
 }
 
 function liveAgentCard(
@@ -244,7 +279,7 @@ function renderAgentCard(
 	if (parts.length > 0) text += ` ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(" · "))}`;
 	if (task) text += `\n  ${theme.fg("dim", `task: ${truncatePlain(task, 88)}`)}`;
 	const card = new Container();
-	card.addChild(new Text(text, 0, 0));
+	card.addChild(new Text(text, 1, 0));
 	card.addChild(body);
 	return card;
 }
@@ -263,12 +298,12 @@ function renderAgentCardBody(
 		"No output.";
 	if (expanded)
 		return ok
-			? new Markdown(output, 2, 0, getMarkdownTheme())
-			: new Text(theme.fg("error", output), 2, 0);
+			? new Markdown(output, 3, 0, getMarkdownTheme())
+			: new Text(theme.fg("error", output), 3, 0);
 
 	const previewText = `⎿  ${truncatePlain(details?.responsePreview ?? output, 110)}`;
-	if (!ok) return new Text(`  ${theme.fg("error", previewText)}`, 0, 0);
-	return new Markdown(previewText, 2, 0, getMarkdownTheme(), {
+	if (!ok) return new Text(`  ${theme.fg("error", previewText)}`, 1, 0);
+	return new Markdown(previewText, 3, 0, getMarkdownTheme(), {
 		color: (value) => theme.fg("dim", value),
 	});
 }