@clinebot/core 0.0.0 → 0.0.2

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

@@ -155,14 +155,24 @@ class LocalFileSessionService {
 	persistSessionMessages(
 		sessionId: string,
 		messages: LlmsProviders.Message[],
+		systemPrompt?: string,
 	): void {
 		const row = this.rows.get(sessionId);
 		if (!row?.messages_path) {
 			throw new Error(`session not found: ${sessionId}`);
 		}
+		const payload: {
+			version: number;
+			updated_at: string;
+			systemPrompt?: string;
+			messages: LlmsProviders.Message[];
+		} = { version: 1, updated_at: nowIso(), messages };
+		if (systemPrompt !== undefined && systemPrompt !== "") {
+			payload.systemPrompt = systemPrompt;
+		}
 		writeFileSync(
 			row.messages_path,
-			`${JSON.stringify({ version: 1, updated_at: nowIso(), messages }, null, 2)}\n`,
+			`${JSON.stringify(payload, null, 2)}\n`,
 			"utf8",
 		);
 	}

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

@@ -237,6 +237,75 @@ describe("DefaultSessionManager", () => {
 		});
 	});
 
+	it("persists rendered messages when a turn fails", async () => {
+		const sessionId = "sess-failed-turn";
+		const manifest = createManifest(sessionId);
+		const persistSessionMessages = vi.fn();
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-failed-turn.json",
+				transcriptPath: "/tmp/transcript-failed-turn.log",
+				hookPath: "/tmp/hook-failed-turn.log",
+				messagesPath: "/tmp/messages-failed-turn.json",
+				manifest,
+			}),
+			persistSessionMessages,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const renderedMessages = [
+			{ role: "user", content: [{ type: "text", text: "hello" }] },
+			{ role: "assistant", content: [{ type: "text", text: "partial" }] },
+		];
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockRejectedValue(new Error("boom")),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					restore: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi
+						.fn()
+						.mockReturnValueOnce([])
+						.mockReturnValue(renderedMessages),
+					messages: [],
+				}) as never,
+		});
+
+		await expect(
+			manager.start({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: false,
+			}),
+		).rejects.toThrow("boom");
+
+		expect(persistSessionMessages).toHaveBeenCalledTimes(1);
+		expect(persistSessionMessages).toHaveBeenCalledWith(
+			sessionId,
+			renderedMessages,
+			"You are a test agent",
+		);
+		expect(sessionService.updateSessionStatus).toHaveBeenCalledWith(
+			sessionId,
+			"failed",
+			1,
+		);
+	});
+
 	it("uses run for first send then continue for subsequent sends", async () => {
 		const sessionId = "sess-2";
 		const manifest = createManifest(sessionId);
@@ -294,6 +363,123 @@ describe("DefaultSessionManager", () => {
 		expect(sessionService.persistSessionMessages).toHaveBeenCalledTimes(2);
 	});
 
+	it("tracks accumulated usage per session across turns", async () => {
+		const sessionId = "sess-usage";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-usage.json",
+				transcriptPath: "/tmp/transcript-usage.log",
+				hookPath: "/tmp/hook-usage.log",
+				messagesPath: "/tmp/messages-usage.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 runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				text: "first",
+				usage: {
+					inputTokens: 10,
+					outputTokens: 3,
+					cacheReadTokens: 1,
+					cacheWriteTokens: 2,
+					totalCost: 0.11,
+				},
+			}),
+		);
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				text: "second",
+				usage: {
+					inputTokens: 8,
+					outputTokens: 4,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 0,
+					totalCost: 0.09,
+				},
+			}),
+		);
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					abort: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId }),
+			interactive: true,
+		});
+
+		await manager.send({ sessionId, prompt: "first" });
+		expect(await manager.getAccumulatedUsage(sessionId)).toEqual({
+			inputTokens: 10,
+			outputTokens: 3,
+			cacheReadTokens: 1,
+			cacheWriteTokens: 2,
+			totalCost: 0.11,
+		});
+
+		await manager.send({ sessionId, prompt: "second" });
+		expect(await manager.getAccumulatedUsage(sessionId)).toEqual({
+			inputTokens: 18,
+			outputTokens: 7,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 2,
+			totalCost: 0.2,
+		});
+	});
+
+	it("returns undefined accumulated usage for unknown sessions", async () => {
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				listSessions: vi.fn().mockResolvedValue([]),
+				deleteSession: vi.fn().mockResolvedValue({ deleted: false }),
+			} as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: () =>
+				({
+					run: vi.fn(),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		expect(
+			await manager.getAccumulatedUsage("missing-session"),
+		).toBeUndefined();
+	});
+
 	it("marks a failed single-run session as failed when run throws", async () => {
 		const sessionId = "sess-fail";
 		const manifest = createManifest(sessionId);
@@ -813,4 +999,88 @@ describe("DefaultSessionManager", () => {
 			0,
 		);
 	});
+
+	it("persists failed teammate task messages for team-task sub-sessions", async () => {
+		const sessionId = "sess-team-task-failure-messages";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-team-task-failure-messages.json",
+				transcriptPath: "/tmp/transcript-team-task-failure-messages.log",
+				hookPath: "/tmp/hook-team-task-failure-messages.log",
+				messagesPath: "/tmp/messages-team-task-failure-messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			onTeamTaskStart: vi.fn().mockResolvedValue(undefined),
+			onTeamTaskEnd: vi.fn().mockResolvedValue(undefined),
+		};
+
+		let onTeamEvent: ((event: unknown) => void) | undefined;
+		const runtimeBuilder = {
+			build: vi
+				.fn()
+				.mockImplementation(
+					(input: { onTeamEvent?: (event: unknown) => void }) => {
+						onTeamEvent = input.onTeamEvent;
+						return {
+							tools: [],
+							shutdown: vi.fn(),
+						};
+					},
+				),
+		};
+
+		const failedMessages = [
+			{ role: "user", content: [{ type: "text", text: "delegated prompt" }] },
+			{ role: "assistant", content: [{ type: "text", text: "partial work" }] },
+		];
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockImplementation(async () => {
+						onTeamEvent?.({
+							type: "task_start",
+							agentId: "providers-investigator",
+							message: "Investigate provider boundaries",
+						});
+						onTeamEvent?.({
+							type: "task_end",
+							agentId: "providers-investigator",
+							error: new Error("401 Unauthorized"),
+							messages: failedMessages,
+						});
+						return createResult({ text: "lead handled failure" });
+					}),
+					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: "run teammate work",
+			interactive: false,
+		});
+
+		expect(sessionService.onTeamTaskStart).toHaveBeenCalledTimes(1);
+		expect(sessionService.onTeamTaskEnd).toHaveBeenCalledWith(
+			sessionId,
+			"providers-investigator",
+			"failed",
+			"[error] 401 Unauthorized",
+			failedMessages,
+		);
+	});
 });