pi-usereq 0.7.0 → 0.11.0

package/pi.dev-src/pi-mono/coding-agent/test/sdk-skills.test.ts

@@ -0,0 +1,109 @@
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createExtensionRuntime } from "../src/core/extensions/loader.js";
+import type { ResourceLoader } from "../src/core/resource-loader.js";
+import { createAgentSession } from "../src/core/sdk.js";
+import { SessionManager } from "../src/core/session-manager.js";
+import { createSyntheticSourceInfo } from "../src/core/source-info.js";
+
+describe("createAgentSession skills option", () => {
+	let tempDir: string;
+	let skillsDir: string;
+
+	beforeEach(() => {
+		tempDir = join(tmpdir(), `pi-sdk-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+		skillsDir = join(tempDir, "skills", "test-skill");
+		mkdirSync(skillsDir, { recursive: true });
+
+		// Create a test skill in the pi skills directory
+		writeFileSync(
+			join(skillsDir, "SKILL.md"),
+			`---
+name: test-skill
+description: A test skill for SDK tests.
+---
+
+# Test Skill
+
+This is a test skill.
+`,
+		);
+	});
+
+	afterEach(() => {
+		if (tempDir) {
+			rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("should discover skills by default and expose them on session.skills", async () => {
+		const { session } = await createAgentSession({
+			cwd: tempDir,
+			agentDir: tempDir,
+			sessionManager: SessionManager.inMemory(),
+		});
+
+		// Skills should be discovered and exposed on the session
+		expect(session.resourceLoader.getSkills().skills.length).toBeGreaterThan(0);
+		expect(session.resourceLoader.getSkills().skills.some((s) => s.name === "test-skill")).toBe(true);
+	});
+
+	it("should have empty skills when resource loader returns none (--no-skills)", async () => {
+		const resourceLoader: ResourceLoader = {
+			getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
+			getSkills: () => ({ skills: [], diagnostics: [] }),
+			getPrompts: () => ({ prompts: [], diagnostics: [] }),
+			getThemes: () => ({ themes: [], diagnostics: [] }),
+			getAgentsFiles: () => ({ agentsFiles: [] }),
+			getSystemPrompt: () => undefined,
+			getAppendSystemPrompt: () => [],
+			extendResources: () => {},
+			reload: async () => {},
+		};
+
+		const { session } = await createAgentSession({
+			cwd: tempDir,
+			agentDir: tempDir,
+			sessionManager: SessionManager.inMemory(),
+			resourceLoader,
+		});
+
+		expect(session.resourceLoader.getSkills().skills).toEqual([]);
+		expect(session.resourceLoader.getSkills().diagnostics).toEqual([]);
+	});
+
+	it("should use provided skills when resource loader supplies them", async () => {
+		const customSkill = {
+			name: "custom-skill",
+			description: "A custom skill",
+			filePath: "/fake/path/SKILL.md",
+			baseDir: "/fake/path",
+			sourceInfo: createSyntheticSourceInfo("/fake/path/SKILL.md", { source: "sdk" }),
+			disableModelInvocation: false,
+		};
+
+		const resourceLoader: ResourceLoader = {
+			getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
+			getSkills: () => ({ skills: [customSkill], diagnostics: [] }),
+			getPrompts: () => ({ prompts: [], diagnostics: [] }),
+			getThemes: () => ({ themes: [], diagnostics: [] }),
+			getAgentsFiles: () => ({ agentsFiles: [] }),
+			getSystemPrompt: () => undefined,
+			getAppendSystemPrompt: () => [],
+			extendResources: () => {},
+			reload: async () => {},
+		};
+
+		const { session } = await createAgentSession({
+			cwd: tempDir,
+			agentDir: tempDir,
+			sessionManager: SessionManager.inMemory(),
+			resourceLoader,
+		});
+
+		expect(session.resourceLoader.getSkills().skills).toEqual([customSkill]);
+		expect(session.resourceLoader.getSkills().diagnostics).toEqual([]);
+	});
+});

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

@@ -0,0 +1,91 @@
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { type CreateAgentSessionRuntimeFactory, createAgentSessionRuntime } from "../src/core/agent-session-runtime.js";
+import { getMissingSessionCwdIssue, MissingSessionCwdError } from "../src/core/session-cwd.js";
+import { SessionManager } from "../src/core/session-manager.js";
+
+function createTempDir(name: string): string {
+	const dir = join(tmpdir(), `${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+function writeSessionFile(path: string, cwd: string): void {
+	writeFileSync(
+		path,
+		`${JSON.stringify({
+			type: "session",
+			version: 3,
+			id: "session-id",
+			timestamp: new Date().toISOString(),
+			cwd,
+		})}\n`,
+	);
+}
+
+describe("session cwd handling", () => {
+	const cleanupPaths: string[] = [];
+
+	afterEach(() => {
+		for (const path of cleanupPaths.splice(0)) {
+			rmSync(path, { recursive: true, force: true });
+		}
+	});
+
+	it("detects missing session cwd from persisted sessions", () => {
+		const fallbackCwd = createTempDir("pi-session-cwd-fallback");
+		const missingCwd = join(fallbackCwd, "does-not-exist");
+		const sessionDir = createTempDir("pi-session-cwd-session-dir");
+		const sessionFile = join(sessionDir, "session.jsonl");
+		cleanupPaths.push(fallbackCwd, sessionDir);
+		writeSessionFile(sessionFile, missingCwd);
+
+		const sessionManager = SessionManager.open(sessionFile);
+		const issue = getMissingSessionCwdIssue(sessionManager, fallbackCwd);
+		expect(issue).toEqual({
+			sessionFile: sessionManager.getSessionFile(),
+			sessionCwd: missingCwd,
+			fallbackCwd,
+		});
+	});
+
+	it("supports overriding the effective cwd when opening a session", () => {
+		const fallbackCwd = createTempDir("pi-session-cwd-override");
+		const missingCwd = join(fallbackCwd, "does-not-exist");
+		const sessionDir = createTempDir("pi-session-cwd-override-session-dir");
+		const sessionFile = join(sessionDir, "session.jsonl");
+		cleanupPaths.push(fallbackCwd, sessionDir);
+		writeSessionFile(sessionFile, missingCwd);
+
+		const sessionManager = SessionManager.open(sessionFile, undefined, fallbackCwd);
+		expect(sessionManager.getCwd()).toBe(fallbackCwd);
+		expect(getMissingSessionCwdIssue(sessionManager, fallbackCwd)).toBeUndefined();
+	});
+
+	it("throws a controlled error before runtime creation when the stored cwd is missing", async () => {
+		const fallbackCwd = createTempDir("pi-session-cwd-runtime");
+		const missingCwd = join(fallbackCwd, "does-not-exist");
+		const sessionDir = createTempDir("pi-session-cwd-runtime-session-dir");
+		const sessionFile = join(sessionDir, "session.jsonl");
+		cleanupPaths.push(fallbackCwd, sessionDir);
+		writeSessionFile(sessionFile, missingCwd);
+
+		const sessionManager = SessionManager.open(sessionFile);
+		let createRuntimeCalled = false;
+		const createRuntime: CreateAgentSessionRuntimeFactory = async () => {
+			createRuntimeCalled = true;
+			throw new Error("should not be called");
+		};
+
+		await expect(
+			createAgentSessionRuntime(createRuntime, {
+				cwd: fallbackCwd,
+				agentDir: fallbackCwd,
+				sessionManager,
+			}),
+		).rejects.toBeInstanceOf(MissingSessionCwdError);
+		expect(createRuntimeCalled).toBe(false);
+	});
+});

package/pi.dev-src/pi-mono/coding-agent/test/session-info-modified-timestamp.test.ts

@@ -0,0 +1,83 @@
+import { writeFileSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import type { SessionHeader } from "../src/core/session-manager.js";
+import { SessionManager } from "../src/core/session-manager.js";
+import { initTheme } from "../src/modes/interactive/theme/theme.js";
+
+function createSessionFile(path: string): void {
+	const header: SessionHeader = {
+		type: "session",
+		id: "test-session",
+		version: 3,
+		timestamp: new Date(0).toISOString(),
+		cwd: "/tmp",
+	};
+	writeFileSync(path, `${JSON.stringify(header)}\n`, "utf8");
+
+	// SessionManager only persists once it has seen at least one assistant message.
+	// Add a minimal assistant entry so subsequent appends are persisted.
+	const mgr = SessionManager.open(path);
+	mgr.appendMessage({
+		role: "assistant",
+		content: [{ type: "text", text: "hi" }],
+		api: "openai-completions",
+		provider: "openai",
+		model: "test",
+		usage: {
+			input: 1,
+			output: 1,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 2,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: Date.now(),
+	});
+}
+
+describe("SessionInfo.modified", () => {
+	beforeAll(() => initTheme("dark"));
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("uses last user/assistant message timestamp instead of file mtime", async () => {
+		const filePath = join(tmpdir(), `pi-session-${Date.now()}-modified.jsonl`);
+		createSessionFile(filePath);
+
+		const before = await stat(filePath);
+		// Ensure the file mtime can differ from our message timestamp even on coarse filesystems.
+		await new Promise((r) => setTimeout(r, 10));
+
+		const mgr = SessionManager.open(filePath);
+		const msgTime = Date.now();
+		mgr.appendMessage({
+			role: "assistant",
+			content: [{ type: "text", text: "later" }],
+			api: "openai-completions",
+			provider: "openai",
+			model: "test",
+			usage: {
+				input: 1,
+				output: 1,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 2,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+			},
+			stopReason: "stop",
+			timestamp: msgTime,
+		});
+
+		const sessions = await SessionManager.list("/tmp", dirname(filePath));
+		const s = sessions.find((x) => x.path === filePath);
+		expect(s).toBeDefined();
+		expect(s!.modified.getTime()).toBe(msgTime);
+		expect(s!.modified.getTime()).not.toBe(before.mtime.getTime());
+	});
+});

package/pi.dev-src/pi-mono/coding-agent/test/session-manager/build-context.test.ts

@@ -0,0 +1,268 @@
+import { describe, expect, it } from "vitest";
+import {
+	type BranchSummaryEntry,
+	buildSessionContext,
+	type CompactionEntry,
+	type ModelChangeEntry,
+	type SessionEntry,
+	type SessionMessageEntry,
+	type ThinkingLevelChangeEntry,
+} from "../../src/core/session-manager.js";
+
+function msg(id: string, parentId: string | null, role: "user" | "assistant", text: string): SessionMessageEntry {
+	const base = { type: "message" as const, id, parentId, timestamp: "2025-01-01T00:00:00Z" };
+	if (role === "user") {
+		return { ...base, message: { role, content: text, timestamp: 1 } };
+	}
+	return {
+		...base,
+		message: {
+			role,
+			content: [{ type: "text", text }],
+			api: "anthropic-messages",
+			provider: "anthropic",
+			model: "claude-test",
+			usage: {
+				input: 1,
+				output: 1,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 2,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+			},
+			stopReason: "stop",
+			timestamp: 1,
+		},
+	};
+}
+
+function compaction(id: string, parentId: string | null, summary: string, firstKeptEntryId: string): CompactionEntry {
+	return {
+		type: "compaction",
+		id,
+		parentId,
+		timestamp: "2025-01-01T00:00:00Z",
+		summary,
+		firstKeptEntryId,
+		tokensBefore: 1000,
+	};
+}
+
+function branchSummary(id: string, parentId: string | null, summary: string, fromId: string): BranchSummaryEntry {
+	return { type: "branch_summary", id, parentId, timestamp: "2025-01-01T00:00:00Z", summary, fromId };
+}
+
+function thinkingLevel(id: string, parentId: string | null, level: string): ThinkingLevelChangeEntry {
+	return { type: "thinking_level_change", id, parentId, timestamp: "2025-01-01T00:00:00Z", thinkingLevel: level };
+}
+
+function modelChange(id: string, parentId: string | null, provider: string, modelId: string): ModelChangeEntry {
+	return { type: "model_change", id, parentId, timestamp: "2025-01-01T00:00:00Z", provider, modelId };
+}
+
+describe("buildSessionContext", () => {
+	describe("trivial cases", () => {
+		it("empty entries returns empty context", () => {
+			const ctx = buildSessionContext([]);
+			expect(ctx.messages).toEqual([]);
+			expect(ctx.thinkingLevel).toBe("off");
+			expect(ctx.model).toBeNull();
+		});
+
+		it("single user message", () => {
+			const entries: SessionEntry[] = [msg("1", null, "user", "hello")];
+			const ctx = buildSessionContext(entries);
+			expect(ctx.messages).toHaveLength(1);
+			expect(ctx.messages[0].role).toBe("user");
+		});
+
+		it("simple conversation", () => {
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "hello"),
+				msg("2", "1", "assistant", "hi there"),
+				msg("3", "2", "user", "how are you"),
+				msg("4", "3", "assistant", "great"),
+			];
+			const ctx = buildSessionContext(entries);
+			expect(ctx.messages).toHaveLength(4);
+			expect(ctx.messages.map((m) => m.role)).toEqual(["user", "assistant", "user", "assistant"]);
+		});
+
+		it("tracks thinking level changes", () => {
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "hello"),
+				thinkingLevel("2", "1", "high"),
+				msg("3", "2", "assistant", "thinking hard"),
+			];
+			const ctx = buildSessionContext(entries);
+			expect(ctx.thinkingLevel).toBe("high");
+			expect(ctx.messages).toHaveLength(2);
+		});
+
+		it("tracks model from assistant message", () => {
+			const entries: SessionEntry[] = [msg("1", null, "user", "hello"), msg("2", "1", "assistant", "hi")];
+			const ctx = buildSessionContext(entries);
+			expect(ctx.model).toEqual({ provider: "anthropic", modelId: "claude-test" });
+		});
+
+		it("tracks model from model change entry", () => {
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "hello"),
+				modelChange("2", "1", "openai", "gpt-4"),
+				msg("3", "2", "assistant", "hi"),
+			];
+			const ctx = buildSessionContext(entries);
+			// Assistant message overwrites model change
+			expect(ctx.model).toEqual({ provider: "anthropic", modelId: "claude-test" });
+		});
+	});
+
+	describe("with compaction", () => {
+		it("includes summary before kept messages", () => {
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "first"),
+				msg("2", "1", "assistant", "response1"),
+				msg("3", "2", "user", "second"),
+				msg("4", "3", "assistant", "response2"),
+				compaction("5", "4", "Summary of first two turns", "3"),
+				msg("6", "5", "user", "third"),
+				msg("7", "6", "assistant", "response3"),
+			];
+			const ctx = buildSessionContext(entries);
+
+			// Should have: summary + kept (3,4) + after (6,7) = 5 messages
+			expect(ctx.messages).toHaveLength(5);
+			expect((ctx.messages[0] as any).summary).toContain("Summary of first two turns");
+			expect((ctx.messages[1] as any).content).toBe("second");
+			expect((ctx.messages[2] as any).content[0].text).toBe("response2");
+			expect((ctx.messages[3] as any).content).toBe("third");
+			expect((ctx.messages[4] as any).content[0].text).toBe("response3");
+		});
+
+		it("handles compaction keeping from first message", () => {
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "first"),
+				msg("2", "1", "assistant", "response"),
+				compaction("3", "2", "Empty summary", "1"),
+				msg("4", "3", "user", "second"),
+			];
+			const ctx = buildSessionContext(entries);
+
+			// Summary + all messages (1,2,4)
+			expect(ctx.messages).toHaveLength(4);
+			expect((ctx.messages[0] as any).summary).toContain("Empty summary");
+		});
+
+		it("multiple compactions uses latest", () => {
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "a"),
+				msg("2", "1", "assistant", "b"),
+				compaction("3", "2", "First summary", "1"),
+				msg("4", "3", "user", "c"),
+				msg("5", "4", "assistant", "d"),
+				compaction("6", "5", "Second summary", "4"),
+				msg("7", "6", "user", "e"),
+			];
+			const ctx = buildSessionContext(entries);
+
+			// Should use second summary, keep from 4
+			expect(ctx.messages).toHaveLength(4);
+			expect((ctx.messages[0] as any).summary).toContain("Second summary");
+		});
+	});
+
+	describe("with branches", () => {
+		it("follows path to specified leaf", () => {
+			// Tree:
+			//   1 -> 2 -> 3 (branch A)
+			//         \-> 4 (branch B)
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "start"),
+				msg("2", "1", "assistant", "response"),
+				msg("3", "2", "user", "branch A"),
+				msg("4", "2", "user", "branch B"),
+			];
+
+			const ctxA = buildSessionContext(entries, "3");
+			expect(ctxA.messages).toHaveLength(3);
+			expect((ctxA.messages[2] as any).content).toBe("branch A");
+
+			const ctxB = buildSessionContext(entries, "4");
+			expect(ctxB.messages).toHaveLength(3);
+			expect((ctxB.messages[2] as any).content).toBe("branch B");
+		});
+
+		it("includes branch summary in path", () => {
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "start"),
+				msg("2", "1", "assistant", "response"),
+				msg("3", "2", "user", "abandoned path"),
+				branchSummary("4", "2", "Summary of abandoned work", "3"),
+				msg("5", "4", "user", "new direction"),
+			];
+			const ctx = buildSessionContext(entries, "5");
+
+			expect(ctx.messages).toHaveLength(4);
+			expect((ctx.messages[2] as any).summary).toContain("Summary of abandoned work");
+			expect((ctx.messages[3] as any).content).toBe("new direction");
+		});
+
+		it("complex tree with multiple branches and compaction", () => {
+			// Tree:
+			//   1 -> 2 -> 3 -> 4 -> compaction(5) -> 6 -> 7 (main path)
+			//              \-> 8 -> 9 (abandoned branch)
+			//                    \-> branchSummary(10) -> 11 (resumed from 3)
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "start"),
+				msg("2", "1", "assistant", "r1"),
+				msg("3", "2", "user", "q2"),
+				msg("4", "3", "assistant", "r2"),
+				compaction("5", "4", "Compacted history", "3"),
+				msg("6", "5", "user", "q3"),
+				msg("7", "6", "assistant", "r3"),
+				// Abandoned branch from 3
+				msg("8", "3", "user", "wrong path"),
+				msg("9", "8", "assistant", "wrong response"),
+				// Branch summary resuming from 3
+				branchSummary("10", "3", "Tried wrong approach", "9"),
+				msg("11", "10", "user", "better approach"),
+			];
+
+			// Main path to 7: summary + kept(3,4) + after(6,7)
+			const ctxMain = buildSessionContext(entries, "7");
+			expect(ctxMain.messages).toHaveLength(5);
+			expect((ctxMain.messages[0] as any).summary).toContain("Compacted history");
+			expect((ctxMain.messages[1] as any).content).toBe("q2");
+			expect((ctxMain.messages[2] as any).content[0].text).toBe("r2");
+			expect((ctxMain.messages[3] as any).content).toBe("q3");
+			expect((ctxMain.messages[4] as any).content[0].text).toBe("r3");
+
+			// Branch path to 11: 1,2,3 + branch_summary + 11
+			const ctxBranch = buildSessionContext(entries, "11");
+			expect(ctxBranch.messages).toHaveLength(5);
+			expect((ctxBranch.messages[0] as any).content).toBe("start");
+			expect((ctxBranch.messages[1] as any).content[0].text).toBe("r1");
+			expect((ctxBranch.messages[2] as any).content).toBe("q2");
+			expect((ctxBranch.messages[3] as any).summary).toContain("Tried wrong approach");
+			expect((ctxBranch.messages[4] as any).content).toBe("better approach");
+		});
+	});
+
+	describe("edge cases", () => {
+		it("uses last entry when leafId not found", () => {
+			const entries: SessionEntry[] = [msg("1", null, "user", "hello"), msg("2", "1", "assistant", "hi")];
+			const ctx = buildSessionContext(entries, "nonexistent");
+			expect(ctx.messages).toHaveLength(2);
+		});
+
+		it("handles orphaned entries gracefully", () => {
+			const entries: SessionEntry[] = [
+				msg("1", null, "user", "hello"),
+				msg("2", "missing", "assistant", "orphan"), // parent doesn't exist
+			];
+			const ctx = buildSessionContext(entries, "2");
+			// Should only get the orphan since parent chain is broken
+			expect(ctx.messages).toHaveLength(1);
+		});
+	});
+});

