@clinebot/core 0.0.28 → 0.0.30

package/src/session/default-session-manager.test.ts

@@ -1,7 +1,8 @@
+import { execFileSync } from "node:child_process";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { AgentResult } from "@clinebot/agents";
+import type { AgentResult } from "@clinebot/shared";
 import { setClineDir, setHomeDir } from "@clinebot/shared/storage";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { TelemetryService } from "../telemetry/TelemetryService";
@@ -126,10 +127,30 @@ function createConfig(
 	};
 }
 
+function createGitRepo(cwd: string): void {
+	execFileSync("git", ["-C", cwd, "init"], { stdio: "pipe" });
+	execFileSync("git", ["-C", cwd, "config", "user.name", "Codex Test"], {
+		stdio: "pipe",
+	});
+	execFileSync(
+		"git",
+		["-C", cwd, "config", "user.email", "codex@example.com"],
+		{
+			stdio: "pipe",
+		},
+	);
+	writeFileSync(join(cwd, "note.txt"), "base\n", "utf8");
+	execFileSync("git", ["-C", cwd, "add", "note.txt"], { stdio: "pipe" });
+	execFileSync("git", ["-C", cwd, "commit", "-m", "initial"], {
+		stdio: "pipe",
+	});
+}
+
 describe("DefaultSessionManager", () => {
 	const envSnapshot = {
 		HOME: process.env.HOME,
 		CLINE_DIR: process.env.CLINE_DIR,
+		CLINE_CHECKPOINT: process.env.CLINE_CHECKPOINT,
 	};
 	let isolatedHomeDir = "";
 
@@ -137,6 +158,7 @@ describe("DefaultSessionManager", () => {
 		isolatedHomeDir = mkdtempSync(join(tmpdir(), "core-session-home-"));
 		process.env.HOME = isolatedHomeDir;
 		process.env.CLINE_DIR = join(isolatedHomeDir, ".cline");
+		delete process.env.CLINE_CHECKPOINT;
 		setHomeDir(isolatedHomeDir);
 		setClineDir(process.env.CLINE_DIR);
 	});
@@ -144,6 +166,7 @@ describe("DefaultSessionManager", () => {
 	afterEach(() => {
 		process.env.HOME = envSnapshot.HOME;
 		process.env.CLINE_DIR = envSnapshot.CLINE_DIR;
+		process.env.CLINE_CHECKPOINT = envSnapshot.CLINE_CHECKPOINT;
 		setHomeDir(envSnapshot.HOME ?? "~");
 		setClineDir(envSnapshot.CLINE_DIR ?? join("~", ".cline"));
 		rmSync(isolatedHomeDir, { recursive: true, force: true });
@@ -314,6 +337,102 @@ describe("DefaultSessionManager", () => {
 		expect(started.manifest.source).toBe("kanban");
 	});
 
+	it("reuses the persisted team name when resuming a session", async () => {
+		const sessionId = "sess-team-resume";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				transcriptPath: "/tmp/transcript.log",
+				hookPath: "/tmp/hook.log",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([
+				{
+					sessionId,
+					source: SessionSource.CLI,
+					pid: process.pid,
+					startedAt: "2026-01-01T00:00:00.000Z",
+					endedAt: null,
+					exitCode: null,
+					status: "running",
+					statusLock: 0,
+					interactive: true,
+					provider: "mock-provider",
+					model: "mock-model",
+					cwd: "/tmp/project",
+					workspaceRoot: "/tmp/project",
+					teamName: "persisted-team",
+					enableTools: true,
+					enableSpawn: true,
+					enableTeams: true,
+					parentSessionId: null,
+					parentAgentId: null,
+					agentId: null,
+					conversationId: null,
+					isSubagent: false,
+					prompt: null,
+					metadata: null,
+					transcriptPath: "/tmp/transcript.log",
+					hookPath: "/tmp/hook.log",
+					messagesPath: "/tmp/messages.json",
+					updatedAt: "2026-01-01T00:00:00.000Z",
+				},
+			]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				teamRuntime: {
+					getTeamId: vi.fn().mockReturnValue("team_persisted-team"),
+					getTeamName: vi.fn().mockReturnValue("persisted-team"),
+				},
+				teamRestoredFromPersistence: true,
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			getAgentId: vi.fn().mockReturnValue("agent-root-1"),
+			getConversationId: vi.fn().mockReturnValue("conv-root-1"),
+			abort: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId, teamName: undefined }),
+		});
+
+		expect(runtimeBuilder.build).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					sessionId,
+					teamName: "persisted-team",
+				}),
+			}),
+		);
+		expect(
+			sessionService.createRootSessionWithArtifacts,
+		).not.toHaveBeenCalled();
+	});
+
 	it("runs a non-interactive prompt and persists messages/status", async () => {
 		const sessionId = "sess-1";
 		const manifest = createManifest(sessionId);
@@ -389,6 +508,335 @@ describe("DefaultSessionManager", () => {
 		expect(shutdown).toHaveBeenCalledTimes(1);
 	});
 
+	it("preserves manifest metadata updates and persists total cost", async () => {
+		const sessionId = "sess-history-meta";
+		let storedManifest: SessionManifest = {
+			...createManifest(sessionId),
+			metadata: {
+				checkpoint: {
+					latest: {
+						ref: "abc123",
+						createdAt: 1,
+						runCount: 1,
+					},
+					history: [
+						{
+							ref: "abc123",
+							createdAt: 1,
+							runCount: 1,
+						},
+					],
+				},
+			},
+		};
+		const createRootSessionWithArtifacts = vi.fn().mockResolvedValue({
+			manifestPath: "/tmp/manifest-history-meta.json",
+			transcriptPath: "/tmp/transcript-history-meta.log",
+			hookPath: "/tmp/hook-history-meta.log",
+			messagesPath: "/tmp/messages-history-meta.json",
+			manifest: { ...storedManifest },
+		});
+		const persistSessionMessages = vi.fn();
+		const updateSession = vi.fn().mockImplementation(async (input) => {
+			storedManifest = {
+				...storedManifest,
+				metadata: input.metadata,
+			};
+			return { updated: true };
+		});
+		const updateSessionStatus = vi.fn().mockResolvedValue({
+			updated: true,
+			endedAt: "2026-01-01T00:00:05.000Z",
+		});
+		const readSessionManifest = vi
+			.fn()
+			.mockImplementation(() => storedManifest);
+		const writeSessionManifest = vi
+			.fn()
+			.mockImplementation((_path, manifest) => {
+				storedManifest = manifest;
+			});
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts,
+			persistSessionMessages,
+			updateSession,
+			updateSessionStatus,
+			readSessionManifest,
+			writeSessionManifest,
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(
+				createResult({
+					usage: {
+						inputTokens: 3,
+						outputTokens: 4,
+						totalCost: 0.42,
+					},
+					messages: [
+						{ role: "user", content: [{ type: "text", text: "hello" }] },
+					],
+				}),
+			),
+			continue: vi.fn(),
+			abort: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		};
+
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId }),
+			prompt: "hello",
+			interactive: false,
+		});
+
+		expect(updateSession).toHaveBeenCalledWith({
+			sessionId,
+			metadata: {
+				checkpoint: {
+					latest: {
+						ref: "abc123",
+						createdAt: 1,
+						runCount: 1,
+					},
+					history: [
+						{
+							ref: "abc123",
+							createdAt: 1,
+							runCount: 1,
+						},
+					],
+				},
+				totalCost: 0.42,
+			},
+		});
+		expect(writeSessionManifest).toHaveBeenCalledWith(
+			"/tmp/manifest-history-meta.json",
+			expect.objectContaining({
+				metadata: {
+					checkpoint: {
+						latest: {
+							ref: "abc123",
+							createdAt: 1,
+							runCount: 1,
+						},
+						history: [
+							{
+								ref: "abc123",
+								createdAt: 1,
+								runCount: 1,
+							},
+						],
+					},
+					totalCost: 0.42,
+				},
+				status: "completed",
+			}),
+		);
+	});
+
+	it("does not install checkpoint hooks unless CLINE_CHECKPOINT=true", async () => {
+		const sessionId = "sess-checkpoint-default-off";
+		const manifest = createManifest(sessionId);
+		const updateSession = vi.fn().mockResolvedValue({ updated: true });
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-checkpoint-default-off.json",
+				transcriptPath: "/tmp/transcript-checkpoint-default-off.log",
+				hookPath: "/tmp/hook-checkpoint-default-off.log",
+				messagesPath: "/tmp/messages-checkpoint-default-off.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSession,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([
+				{
+					sessionId,
+					provider: "mock-provider",
+					model: "mock-model",
+					cwd: "/tmp/project",
+					workspaceRoot: "/tmp/project",
+					createdAt: "2026-01-01T00:00:00.000Z",
+					updatedAt: "2026-01-01T00:00:00.000Z",
+					status: "running",
+					metadata: undefined,
+				},
+			]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockImplementation(() => {
+				return {
+					tools: [],
+					shutdown: vi.fn(),
+				};
+			}),
+		};
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: (config) =>
+				({
+					run: vi.fn().mockImplementation(async () => {
+						await config.hooks?.onRunStart?.({
+							agentId: "agent_1",
+							conversationId: "conv_1",
+							parentAgentId: null,
+							userMessage: "hello",
+						});
+						await config.hooks?.onBeforeAgentStart?.({
+							agentId: "agent_1",
+							conversationId: "conv_1",
+							parentAgentId: null,
+							iteration: 1,
+							systemPrompt: "system",
+							messages: [],
+						});
+						return createResult();
+					}),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId }),
+			prompt: "hello",
+			interactive: false,
+		});
+		expect(updateSession).toHaveBeenCalledTimes(1);
+		expect(updateSession).toHaveBeenLastCalledWith({
+			sessionId,
+			metadata: {
+				totalCost: 0,
+			},
+		});
+	});
+
+	it("installs checkpoint hooks when CLINE_CHECKPOINT=true", async () => {
+		process.env.CLINE_CHECKPOINT = "true";
+
+		const sessionId = "sess-checkpoint-env-on";
+		const repoCwd = mkdtempSync(join(isolatedHomeDir, "checkpoint-repo-"));
+		createGitRepo(repoCwd);
+		const manifest = createManifest(sessionId);
+		const updateSession = vi.fn().mockResolvedValue({ updated: true });
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-checkpoint-env-on.json",
+				transcriptPath: "/tmp/transcript-checkpoint-env-on.log",
+				hookPath: "/tmp/hook-checkpoint-env-on.log",
+				messagesPath: "/tmp/messages-checkpoint-env-on.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSession,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([
+				{
+					sessionId,
+					provider: "mock-provider",
+					model: "mock-model",
+					cwd: repoCwd,
+					workspaceRoot: repoCwd,
+					createdAt: "2026-01-01T00:00:00.000Z",
+					updatedAt: "2026-01-01T00:00:00.000Z",
+					status: "running",
+					metadata: undefined,
+				},
+			]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockImplementation(() => {
+				return {
+					tools: [],
+					shutdown: vi.fn(),
+				};
+			}),
+		};
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: (config) =>
+				({
+					run: vi.fn().mockImplementation(async () => {
+						await config.hooks?.onRunStart?.({
+							agentId: "agent_1",
+							conversationId: "conv_1",
+							parentAgentId: null,
+							userMessage: "hello",
+						});
+						await config.hooks?.onBeforeAgentStart?.({
+							agentId: "agent_1",
+							conversationId: "conv_1",
+							parentAgentId: null,
+							iteration: 1,
+							systemPrompt: "system",
+							messages: [],
+						});
+						return createResult();
+					}),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId, cwd: repoCwd }),
+			prompt: "hello",
+			interactive: false,
+		});
+		expect(updateSession).toHaveBeenCalledTimes(2);
+		expect(updateSession).toHaveBeenNthCalledWith(1, {
+			sessionId,
+			metadata: expect.objectContaining({
+				checkpoint: expect.objectContaining({
+					latest: expect.objectContaining({
+						ref: expect.stringMatching(/^[0-9a-f]{40}$/),
+						runCount: 1,
+					}),
+				}),
+			}),
+		});
+		expect(updateSession).toHaveBeenNthCalledWith(2, {
+			sessionId,
+			metadata: expect.objectContaining({
+				totalCost: 0,
+			}),
+		});
+	});
+
 	it("persists assistant message metadata for usage and model identity", async () => {
 		const sessionId = "sess-meta";
 		const manifest = createManifest(sessionId);
@@ -432,6 +880,10 @@ describe("DefaultSessionManager", () => {
 				model: {
 					id: "claude-sonnet-4-6",
 					provider: "anthropic",
+					info: {
+						id: "claude-sonnet-4-6",
+						family: "claude-sonnet-4",
+					},
 				},
 				endedAt: new Date("2026-01-01T00:00:02.000Z"),
 				messages: [
@@ -470,11 +922,10 @@ describe("DefaultSessionManager", () => {
 		expect(Array.isArray(persisted)).toBe(true);
 		expect(persisted?.[1]).toMatchObject({
 			role: "assistant",
-			providerId: "anthropic",
-			modelId: "claude-sonnet-4-6",
 			modelInfo: {
 				id: "claude-sonnet-4-6",
 				provider: "anthropic",
+				family: "claude-sonnet-4",
 			},
 			metrics: {
 				inputTokens: 33,
@@ -1458,6 +1909,67 @@ describe("DefaultSessionManager", () => {
 		);
 	});
 
+	it("injects a core-owned compaction prepareTurn callback into the agent constructor", async () => {
+		const sessionId = "sess-compaction";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-compaction.json",
+				transcriptPath: "/tmp/transcript-compaction.log",
+				hookPath: "/tmp/hook-compaction.log",
+				messagesPath: "/tmp/messages-compaction.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const run = vi.fn().mockResolvedValue(createResult());
+		const createAgent = vi.fn().mockReturnValue({
+			run,
+			continue: vi.fn(),
+			abort: vi.fn(),
+			restore: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		});
+		const compact = vi.fn();
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: createAgent as never,
+		});
+
+		await manager.start({
+			config: createConfig({
+				sessionId,
+				compaction: {
+					enabled: true,
+					strategy: "basic",
+					compact,
+				},
+			}),
+			interactive: true,
+		});
+		await manager.send({ sessionId, prompt: "test" });
+
+		expect(createAgent).toHaveBeenCalledWith(
+			expect.objectContaining({
+				prepareTurn: expect.any(Function),
+			}),
+		);
+	});
+
 	it("formats prompt in core and merges explicit + mention user files", async () => {
 		const tempCwd = mkdtempSync(join(tmpdir(), "core-session-format-"));
 		try {
@@ -1690,13 +2202,29 @@ describe("DefaultSessionManager", () => {
 					},
 				});
 			}, 0);
-			return createResult({ text: "lead scheduled teammate" });
+			return createResult({
+				text: "lead scheduled teammate",
+				messages: [
+					{ role: "user", content: "run teammate work" },
+					{ role: "assistant", content: "lead scheduled teammate" },
+				],
+			});
 		});
-		const continueFn = vi
-			.fn()
-			.mockResolvedValue(
-				createResult({ text: "lead processed teammate result" }),
-			);
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				text: "lead processed teammate result",
+				messages: [
+					{ role: "user", content: "run teammate work" },
+					{ role: "assistant", content: "lead scheduled teammate" },
+					{
+						role: "user",
+						content:
+							"System-delivered teammate async run updates:\n- investigator completed",
+					},
+					{ role: "assistant", content: "lead processed teammate result" },
+				],
+			}),
+		);
 		const manager = new DefaultSessionManager({
 			distinctId,
 			sessionService: sessionService as never,
@@ -1727,6 +2255,21 @@ describe("DefaultSessionManager", () => {
 		expect(continueFn.mock.calls[0]?.[0]).toContain(
 			"System-delivered teammate async run updates:",
 		);
+		const finalPersistedMessages = (
+			sessionService.persistSessionMessages as ReturnType<typeof vi.fn>
+		).mock.calls.at(-1)?.[1] as Array<Record<string, unknown>> | undefined;
+		expect(finalPersistedMessages?.at(-1)).toMatchObject({
+			role: "assistant",
+			metrics: {
+				inputTokens: 1,
+				outputTokens: 2,
+				cost: 0,
+			},
+			modelInfo: {
+				id: "mock-model",
+				provider: "mock-provider",
+			},
+		});
 		expect(sessionService.updateSessionStatus).toHaveBeenCalledWith(
 			sessionId,
 			"completed",
@@ -1814,6 +2357,7 @@ describe("DefaultSessionManager", () => {
 			"providers-investigator",
 			"failed",
 			"[error] 401 Unauthorized",
+			undefined,
 			failedMessages,
 		);
 	});