@clinebot/core 0.0.28 → 0.0.30

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

@@ -2,30 +2,30 @@ import { existsSync, readFileSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
+import { Agent } from "@clinebot/agents";
+import type * as LlmsProviders from "@clinebot/llms";
 import {
-	Agent,
 	type AgentConfig,
 	type AgentEvent,
 	type AgentResult,
-	createSpawnAgentTool,
-	type TeamEvent,
-	type Tool,
-	type ToolApprovalRequest,
-	type ToolApprovalResult,
-} from "@clinebot/agents";
-import type * as LlmsProviders from "@clinebot/llms/providers";
-import {
 	createSessionId,
 	type ITelemetryService,
 	isLikelyAuthError,
 	normalizeUserInput,
+	type Tool,
+	type ToolApprovalRequest,
+	type ToolApprovalResult,
 } from "@clinebot/shared";
 import { setHomeDirIfUnset } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
+import { createContextCompactionPrepareTurn } from "../extensions/context/compaction";
 import { enrichPromptWithMentions } from "../input";
+import { createCheckpointHooks } from "../runtime/checkpoint-hooks";
+import { mergeAgentHooks } from "../runtime/hook-file-hooks";
 import { DefaultRuntimeBuilder } from "../runtime/runtime-builder";
 import type { RuntimeBuilder } from "../runtime/session-runtime";
 import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+import { createSpawnAgentTool, type TeamEvent } from "../team";
 import {
 	captureAgentCreated,
 	captureAgentTeamCreated,
@@ -35,7 +35,12 @@ import {
 	captureTaskCompleted,
 } from "../telemetry/core-events";
 import { resolveCoreDistinctId } from "../telemetry/distinct-id";
-import { createBuiltinTools, type ToolExecutors, ToolPresets } from "../tools";
+import {
+	createBuiltinTools,
+	resolveToolPresetName,
+	type ToolExecutors,
+	ToolPresets,
+} from "../tools";
 import { SessionSource, type SessionStatus } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
 import type { CoreSessionEvent } from "../types/events";
@@ -67,7 +72,10 @@ import type {
 	StartSessionInput,
 	StartSessionResult,
 } from "./session-manager";
-import { SessionManifestSchema } from "./session-manifest";
+import {
+	type SessionManifest,
+	SessionManifestSchema,
+} from "./session-manifest";
 import type {
 	CoreSessionService,
 	RootSessionArtifacts,
@@ -89,7 +97,6 @@ import {
 	emitSessionCreationTelemetry,
 } from "./session-telemetry";
 import {
-	extractWorkspaceMetadataFromSystemPrompt,
 	toSessionRecord,
 	withLatestAssistantTurnMetadata,
 } from "./utils/helpers";
@@ -98,6 +105,7 @@ import {
 	accumulateUsageTotals,
 	createInitialAccumulatedUsage,
 } from "./utils/usage";
+import { buildWorkspaceMetadata } from "./workspace-manifest";
 
 type SessionBackend =
 	| CoreSessionService
@@ -107,6 +115,11 @@ type SessionBackend =
 const MAX_SCAN_LIMIT = 5000;
 const MAX_USER_FILE_BYTES = 20 * 1_000 * 1_024;
 
+// NOTE: Temporarily disabled until checkpoint is ready for production.
+function isCheckpointFeatureEnabled(): boolean {
+	return process?.env?.CLINE_CHECKPOINT === "true";
+}
+
 async function loadUserFileContent(path: string): Promise<string> {
 	const fileStat = await stat(path);
 	if (!fileStat.isFile()) {
@@ -187,6 +200,21 @@ export class DefaultSessionManager implements SessionManager {
 		const startedAt = nowIso();
 		const requestedSessionId = input.config.sessionId?.trim() ?? "";
 		const sessionId = requestedSessionId || createSessionId();
+		const resumedRow = requestedSessionId
+			? await this.getRow(sessionId)
+			: undefined;
+		const startInput: StartSessionInput =
+			resumedRow &&
+			!input.config.teamName?.trim() &&
+			resumedRow.teamName?.trim()
+				? {
+						...input,
+						config: {
+							...input.config,
+							teamName: resumedRow.teamName,
+						},
+					}
+				: input;
 		this.usageBySession.set(sessionId, createInitialAccumulatedUsage());
 
 		const sessionsDir =
@@ -214,26 +242,29 @@ export class DefaultSessionManager implements SessionManager {
 			started_at: startedAt,
 			status: "running",
 			interactive: input.interactive === true,
-			provider: input.config.providerId,
-			model: input.config.modelId,
-			cwd: input.config.cwd,
+			provider: startInput.config.providerId,
+			model: startInput.config.modelId,
+			cwd: startInput.config.cwd,
 			workspace_root: workspacePath,
-			team_name: input.config.teamName,
-			enable_tools: input.config.enableTools,
-			enable_spawn: input.config.enableSpawnAgent,
-			enable_teams: input.config.enableAgentTeams,
-			prompt: input.prompt?.trim() || undefined,
+			team_name: startInput.config.teamName,
+			enable_tools: startInput.config.enableTools,
+			enable_spawn: startInput.config.enableSpawnAgent,
+			enable_teams: startInput.config.enableAgentTeams,
+			prompt: startInput.prompt?.trim() || undefined,
 			messages_path: messagesPath,
 		});
 
 		const { config: effectiveConfig, pluginSandboxShutdown } =
 			await buildEffectiveConfig(
-				input,
+				startInput,
 				hookPath,
 				sessionId,
 				this.defaultTelemetry,
 				(e) => void this.handlePluginEvent(sessionId, e),
 			);
+		const workspaceMetadata = await buildWorkspaceMetadata(
+			startInput.config.cwd,
+		);
 		const providerConfig = buildResolvedProviderConfig(
 			effectiveConfig,
 			this.providerSettingsManager,
@@ -242,11 +273,29 @@ export class DefaultSessionManager implements SessionManager {
 		const configWithProvider: CoreSessionConfig = {
 			...effectiveConfig,
 			providerConfig,
+			workspaceMetadata,
 		};
+		configWithProvider.hooks = mergeAgentHooks([
+			effectiveConfig.hooks,
+			isCheckpointFeatureEnabled()
+				? createCheckpointHooks({
+						cwd: configWithProvider.cwd,
+						sessionId,
+						logger: configWithProvider.logger,
+						readSessionMetadata: async () =>
+							(await this.get(sessionId))?.metadata as
+								| Record<string, unknown>
+								| undefined,
+						writeSessionMetadata: async (metadata) => {
+							await this.persistSessionMetadata(sessionId, () => metadata);
+						},
+					})
+				: undefined,
+		]);
 
-		const runtime = this.runtimeBuilder.build({
+		const runtime = await this.runtimeBuilder.build({
 			config: configWithProvider,
-			hooks: effectiveConfig.hooks,
+			hooks: configWithProvider.hooks,
 			extensions: effectiveConfig.extensions,
 			logger: configWithProvider.logger,
 			telemetry: configWithProvider.telemetry,
@@ -260,6 +309,7 @@ export class DefaultSessionManager implements SessionManager {
 			userInstructionWatcher: input.userInstructionWatcher,
 			defaultToolExecutors:
 				input.defaultToolExecutors ?? this.defaultToolExecutors,
+			teamToolsFactory: input.teamToolsFactory,
 		});
 		if (runtime.teamRuntime && !configWithProvider.teamName?.trim()) {
 			configWithProvider.teamName = runtime.teamRuntime.getTeamName();
@@ -267,7 +317,7 @@ export class DefaultSessionManager implements SessionManager {
 
 		const tools = [...runtime.tools, ...(configWithProvider.extraTools ?? [])];
 
-		const agent = this.createAgentInstance({
+		const agentConfig = {
 			providerId: providerConfig.providerId,
 			modelId: providerConfig.modelId,
 			apiKey: providerConfig.apiKey,
@@ -281,8 +331,9 @@ export class DefaultSessionManager implements SessionManager {
 			systemPrompt: configWithProvider.systemPrompt,
 			maxIterations: configWithProvider.maxIterations,
 			execution: configWithProvider.execution,
+			prepareTurn: createContextCompactionPrepareTurn(configWithProvider),
 			tools,
-			hooks: effectiveConfig.hooks,
+			hooks: configWithProvider.hooks,
 			extensions: effectiveConfig.extensions,
 			hookErrorMode: configWithProvider.hookErrorMode,
 			initialMessages: input.initialMessages,
@@ -293,10 +344,14 @@ export class DefaultSessionManager implements SessionManager {
 			onConsecutiveMistakeLimitReached:
 				configWithProvider.onConsecutiveMistakeLimitReached,
 			completionGuard: runtime.completionGuard,
+			consumePendingUserMessage: () => this.consumeSteerMessage(sessionId),
 			logger: runtime.logger ?? configWithProvider.logger,
+			extensionContext: configWithProvider.extensionContext,
 			onEvent: (event: AgentEvent) =>
 				this.onAgentEvent(sessionId, configWithProvider, event),
-		});
+		} as AgentConfig;
+		const agent = this.createAgentInstance(agentConfig);
+		runtime.registerLeadAgent?.(agent);
 		const rootAgentIdentity = buildTelemetryAgentIdentity({
 			agentId: this.readAgentId(agent),
 			conversationId: this.readAgentConversationId(agent),
@@ -341,7 +396,7 @@ export class DefaultSessionManager implements SessionManager {
 			started: false,
 			aborting: false,
 			interactive: input.interactive === true,
-			persistedMessages: input.initialMessages,
+			persistedMessages: startInput.initialMessages,
 			activeTeamRunIds: new Set<string>(),
 			pendingTeamRunUpdates: [],
 			teamRunWaiters: [],
@@ -354,11 +409,11 @@ export class DefaultSessionManager implements SessionManager {
 
 		let result: AgentResult | undefined;
 		try {
-			if (input.prompt?.trim()) {
+			if (startInput.prompt?.trim()) {
 				result = await this.runTurn(active, {
-					prompt: input.prompt,
-					userImages: input.userImages,
-					userFiles: input.userFiles,
+					prompt: startInput.prompt,
+					userImages: startInput.userImages,
+					userFiles: startInput.userFiles,
 				});
 				if (!active.interactive) {
 					await this.finalizeSingleRun(active, result.finishReason);
@@ -650,10 +705,15 @@ export class DefaultSessionManager implements SessionManager {
 				baselineMessages,
 			);
 			session.persistedMessages = persistedMessages;
-			this.usageBySession.set(
-				session.sessionId,
-				accumulateUsageTotals(usageBaseline, result.usage),
+			const accumulatedUsage = accumulateUsageTotals(
+				usageBaseline,
+				result.usage,
 			);
+			this.usageBySession.set(session.sessionId, accumulatedUsage);
+			await this.persistSessionMetadata(session.sessionId, (current) => ({
+				...(current ?? {}),
+				totalCost: accumulatedUsage.totalCost,
+			}));
 			await this.invoke<void>(
 				"persistSessionMessages",
 				session.sessionId,
@@ -744,6 +804,37 @@ export class DefaultSessionManager implements SessionManager {
 		})) as RootSessionArtifacts;
 	}
 
+	private async persistSessionMetadata(
+		sessionId: string,
+		resolveMetadata: (
+			current: Record<string, unknown> | undefined,
+		) => Record<string, unknown> | undefined,
+	): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		const currentManifest =
+			(await this.invokeOptionalValue<SessionManifest>(
+				"readSessionManifest",
+				sessionId,
+			)) ?? session?.artifacts?.manifest;
+		const metadata = resolveMetadata(
+			currentManifest?.metadata as Record<string, unknown> | undefined,
+		);
+		if (!session?.artifacts) {
+			return;
+		}
+		const result = await this.invokeOptionalValue<{ updated?: boolean }>(
+			"updateSession",
+			{
+				sessionId,
+				metadata,
+			},
+		);
+		if (result?.updated === false) {
+			return;
+		}
+		session.artifacts.manifest.metadata = metadata;
+	}
+
 	private async finalizeSingleRun(
 		session: ActiveSession,
 		finishReason: AgentResult["finishReason"],
@@ -818,14 +909,19 @@ export class DefaultSessionManager implements SessionManager {
 			exitCode,
 		);
 		if (!result.updated) return;
-		session.artifacts.manifest.status = status;
-		session.artifacts.manifest.ended_at = result.endedAt ?? nowIso();
-		session.artifacts.manifest.exit_code =
-			typeof exitCode === "number" ? exitCode : null;
+		const latestManifest =
+			(await this.invokeOptionalValue<SessionManifest>(
+				"readSessionManifest",
+				session.sessionId,
+			)) ?? session.artifacts.manifest;
+		latestManifest.status = status;
+		latestManifest.ended_at = result.endedAt ?? nowIso();
+		latestManifest.exit_code = typeof exitCode === "number" ? exitCode : null;
+		session.artifacts.manifest = latestManifest;
 		await this.invoke<void>(
 			"writeSessionManifest",
 			session.artifacts.manifestPath,
-			session.artifacts.manifest,
+			latestManifest,
 		);
 		this.emitStatus(session.sessionId, status);
 	}
@@ -869,6 +965,27 @@ export class DefaultSessionManager implements SessionManager {
 		});
 	}
 
+	/**
+	 * Consume the first steer-delivery pending prompt for injection into the
+	 * running agent loop. Called synchronously by the agent between iterations.
+	 */
+	private consumeSteerMessage(sessionId: string): string | undefined {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			return undefined;
+		}
+		const steerIndex = session.pendingPrompts.findIndex(
+			(entry) => entry.delivery === "steer",
+		);
+		if (steerIndex < 0) {
+			return undefined;
+		}
+		const [steer] = session.pendingPrompts.splice(steerIndex, 1);
+		this.emitPendingPrompts(session);
+		this.emitPendingPromptSubmitted(session, steer);
+		return steer.prompt;
+	}
+
 	private enqueuePendingPrompt(
 		sessionId: string,
 		entry: {
@@ -1065,9 +1182,12 @@ export class DefaultSessionManager implements SessionManager {
 			const tools: Tool[] = config.enableTools
 				? createBuiltinTools({
 						cwd: config.cwd,
-						...(config.mode === "plan"
-							? ToolPresets.readonly
-							: ToolPresets.development),
+						...ToolPresets[
+							resolveToolPresetName({
+								mode: config.mode,
+								yolo: config.yolo,
+							})
+						],
 						executors: this.defaultToolExecutors,
 					})
 				: [];
@@ -1092,10 +1212,6 @@ export class DefaultSessionManager implements SessionManager {
 						providerConfig: config.providerConfig,
 						knownModels: config.knownModels,
 						thinking: config.thinking,
-						clineWorkspaceMetadata:
-							config.providerId === "cline"
-								? extractWorkspaceMetadataFromSystemPrompt(config.systemPrompt)
-								: undefined,
 						maxIterations: config.maxIterations,
 						hooks: config.hooks,
 						extensions: config.extensions,

package/src/session/file-session-service.ts

@@ -7,12 +7,12 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { resolveSessionDataDir } from "@clinebot/shared/storage";
-import type { SessionRow } from "./session-service";
 import type {
 	PersistedSessionUpdateInput,
 	SessionPersistenceAdapter,
-} from "./unified-session-persistence-service";
-import { UnifiedSessionPersistenceService } from "./unified-session-persistence-service";
+} from "./persistence-service";
+import { UnifiedSessionPersistenceService } from "./persistence-service";
+import type { SessionRow } from "./session-service";
 
 interface FileSessionIndex {
 	version: 1;

package/src/session/index.ts

@@ -1,3 +1,9 @@
+export {
+	upsertWorkspaceInfo,
+	type WorkspaceInfo,
+	type WorkspaceManifest,
+	WorkspaceManifestSchema,
+} from "@clinebot/shared";
 export type {
 	ClineCore,
 	ClineCoreOptions,
@@ -33,13 +39,7 @@ export type {
 	WorkspaceManagerEvent,
 } from "./workspace-manager";
 export { InMemoryWorkspaceManager } from "./workspace-manager";
-export type { WorkspaceManifest } from "./workspace-manifest";
 export {
-	buildWorkspaceMetadata,
-	emptyWorkspaceManifest,
 	generateWorkspaceInfo,
 	normalizeWorkspacePath,
-	upsertWorkspaceInfo,
-	WorkspaceInfoSchema,
-	WorkspaceManifestSchema,
 } from "./workspace-manifest";

package/src/session/persistence-service.test.ts

@@ -0,0 +1,212 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { SqliteSessionStore } from "../storage/sqlite-session-store";
+import { SessionSource } from "../types/common";
+import { CoreSessionService } from "./session-service";
+
+describe("UnifiedSessionPersistenceService", () => {
+	const tempDirs: string[] = [];
+	const stores: Array<SqliteSessionStore> = [];
+
+	afterEach(() => {
+		for (const store of stores.splice(0)) {
+			store.close();
+		}
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("reconciles dead running sessions into failed manifests with terminal markers", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "stale-session-reconcile-"));
+		tempDirs.push(sessionsDir);
+
+		const store = new SqliteSessionStore({ sessionsDir });
+		stores.push(store);
+		const service = new CoreSessionService(store);
+		const sessionId = "stale-root-session";
+		const artifacts = await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: 999_999_999,
+			interactive: false,
+			provider: "mock-provider",
+			model: "mock-model",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: false,
+			prompt: "hello",
+			startedAt: "2026-01-01T00:00:00.000Z",
+		});
+
+		const reconciled = await service.reconcileDeadSessions();
+		expect(reconciled).toBe(1);
+
+		const rows = await service.listSessions(10);
+		expect(rows).toHaveLength(1);
+		expect(rows[0]).toMatchObject({
+			sessionId,
+			status: "failed",
+			exitCode: 1,
+		});
+		expect(rows[0]?.endedAt).toBeTruthy();
+
+		const manifest = JSON.parse(
+			readFileSync(artifacts.manifestPath, "utf8"),
+		) as Record<string, unknown>;
+		expect(manifest.status).toBe("failed");
+		expect(manifest.exit_code).toBe(1);
+		expect(manifest.ended_at).toBeTruthy();
+		expect(manifest.metadata).toMatchObject({
+			terminal_marker: "failed_external_process_exit",
+			terminal_marker_pid: 999_999_999,
+			terminal_marker_source: "stale_session_reconciler",
+		});
+		expect(
+			(manifest.metadata as Record<string, unknown>).terminal_marker_at,
+		).toBeTruthy();
+
+		expect(existsSync(artifacts.hookPath)).toBe(true);
+		expect(existsSync(artifacts.transcriptPath)).toBe(true);
+		expect(readFileSync(artifacts.hookPath, "utf8")).toContain(
+			'"hookName":"session_shutdown"',
+		);
+		expect(readFileSync(artifacts.hookPath, "utf8")).toContain(
+			'"reason":"failed_external_process_exit"',
+		);
+		expect(readFileSync(artifacts.transcriptPath, "utf8")).toContain(
+			"[shutdown] failed_external_process_exit",
+		);
+	}, 15_000);
+
+	it("persists teammate task metadata in the file envelope and usage on messages", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "team-task-messages-"));
+		tempDirs.push(sessionsDir);
+
+		const store = new SqliteSessionStore({ sessionsDir });
+		stores.push(store);
+		const service = new CoreSessionService(store);
+		const rootSessionId = "root-session";
+		await service.createRootSessionWithArtifacts({
+			sessionId: rootSessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: false,
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: true,
+			prompt: "lead task",
+			startedAt: "2026-04-10T19:00:00.000Z",
+		});
+
+		await service.onTeamTaskStart(
+			rootSessionId,
+			"java-haiku-agent",
+			"Write a haiku about Java",
+		);
+		await service.onTeamTaskEnd(
+			rootSessionId,
+			"java-haiku-agent",
+			"completed",
+			"[done] completed",
+			{
+				text: "Classes wrap the world\nWrite once, run on every machine —\nVerbose, yet it soars",
+				usage: {
+					inputTokens: 42,
+					outputTokens: 17,
+					cacheReadTokens: 9,
+					cacheWriteTokens: 0,
+					totalCost: 0.123,
+				},
+				messages: [
+					{
+						role: "user",
+						content: "Write a haiku about Java. Return only the haiku.",
+					},
+					{
+						role: "assistant",
+						content: [
+							{
+								type: "text",
+								text: "Classes wrap the world\nWrite once, run on every machine —\nVerbose, yet it soars",
+							},
+						],
+					},
+				],
+				toolCalls: [],
+				iterations: 1,
+				finishReason: "completed",
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+					info: { id: "claude-sonnet-4-6" },
+				},
+				startedAt: new Date("2026-04-10T19:00:01.000Z"),
+				endedAt: new Date("2026-04-10T19:00:02.000Z"),
+				durationMs: 1000,
+			},
+		);
+
+		const childSessions = await service.listSessions(10);
+		const teammateSessionId = childSessions.find((row) =>
+			row.sessionId.includes("__teamtask__java-haiku-agent__"),
+		)?.sessionId;
+		expect(teammateSessionId).toBeTruthy();
+		const path = join(
+			sessionsDir,
+			rootSessionId,
+			"java-haiku-agent__" +
+				teammateSessionId?.slice(teammateSessionId?.lastIndexOf("__") + 2) +
+				".messages.json",
+		);
+		const payload = JSON.parse(readFileSync(path, "utf8")) as {
+			agent?: string;
+			sessionId?: string;
+			taskType?: string;
+			messages: Array<Record<string, unknown>>;
+		};
+		const user = payload.messages[0] as Record<string, unknown>;
+		const assistant = payload.messages[1] as Record<string, unknown>;
+
+		expect(payload.agent).toBe("teammate");
+		expect(payload.sessionId).toBe(rootSessionId);
+		expect(payload.taskType).toBe("team");
+		expect(assistant.id).toEqual(expect.any(String));
+		expect(user.agent).toBeUndefined();
+		expect(user.sessionId).toBeUndefined();
+		expect(assistant.agent).toBeUndefined();
+		expect(assistant.sessionId).toBeUndefined();
+		expect(assistant.modelInfo).toMatchObject({
+			id: "claude-sonnet-4-6",
+			provider: "anthropic",
+		});
+		expect(assistant.metrics).toMatchObject({
+			inputTokens: 42,
+			outputTokens: 17,
+			cacheReadTokens: 9,
+			cacheWriteTokens: 0,
+			cost: 0.123,
+		});
+		const row = childSessions.find(
+			(item) => item.sessionId === teammateSessionId,
+		);
+		expect(row?.messagesPath).toBe(path);
+		expect(row?.transcriptPath).toBe(
+			join(
+				sessionsDir,
+				rootSessionId,
+				"java-haiku-agent__" +
+					teammateSessionId?.slice(teammateSessionId?.lastIndexOf("__") + 2) +
+					".log",
+			),
+		);
+	});
+});