package/pi.dev-src/pi-mono/coding-agent/test/session-manager/custom-session-id.test.ts

@@ -0,0 +1,109 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { SessionManager } from "../../src/core/session-manager.js";
+
+const UUID_V7_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+describe("SessionManager.newSession with custom id", () => {
+	it("uses the provided id instead of generating one", () => {
+		const session = SessionManager.inMemory();
+		session.newSession({ id: "my-custom-id" });
+		expect(session.getSessionId()).toBe("my-custom-id");
+	});
+
+	it("generates a UUIDv7 id when no id is provided", () => {
+		const session = SessionManager.inMemory();
+		session.newSession();
+		const id = session.getSessionId();
+		expect(id).toBeDefined();
+		expect(id).not.toBe("");
+		expect(id).toMatch(UUID_V7_RE);
+	});
+
+	it("generates a UUIDv7 id when options is provided without id", () => {
+		const session = SessionManager.inMemory();
+		session.newSession({ parentSession: "parent.jsonl" });
+		const id = session.getSessionId();
+		expect(id).toBeDefined();
+		expect(id).not.toBe("");
+		expect(id).toMatch(UUID_V7_RE);
+	});
+
+	it("includes the custom id in the session header", () => {
+		const session = SessionManager.inMemory();
+		session.newSession({ id: "header-test-id" });
+
+		const header = session.getHeader();
+		expect(header).not.toBeNull();
+		expect(header!.id).toBe("header-test-id");
+	});
+
+	it("generates a UUIDv7 id when constructed without an explicit id", () => {
+		const session = SessionManager.inMemory();
+		expect(session.getSessionId()).toMatch(UUID_V7_RE);
+		expect(session.getHeader()!.id).toBe(session.getSessionId());
+	});
+
+	it("generates a UUIDv7 id when creating a branched session", () => {
+		const session = SessionManager.inMemory();
+		const firstId = session.appendMessage({
+			role: "user",
+			content: [{ type: "text", text: "hello" }],
+			timestamp: Date.now(),
+		});
+
+		session.createBranchedSession(firstId);
+
+		expect(session.getSessionId()).toMatch(UUID_V7_RE);
+		expect(session.getHeader()!.id).toBe(session.getSessionId());
+	});
+
+	it("generates a UUIDv7 id when forking from another session file", () => {
+		const tempDir = mkdtempSync(join(tmpdir(), "pi-session-manager-"));
+		const sourcePath = join(tempDir, "source.jsonl");
+		writeFileSync(
+			sourcePath,
+			`${[
+				JSON.stringify({
+					type: "session",
+					version: 3,
+					id: "legacy-session-id",
+					timestamp: new Date().toISOString(),
+					cwd: tempDir,
+				}),
+				JSON.stringify({
+					type: "message",
+					id: "entry-1",
+					parentId: null,
+					timestamp: new Date().toISOString(),
+					message: {
+						role: "assistant",
+						content: [{ type: "text", text: "hello" }],
+						api: "openai-responses",
+						provider: "openai",
+						model: "gpt-5.4",
+						usage: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							totalTokens: 0,
+							cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+						},
+						stopReason: "stop",
+						timestamp: Date.now(),
+					},
+				}),
+			].join("\n")}
+`,
+		);
+
+		const forked = SessionManager.forkFrom(sourcePath, tempDir, tempDir);
+		const header = forked.getHeader();
+		expect(header).not.toBeNull();
+		expect(header!.id).toMatch(UUID_V7_RE);
+		expect(header!.parentSession).toBe(sourcePath);
+	});
+});