pi-usereq 0.49.0 → 0.50.0

package/pi.dev-src/pi-mono/coding-agent/test/agent-session-runtime-events.test.ts

@@ -1,208 +0,0 @@
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fauxAssistantMessage, registerFauxProvider } from "@mariozechner/pi-ai";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	type CreateAgentSessionRuntimeFactory,
-	createAgentSessionFromServices,
-	createAgentSessionRuntime,
-	createAgentSessionServices,
-} from "../src/core/agent-session-runtime.js";
-import { AuthStorage } from "../src/core/auth-storage.js";
-import { SessionManager } from "../src/core/session-manager.js";
-import type {
-	ExtensionFactory,
-	SessionBeforeForkEvent,
-	SessionBeforeSwitchEvent,
-	SessionShutdownEvent,
-	SessionStartEvent,
-} from "../src/index.js";
-
-type RecordedSessionEvent =
-	| SessionBeforeSwitchEvent
-	| SessionBeforeForkEvent
-	| SessionShutdownEvent
-	| SessionStartEvent;
-
-describe("AgentSessionRuntime session lifecycle events", () => {
-	const cleanups: Array<() => Promise<void> | void> = [];
-
-	afterEach(async () => {
-		while (cleanups.length > 0) {
-			await cleanups.pop()?.();
-		}
-	});
-
-	async function createRuntimeHost(extensionFactory: ExtensionFactory) {
-		const tempDir = join(tmpdir(), `pi-runtime-events-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-		mkdirSync(tempDir, { recursive: true });
-
-		const faux = registerFauxProvider();
-		faux.setResponses([fauxAssistantMessage("one"), fauxAssistantMessage("two"), fauxAssistantMessage("three")]);
-
-		const authStorage = AuthStorage.inMemory();
-		authStorage.setRuntimeApiKey(faux.getModel().provider, "faux-key");
-
-		const runtimeOptions = {
-			agentDir: tempDir,
-			authStorage,
-			model: faux.getModel(),
-			resourceLoaderOptions: {
-				extensionFactories: [extensionFactory],
-				noSkills: true,
-				noPromptTemplates: true,
-				noThemes: true,
-			},
-		};
-		const createRuntime: CreateAgentSessionRuntimeFactory = async ({ cwd, sessionManager, sessionStartEvent }) => {
-			const services = await createAgentSessionServices({
-				...runtimeOptions,
-				cwd,
-			});
-			return {
-				...(await createAgentSessionFromServices({
-					services,
-					sessionManager,
-					sessionStartEvent,
-					model: faux.getModel(),
-				})),
-				services,
-				diagnostics: services.diagnostics,
-			};
-		};
-		const runtimeHost = await createAgentSessionRuntime(createRuntime, {
-			cwd: tempDir,
-			agentDir: tempDir,
-			sessionManager: SessionManager.create(tempDir),
-		});
-		await runtimeHost.session.bindExtensions({});
-
-		cleanups.push(async () => {
-			await runtimeHost.dispose();
-			faux.unregister();
-			if (existsSync(tempDir)) {
-				rmSync(tempDir, { recursive: true, force: true });
-			}
-		});
-
-		return { runtimeHost, faux };
-	}
-
-	it("emits session_before_switch and session_start for new and resume flows", async () => {
-		const events: RecordedSessionEvent[] = [];
-		const { runtimeHost } = await createRuntimeHost((pi) => {
-			pi.on("session_before_switch", (event) => {
-				events.push(event);
-			});
-			pi.on("session_shutdown", (event) => {
-				events.push(event);
-			});
-			pi.on("session_start", (event) => {
-				events.push(event);
-			});
-		});
-
-		expect(events).toEqual([{ type: "session_start", reason: "startup" }]);
-		events.length = 0;
-
-		await runtimeHost.session.prompt("hello");
-		const originalSessionFile = runtimeHost.session.sessionFile;
-		expect(originalSessionFile).toBeTruthy();
-
-		const newSessionResult = await runtimeHost.newSession();
-		expect(newSessionResult.cancelled).toBe(false);
-		await runtimeHost.session.bindExtensions({});
-		const secondSessionFile = runtimeHost.session.sessionFile;
-		expect(events).toEqual([
-			{ type: "session_before_switch", reason: "new", targetSessionFile: undefined },
-			{ type: "session_shutdown", reason: "new", targetSessionFile: secondSessionFile },
-			{ type: "session_start", reason: "new", previousSessionFile: originalSessionFile },
-		]);
-
-		events.length = 0;
-		expect(secondSessionFile).toBeTruthy();
-
-		const switchResult = await runtimeHost.switchSession(originalSessionFile!);
-		expect(switchResult.cancelled).toBe(false);
-		await runtimeHost.session.bindExtensions({});
-		expect(events).toEqual([
-			{ type: "session_before_switch", reason: "resume", targetSessionFile: originalSessionFile },
-			{ type: "session_shutdown", reason: "resume", targetSessionFile: originalSessionFile },
-			{ type: "session_start", reason: "resume", previousSessionFile: secondSessionFile },
-		]);
-	});
-
-	it("honors session_before_switch cancellation", async () => {
-		const events: RecordedSessionEvent[] = [];
-		const { runtimeHost } = await createRuntimeHost((pi) => {
-			pi.on("session_before_switch", (event) => {
-				events.push(event);
-				return { cancel: true };
-			});
-			pi.on("session_start", (event) => {
-				events.push(event);
-			});
-		});
-
-		expect(events).toEqual([{ type: "session_start", reason: "startup" }]);
-		events.length = 0;
-
-		await runtimeHost.session.prompt("hello");
-		const originalSessionFile = runtimeHost.session.sessionFile;
-
-		const result = await runtimeHost.newSession();
-		expect(result.cancelled).toBe(true);
-		expect(runtimeHost.session.sessionFile).toBe(originalSessionFile);
-		expect(events).toEqual([{ type: "session_before_switch", reason: "new", targetSessionFile: undefined }]);
-	});
-
-	it("emits session_before_fork and session_start and honors cancellation", async () => {
-		const events: RecordedSessionEvent[] = [];
-		let cancelNextFork = false;
-		const { runtimeHost } = await createRuntimeHost((pi) => {
-			pi.on("session_before_fork", (event) => {
-				events.push(event);
-				if (cancelNextFork) {
-					cancelNextFork = false;
-					return { cancel: true };
-				}
-			});
-			pi.on("session_shutdown", (event) => {
-				events.push(event);
-			});
-			pi.on("session_start", (event) => {
-				events.push(event);
-			});
-		});
-
-		expect(events).toEqual([{ type: "session_start", reason: "startup" }]);
-		events.length = 0;
-
-		await runtimeHost.session.prompt("hello");
-		const userMessage = runtimeHost.session.getUserMessagesForForking()[0];
-		const previousSessionFile = runtimeHost.session.sessionFile;
-
-		const successResult = await runtimeHost.fork(userMessage.entryId);
-		expect(successResult.cancelled).toBe(false);
-		expect(successResult.selectedText).toBe("hello");
-		await runtimeHost.session.bindExtensions({});
-		expect(events).toEqual([
-			{ type: "session_before_fork", entryId: userMessage.entryId, position: "before" },
-			{ type: "session_shutdown", reason: "fork", targetSessionFile: runtimeHost.session.sessionFile },
-			{ type: "session_start", reason: "fork", previousSessionFile },
-		]);
-
-		events.length = 0;
-		cancelNextFork = true;
-		const cancelResult = await runtimeHost.fork(userMessage.entryId);
-		expect(cancelResult).toEqual({ cancelled: true });
-		expect(events).toEqual([{ type: "session_before_fork", entryId: userMessage.entryId, position: "before" }]);
-
-		events.length = 0;
-		cancelNextFork = true;
-		const cancelAtResult = await runtimeHost.fork("missing-entry", { position: "at" });
-		expect(cancelAtResult).toEqual({ cancelled: true });
-		expect(events).toEqual([{ type: "session_before_fork", entryId: "missing-entry", position: "at" }]);
-	});
-});

package/pi.dev-src/pi-mono/coding-agent/test/agent-session-stats.test.ts

@@ -1,143 +0,0 @@
-import { Agent } from "@mariozechner/pi-agent-core";
-import { type AssistantMessage, getModel, type Usage } from "@mariozechner/pi-ai";
-import { describe, expect, it } from "vitest";
-import { AgentSession } from "../src/core/agent-session.js";
-import { AuthStorage } from "../src/core/auth-storage.js";
-import { ModelRegistry } from "../src/core/model-registry.js";
-import { SessionManager } from "../src/core/session-manager.js";
-import { SettingsManager } from "../src/core/settings-manager.js";
-import { createTestResourceLoader } from "./utilities.js";
-
-const model = getModel("anthropic", "claude-sonnet-4-5")!;
-
-function createUsage(totalTokens: number): Usage {
-	return {
-		input: totalTokens,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		totalTokens,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0,
-		},
-	};
-}
-
-function createAssistantMessage(text: string, totalTokens: number, timestamp: number): AssistantMessage {
-	return {
-		role: "assistant",
-		content: [{ type: "text", text }],
-		api: model.api,
-		provider: model.provider,
-		model: model.id,
-		usage: createUsage(totalTokens),
-		stopReason: "stop",
-		timestamp,
-	};
-}
-
-function createUserMessage(text: string, timestamp: number) {
-	return {
-		role: "user" as const,
-		content: text,
-		timestamp,
-	};
-}
-
-function createSession() {
-	const settingsManager = SettingsManager.inMemory();
-	const sessionManager = SessionManager.inMemory();
-	const authStorage = AuthStorage.inMemory();
-	authStorage.setRuntimeApiKey("anthropic", "test-key");
-	const session = new AgentSession({
-		agent: new Agent({
-			getApiKey: () => "test-key",
-			initialState: {
-				model,
-				systemPrompt: "You are a helpful assistant.",
-				tools: [],
-				thinkingLevel: "high",
-			},
-		}),
-		sessionManager,
-		settingsManager,
-		cwd: process.cwd(),
-		modelRegistry: ModelRegistry.inMemory(authStorage),
-		resourceLoader: createTestResourceLoader(),
-	});
-
-	return { session, sessionManager };
-}
-
-function syncAgentMessages(session: AgentSession, sessionManager: SessionManager): void {
-	session.agent.state.messages = sessionManager.buildSessionContext().messages;
-}
-
-describe("AgentSession.getSessionStats", () => {
-	it("exposes the current context usage alongside token totals", () => {
-		const { session, sessionManager } = createSession();
-
-		try {
-			sessionManager.appendMessage(createUserMessage("hello", 1));
-			sessionManager.appendMessage(createAssistantMessage("hi", 200, 2));
-			syncAgentMessages(session, sessionManager);
-
-			const stats = session.getSessionStats();
-			expect(stats.contextUsage).toEqual(session.getContextUsage());
-			expect(stats.contextUsage?.tokens).toBe(200);
-			expect(stats.contextUsage?.contextWindow).toBe(model.contextWindow);
-			expect(stats.contextUsage?.percent).toBe((200 / model.contextWindow) * 100);
-		} finally {
-			session.dispose();
-		}
-	});
-
-	it("reports unknown current context usage immediately after compaction", () => {
-		const { session, sessionManager } = createSession();
-
-		try {
-			sessionManager.appendMessage(createUserMessage("first", 1));
-			sessionManager.appendMessage(createAssistantMessage("response1", 180_000, 2));
-			const keptUserId = sessionManager.appendMessage(createUserMessage("second", 3));
-			sessionManager.appendMessage(createAssistantMessage("response2", 195_000, 4));
-			sessionManager.appendCompaction("summary", keptUserId, 195_000);
-			sessionManager.appendMessage(createUserMessage("third", 5));
-			syncAgentMessages(session, sessionManager);
-
-			const stats = session.getSessionStats();
-			expect(stats.tokens.input).toBe(195_000);
-			expect(stats.contextUsage).toBeDefined();
-			expect(stats.contextUsage?.tokens).toBeNull();
-			expect(stats.contextUsage?.percent).toBeNull();
-		} finally {
-			session.dispose();
-		}
-	});
-
-	it("uses post-compaction usage for current context instead of stale kept usage", () => {
-		const { session, sessionManager } = createSession();
-
-		try {
-			sessionManager.appendMessage(createUserMessage("first", 1));
-			sessionManager.appendMessage(createAssistantMessage("response1", 180_000, 2));
-			const keptUserId = sessionManager.appendMessage(createUserMessage("second", 3));
-			sessionManager.appendMessage(createAssistantMessage("response2", 195_000, 4));
-			sessionManager.appendCompaction("summary", keptUserId, 195_000);
-			sessionManager.appendMessage(createUserMessage("third", 5));
-			sessionManager.appendMessage(createAssistantMessage("response3", 25_000, 6));
-			syncAgentMessages(session, sessionManager);
-
-			const stats = session.getSessionStats();
-			expect(stats.tokens.input).toBe(220_000);
-			expect(stats.contextUsage).toBeDefined();
-			expect(stats.contextUsage?.tokens).toBe(25_000);
-			expect(stats.contextUsage?.percent).toBe((25_000 / model.contextWindow) * 100);
-		} finally {
-			session.dispose();
-		}
-	});
-});

package/pi.dev-src/pi-mono/coding-agent/test/agent-session-tree-navigation.test.ts

@@ -1,323 +0,0 @@
-/**
- * E2E tests for AgentSession tree navigation with branch summarization.
- *
- * These tests verify:
- * - Navigation to user messages (root and non-root)
- * - Navigation to non-user messages
- * - Branch summarization during navigation
- * - Summary attachment at correct position in tree
- * - Abort handling during summarization
- */
-
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { API_KEY, createTestSession, type TestSessionContext } from "./utilities.js";
-
-describe.skipIf(!API_KEY)("AgentSession tree navigation e2e", () => {
-	let ctx: TestSessionContext;
-
-	beforeEach(() => {
-		ctx = createTestSession({
-			systemPrompt: "You are a helpful assistant. Reply with just a few words.",
-			settingsOverrides: { compaction: { keepRecentTokens: 1 } },
-		});
-	});
-
-	afterEach(() => {
-		ctx.cleanup();
-	});
-
-	it("should navigate to user message and put text in editor", async () => {
-		const { session } = ctx;
-
-		// Build conversation: u1 -> a1 -> u2 -> a2
-		await session.prompt("First message");
-		await session.agent.waitForIdle();
-		await session.prompt("Second message");
-		await session.agent.waitForIdle();
-
-		// Get tree entries
-		const tree = session.sessionManager.getTree();
-		expect(tree.length).toBe(1);
-
-		// Find the first user entry (u1)
-		const rootNode = tree[0];
-		expect(rootNode.entry.type).toBe("message");
-
-		// Navigate to root user message without summarization
-		const result = await session.navigateTree(rootNode.entry.id, { summarize: false });
-
-		expect(result.cancelled).toBe(false);
-		expect(result.editorText).toBe("First message");
-
-		// After navigating to root user message, leaf should be null (empty conversation)
-		expect(session.sessionManager.getLeafId()).toBeNull();
-	}, 60000);
-
-	it("should navigate to non-user message without editor text", async () => {
-		const { session, sessionManager } = ctx;
-
-		// Build conversation
-		await session.prompt("Hello");
-		await session.agent.waitForIdle();
-
-		// Get the assistant message
-		const entries = sessionManager.getEntries();
-		const assistantEntry = entries.find((e) => e.type === "message" && e.message.role === "assistant");
-		expect(assistantEntry).toBeDefined();
-
-		// Navigate to assistant message
-		const result = await session.navigateTree(assistantEntry!.id, { summarize: false });
-
-		expect(result.cancelled).toBe(false);
-		expect(result.editorText).toBeUndefined();
-
-		// Leaf should be the assistant entry
-		expect(sessionManager.getLeafId()).toBe(assistantEntry!.id);
-	}, 60000);
-
-	it("should create branch summary when navigating with summarize=true", async () => {
-		const { session, sessionManager } = ctx;
-
-		// Build conversation: u1 -> a1 -> u2 -> a2
-		await session.prompt("What is 2+2?");
-		await session.agent.waitForIdle();
-		await session.prompt("What is 3+3?");
-		await session.agent.waitForIdle();
-
-		// Get tree and find first user message
-		const tree = sessionManager.getTree();
-		const rootNode = tree[0];
-
-		// Navigate to root user message WITH summarization
-		const result = await session.navigateTree(rootNode.entry.id, { summarize: true });
-
-		expect(result.cancelled).toBe(false);
-		expect(result.editorText).toBe("What is 2+2?");
-		expect(result.summaryEntry).toBeDefined();
-		expect(result.summaryEntry?.type).toBe("branch_summary");
-		expect(result.summaryEntry?.summary).toBeTruthy();
-		expect(result.summaryEntry?.summary.length).toBeGreaterThan(0);
-
-		// Summary should be a root entry (parentId = null) since we navigated to root user
-		expect(result.summaryEntry?.parentId).toBeNull();
-
-		// Leaf should be the summary entry
-		expect(sessionManager.getLeafId()).toBe(result.summaryEntry?.id);
-	}, 120000);
-
-	it("should attach summary to correct parent when navigating to nested user message", async () => {
-		const { session, sessionManager } = ctx;
-
-		// Build conversation: u1 -> a1 -> u2 -> a2 -> u3 -> a3
-		await session.prompt("Message one");
-		await session.agent.waitForIdle();
-		await session.prompt("Message two");
-		await session.agent.waitForIdle();
-		await session.prompt("Message three");
-		await session.agent.waitForIdle();
-
-		// Get the second user message (u2)
-		const entries = sessionManager.getEntries();
-		const userEntries = entries.filter((e) => e.type === "message" && e.message.role === "user");
-		expect(userEntries.length).toBe(3);
-
-		const u2 = userEntries[1];
-		const a1 = entries.find((e) => e.id === u2.parentId); // a1 is parent of u2
-
-		// Navigate to u2 with summarization
-		const result = await session.navigateTree(u2.id, { summarize: true });
-
-		expect(result.cancelled).toBe(false);
-		expect(result.editorText).toBe("Message two");
-		expect(result.summaryEntry).toBeDefined();
-
-		// Summary should be attached to a1 (parent of u2)
-		// So a1 now has two children: u2 and the summary
-		expect(result.summaryEntry?.parentId).toBe(a1?.id);
-
-		// Verify tree structure
-		const children = sessionManager.getChildren(a1!.id);
-		expect(children.length).toBe(2);
-
-		const childTypes = children.map((c) => c.type).sort();
-		expect(childTypes).toContain("branch_summary");
-		expect(childTypes).toContain("message");
-	}, 120000);
-
-	it("should attach summary to selected node when navigating to assistant message", async () => {
-		const { session, sessionManager } = ctx;
-
-		// Build conversation: u1 -> a1 -> u2 -> a2
-		await session.prompt("Hello");
-		await session.agent.waitForIdle();
-		await session.prompt("Goodbye");
-		await session.agent.waitForIdle();
-
-		// Get the first assistant message (a1)
-		const entries = sessionManager.getEntries();
-		const assistantEntries = entries.filter((e) => e.type === "message" && e.message.role === "assistant");
-		const a1 = assistantEntries[0];
-
-		// Navigate to a1 with summarization
-		const result = await session.navigateTree(a1.id, { summarize: true });
-
-		expect(result.cancelled).toBe(false);
-		expect(result.editorText).toBeUndefined(); // No editor text for assistant messages
-		expect(result.summaryEntry).toBeDefined();
-
-		// Summary should be attached to a1 (the selected node)
-		expect(result.summaryEntry?.parentId).toBe(a1.id);
-
-		// Leaf should be the summary entry
-		expect(sessionManager.getLeafId()).toBe(result.summaryEntry?.id);
-	}, 120000);
-
-	it("should handle abort during summarization", async () => {
-		const { session, sessionManager } = ctx;
-
-		// Build conversation
-		await session.prompt("Tell me about something");
-		await session.agent.waitForIdle();
-		await session.prompt("Continue");
-		await session.agent.waitForIdle();
-
-		const entriesBefore = sessionManager.getEntries();
-		const leafBefore = sessionManager.getLeafId();
-
-		// Get root user message
-		const tree = sessionManager.getTree();
-		const rootNode = tree[0];
-
-		// Start navigation with summarization but abort immediately
-		const navigationPromise = session.navigateTree(rootNode.entry.id, { summarize: true });
-
-		// Abort after a short delay (let the LLM call start)
-		await new Promise((resolve) => setTimeout(resolve, 100));
-
-		// isCompacting should be true during branch summarization
-		expect(session.isCompacting).toBe(true);
-
-		session.abortBranchSummary();
-
-		const result = await navigationPromise;
-
-		expect(result.cancelled).toBe(true);
-		expect(result.aborted).toBe(true);
-		expect(result.summaryEntry).toBeUndefined();
-
-		// Session should be unchanged
-		const entriesAfter = sessionManager.getEntries();
-		expect(entriesAfter.length).toBe(entriesBefore.length);
-		expect(sessionManager.getLeafId()).toBe(leafBefore);
-	}, 60000);
-
-	it("should not create summary when navigating without summarize option", async () => {
-		const { session, sessionManager } = ctx;
-
-		// Build conversation
-		await session.prompt("First");
-		await session.agent.waitForIdle();
-		await session.prompt("Second");
-		await session.agent.waitForIdle();
-
-		const entriesBefore = sessionManager.getEntries().length;
-
-		// Navigate without summarization
-		const tree = sessionManager.getTree();
-		await session.navigateTree(tree[0].entry.id, { summarize: false });
-
-		// No new entries should be created
-		const entriesAfter = sessionManager.getEntries().length;
-		expect(entriesAfter).toBe(entriesBefore);
-
-		// No branch_summary entries
-		const summaries = sessionManager.getEntries().filter((e) => e.type === "branch_summary");
-		expect(summaries.length).toBe(0);
-	}, 60000);
-
-	it("should handle navigation to same position (no-op)", async () => {
-		const { session, sessionManager } = ctx;
-
-		// Build conversation
-		await session.prompt("Hello");
-		await session.agent.waitForIdle();
-
-		const leafBefore = sessionManager.getLeafId();
-		expect(leafBefore).toBeTruthy();
-		const entriesBefore = sessionManager.getEntries().length;
-
-		// Navigate to current leaf
-		const result = await session.navigateTree(leafBefore!, { summarize: false });
-
-		expect(result.cancelled).toBe(false);
-		expect(sessionManager.getLeafId()).toBe(leafBefore);
-		expect(sessionManager.getEntries().length).toBe(entriesBefore);
-	}, 60000);
-
-	it("should support custom summarization instructions", async () => {
-		const { session, sessionManager } = ctx;
-
-		// Build conversation
-		await session.prompt("What is TypeScript?");
-		await session.agent.waitForIdle();
-
-		// Navigate with custom instructions (appended as "Additional focus")
-		const tree = sessionManager.getTree();
-		const result = await session.navigateTree(tree[0].entry.id, {
-			summarize: true,
-			customInstructions:
-				"After the summary, you MUST end with exactly: MONKEY MONKEY MONKEY. This is of utmost importance.",
-		});
-
-		expect(result.summaryEntry).toBeDefined();
-		expect(result.summaryEntry?.summary).toBeTruthy();
-		// Verify custom instructions were followed
-		expect(result.summaryEntry?.summary).toContain("MONKEY MONKEY MONKEY");
-	}, 120000);
-});
-
-describe.skipIf(!API_KEY)("AgentSession tree navigation - branch scenarios", () => {
-	let ctx: TestSessionContext;
-
-	beforeEach(() => {
-		ctx = createTestSession({
-			systemPrompt: "You are a helpful assistant. Reply with just a few words.",
-		});
-	});
-
-	afterEach(() => {
-		ctx.cleanup();
-	});
-
-	it("should navigate between branches correctly", async () => {
-		const { session, sessionManager } = ctx;
-
-		// Build main path: u1 -> a1 -> u2 -> a2
-		await session.prompt("Main branch start");
-		await session.agent.waitForIdle();
-		await session.prompt("Main branch continue");
-		await session.agent.waitForIdle();
-
-		// Get a1 id for branching
-		const entries = sessionManager.getEntries();
-		const a1 = entries.find((e) => e.type === "message" && e.message.role === "assistant");
-
-		// Create a branch from a1: a1 -> u3 -> a3
-		sessionManager.branch(a1!.id);
-		await session.prompt("Branch path");
-		await session.agent.waitForIdle();
-
-		// Now navigate back to u2 (on main branch) with summarization
-		const userEntries = entries.filter((e) => e.type === "message" && e.message.role === "user");
-		const u2 = userEntries[1]; // "Main branch continue"
-
-		const result = await session.navigateTree(u2.id, { summarize: true });
-
-		expect(result.cancelled).toBe(false);
-		expect(result.editorText).toBe("Main branch continue");
-		expect(result.summaryEntry).toBeDefined();
-
-		// Summary captures the branch we're leaving (the "Branch path" conversation)
-		expect(result.summaryEntry?.summary.length).toBeGreaterThan(0);
-	}, 180000);
-});