@clinebot/core 0.0.33 → 0.0.35

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

@@ -1,8 +1,8 @@
 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 { afterEach, describe, expect, it, vi } from "vitest";
+import { SqliteSessionStore } from "../services/storage/sqlite-session-store";
 import { SessionSource } from "../types/common";
 import { CoreSessionService } from "./session-service";
 
@@ -20,12 +20,17 @@ describe("UnifiedSessionPersistenceService", () => {
 	});
 
 	it("reconciles dead running sessions into failed manifests with terminal markers", async () => {
-		const sessionsDir = mkdtempSync(join(tmpdir(), "stale-session-reconcile-"));
-		tempDirs.push(sessionsDir);
+		const dbDir = mkdtempSync(join(tmpdir(), "stale-session-reconcile-db-"));
+		const sessionsDir = mkdtempSync(
+			join(tmpdir(), "stale-session-reconcile-sessions-"),
+		);
+		tempDirs.push(dbDir, sessionsDir);
 
-		const store = new SqliteSessionStore({ sessionsDir });
+		const store = new SqliteSessionStore({ sessionsDir: dbDir });
 		stores.push(store);
-		const service = new CoreSessionService(store);
+		const service = new CoreSessionService(store, {
+			sessionArtifactsDir: sessionsDir,
+		});
 		const sessionId = "stale-root-session";
 		const artifacts = await service.createRootSessionWithArtifacts({
 			sessionId,
@@ -70,26 +75,24 @@ describe("UnifiedSessionPersistenceService", () => {
 			(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",
-		);
+		const globalHookLog = process.env.CLINE_HOOKS_LOG_PATH ?? "";
+		if (globalHookLog && existsSync(globalHookLog)) {
+			const hookContent = readFileSync(globalHookLog, "utf8");
+			expect(hookContent).toContain('"hookName":"session_shutdown"');
+			expect(hookContent).toContain('"reason":"failed_external_process_exit"');
+		}
 	}, 15_000);
 
 	it("persists teammate task metadata in the file envelope and usage on messages", async () => {
+		const dbDir = mkdtempSync(join(tmpdir(), "team-task-messages-db-"));
 		const sessionsDir = mkdtempSync(join(tmpdir(), "team-task-messages-"));
-		tempDirs.push(sessionsDir);
+		tempDirs.push(dbDir, sessionsDir);
 
-		const store = new SqliteSessionStore({ sessionsDir });
+		const store = new SqliteSessionStore({ sessionsDir: dbDir });
 		stores.push(store);
-		const service = new CoreSessionService(store);
+		const service = new CoreSessionService(store, {
+			sessionArtifactsDir: sessionsDir,
+		});
 		const rootSessionId = "root-session";
 		await service.createRootSessionWithArtifacts({
 			sessionId: rootSessionId,
@@ -194,10 +197,104 @@ describe("UnifiedSessionPersistenceService", () => {
 			cost: 0.123,
 		});
 		expect(row?.messagesPath).toBe(path);
-		expect(row?.transcriptPath).toBeTruthy();
-		expect(row?.transcriptPath).toContain(
-			join(sessionsDir, rootSessionId, "java-haiku-agent__"),
+	});
+
+	it("uploads messages after persisting them when a messages uploader is configured", async () => {
+		const dbDir = mkdtempSync(join(tmpdir(), "messages-upload-db-"));
+		const sessionsDir = mkdtempSync(join(tmpdir(), "messages-upload-"));
+		tempDirs.push(dbDir, sessionsDir);
+
+		const store = new SqliteSessionStore({ sessionsDir: dbDir });
+		stores.push(store);
+		const uploadMessagesFile = vi.fn(async () => {});
+		const service = new CoreSessionService(store, {
+			sessionArtifactsDir: sessionsDir,
+			messagesArtifactUploader: {
+				uploadMessagesFile,
+			},
+		});
+		const sessionId = "root-upload-session";
+		await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: false,
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: false,
+			enableTeams: false,
+			prompt: "hello",
+			metadata: {
+				blobUpload: true,
+			},
+			startedAt: "2026-04-10T19:00:00.000Z",
+		});
+
+		await service.persistSessionMessages(sessionId, [
+			{
+				role: "user",
+				content: "hello",
+			},
+		]);
+
+		expect(uploadMessagesFile).toHaveBeenCalledTimes(1);
+		expect(uploadMessagesFile).toHaveBeenCalledWith(
+			expect.objectContaining({
+				sessionId,
+				path: expect.stringContaining(`${sessionId}.messages.json`),
+				contents: expect.stringContaining('"role": "user"'),
+				row: expect.objectContaining({
+					sessionId,
+					metadata: {
+						blobUpload: true,
+						title: "hello",
+					},
+				}),
+			}),
 		);
-		expect(row?.transcriptPath).toMatch(/\.log$/);
+	});
+
+	it("deletes the full root session directory even when artifact paths are stale", async () => {
+		const dbDir = mkdtempSync(join(tmpdir(), "delete-root-session-dir-db-"));
+		const sessionsDir = mkdtempSync(join(tmpdir(), "delete-root-session-dir-"));
+		tempDirs.push(dbDir, sessionsDir);
+
+		const store = new SqliteSessionStore({ sessionsDir: dbDir });
+		stores.push(store);
+		const service = new CoreSessionService(store, {
+			sessionArtifactsDir: sessionsDir,
+		});
+		const sessionId = "root-session-delete";
+		const artifacts = await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: false,
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: false,
+			enableTeams: false,
+			prompt: "delete me",
+			startedAt: "2026-04-10T19:00:00.000Z",
+		});
+
+		store.run(`UPDATE sessions SET messages_path = NULL WHERE session_id = ?`, [
+			sessionId,
+		]);
+
+		expect(existsSync(artifacts.messagesPath)).toBe(true);
+		expect(existsSync(join(sessionsDir, sessionId))).toBe(true);
+
+		const result = await service.deleteSession(sessionId);
+
+		expect(result).toEqual({ deleted: true });
+		expect(existsSync(artifacts.messagesPath)).toBe(false);
+		expect(existsSync(join(sessionsDir, sessionId))).toBe(false);
 	});
 });

package/src/session/persistence-service.ts

@@ -1,33 +1,28 @@
 import {
 	appendFileSync,
 	existsSync,
+	mkdirSync,
 	readFileSync,
 	writeFileSync,
 } from "node:fs";
+import { dirname, join } from "node:path";
 import type * as LlmsProviders from "@clinebot/llms";
 import type { AgentResult } from "@clinebot/shared";
 import { resolveRootSessionId } from "@clinebot/shared";
+import { ensureHookLogDir } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
 import { z } from "zod";
+import type {
+	SubAgentEndContext,
+	SubAgentStartContext,
+} from "../extensions/tools/team";
 import type { HookEventPayload } from "../hooks";
-import type { SubAgentEndContext, SubAgentStartContext } from "../team";
-import { SessionSource, type SessionStatus } from "../types/common";
-import { nowIso, SessionArtifacts, unlinkIfExists } from "./session-artifacts";
+import { deleteCheckpointRefs } from "../hooks/checkpoint-hooks";
 import {
-	deriveSubsessionStatus,
-	makeSubSessionId,
-	makeTeamTaskSubSessionId,
-} from "./session-graph";
-import {
-	type SessionManifest,
-	SessionManifestSchema,
-} from "./session-manifest";
-import type {
-	CreateRootSessionWithArtifactsInput,
-	RootSessionArtifacts,
-	SessionRow,
-	UpsertSubagentInput,
-} from "./session-service";
+	nowIso,
+	SessionArtifacts,
+	unlinkIfExists,
+} from "../services/session-artifacts";
 import {
 	buildManifestFromRow,
 	buildMessagesFilePayload,
@@ -40,12 +35,29 @@ import {
 	withLatestAssistantTurnMetadata,
 	withOccRetry,
 	writeEmptyMessagesFile,
-} from "./utils/helpers";
+} from "../services/session-data";
+import { SessionSource, type SessionStatus } from "../types/common";
 import type {
 	PersistedSessionUpdateInput,
+	SessionMessagesArtifactUploader,
 	SessionPersistenceAdapter,
 	StoredMessageWithMetadata,
-} from "./utils/types";
+} from "../types/session";
+import {
+	deriveSubsessionStatus,
+	makeSubSessionId,
+	makeTeamTaskSubSessionId,
+} from "./session-graph";
+import {
+	type SessionManifest,
+	SessionManifestSchema,
+} from "./session-manifest";
+import type {
+	CreateRootSessionWithArtifactsInput,
+	RootSessionArtifacts,
+	SessionRow,
+	UpsertSubagentInput,
+} from "./session-service";
 
 export type { PersistedSessionUpdateInput, SessionPersistenceAdapter };
 
@@ -67,12 +79,19 @@ export class UnifiedSessionPersistenceService {
 		string
 	>();
 	protected readonly artifacts: SessionArtifacts;
+	private readonly messagesArtifactUploader?: SessionMessagesArtifactUploader;
 	private static readonly STALE_REASON = "failed_external_process_exit";
 	private static readonly STALE_SOURCE = "stale_session_reconciler";
 	private static readonly TEAM_HEARTBEAT_LOG_INTERVAL_MS = 30_000;
 
-	constructor(private readonly adapter: SessionPersistenceAdapter) {
+	constructor(
+		private readonly adapter: SessionPersistenceAdapter,
+		options: {
+			messagesArtifactUploader?: SessionMessagesArtifactUploader;
+		} = {},
+	) {
 		this.artifacts = new SessionArtifacts(() => this.ensureSessionsDir());
+		this.messagesArtifactUploader = options.messagesArtifactUploader;
 	}
 
 	ensureSessionsDir(): string {
@@ -114,6 +133,7 @@ export class UnifiedSessionPersistenceService {
 		manifestPath: string,
 		manifest: SessionManifest,
 	): void {
+		mkdirSync(dirname(manifestPath), { recursive: true });
 		writeFileSync(
 			manifestPath,
 			`${JSON.stringify(SessionManifestSchema.parse(manifest), null, 2)}\n`,
@@ -151,7 +171,7 @@ export class UnifiedSessionPersistenceService {
 
 	private async resolveArtifactPath(
 		sessionId: string,
-		kind: "transcriptPath" | "hookPath" | "messagesPath",
+		kind: "messagesPath",
 		fallback: (id: string) => string,
 	): Promise<string> {
 		const row = await this.adapter.getSession(sessionId);
@@ -186,8 +206,6 @@ export class UnifiedSessionPersistenceService {
 		const providedId = input.sessionId.trim();
 		const sessionId =
 			providedId.length > 0 ? providedId : `${Date.now()}_${nanoid(5)}`;
-		const transcriptPath = this.artifacts.sessionTranscriptPath(sessionId);
-		const hookPath = this.artifacts.sessionHookPath(sessionId);
 		const messagesPath = this.artifacts.sessionMessagesPath(sessionId);
 		const manifestPath = this.artifacts.sessionManifestPath(sessionId);
 
@@ -241,15 +259,14 @@ export class UnifiedSessionPersistenceService {
 			isSubagent: false,
 			prompt: manifest.prompt ?? null,
 			metadata: sanitizeMetadata(manifest.metadata),
-			transcriptPath,
-			hookPath,
+			hookPath: "",
 			messagesPath,
 			updatedAt: nowIso(),
 		});
 
 		this.initializeMessagesFile(sessionId, messagesPath, startedAt);
 		this.writeManifestFile(manifestPath, manifest);
-		return { manifestPath, transcriptPath, hookPath, messagesPath, manifest };
+		return { manifestPath, messagesPath, manifest };
 	}
 
 	// ── Session status updates ────────────────────────────────────────
@@ -262,14 +279,14 @@ export class UnifiedSessionPersistenceService {
 		let endedAt: string | undefined;
 		const result = await withOccRetry(
 			() => this.adapter.getSession(sessionId),
-			async (statusLock) => {
+			async (row) => {
 				endedAt = nowIso();
 				return this.adapter.updateSession({
 					sessionId,
 					status,
 					endedAt,
 					exitCode: typeof exitCode === "number" ? exitCode : null,
-					expectedStatusLock: statusLock,
+					expectedStatusLock: row.statusLock,
 				});
 			},
 			OCC_MAX_RETRIES,
@@ -387,8 +404,6 @@ export class UnifiedSessionPersistenceService {
 			conversationId?: string | null;
 			prompt: string;
 			startedAt: string;
-			transcriptPath: string;
-			hookPath: string;
 			messagesPath: string;
 		},
 	): SessionRow {
@@ -417,8 +432,7 @@ export class UnifiedSessionPersistenceService {
 			isSubagent: true,
 			prompt: opts.prompt,
 			metadata: resolveMetadataWithTitle({ prompt: opts.prompt }),
-			transcriptPath: opts.transcriptPath,
-			hookPath: opts.hookPath,
+			hookPath: "",
 			messagesPath: opts.messagesPath,
 			updatedAt: opts.startedAt,
 		};
@@ -516,31 +530,16 @@ export class UnifiedSessionPersistenceService {
 		subSessionId: string,
 		event: HookEventPayload,
 	): Promise<void> {
-		const path = await this.resolveArtifactPath(
-			subSessionId,
-			"hookPath",
-			(id) => this.artifacts.sessionHookPath(id),
-		);
+		void subSessionId;
+		const envPath = process.env.CLINE_HOOKS_LOG_PATH?.trim() || undefined;
+		const logPath = envPath ?? join(ensureHookLogDir(), "hooks.jsonl");
 		appendFileSync(
-			path,
+			logPath,
 			`${JSON.stringify({ ts: nowIso(), ...event })}\n`,
 			"utf8",
 		);
 	}
 
-	async appendSubagentTranscriptLine(
-		subSessionId: string,
-		line: string,
-	): Promise<void> {
-		if (!line.trim()) return;
-		const path = await this.resolveArtifactPath(
-			subSessionId,
-			"transcriptPath",
-			(id) => this.artifacts.sessionTranscriptPath(id),
-		);
-		appendFileSync(path, `${line}\n`, "utf8");
-	}
-
 	async persistSessionMessages(
 		sessionId: string,
 		messages: LlmsProviders.Message[],
@@ -560,7 +559,26 @@ export class UnifiedSessionPersistenceService {
 			messages: normalizedMessages,
 			systemPrompt,
 		});
-		writeFileSync(path, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+		const contents = `${JSON.stringify(payload, null, 2)}\n`;
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, contents, "utf8");
+		if (!this.messagesArtifactUploader) {
+			return;
+		}
+		try {
+			const row = await this.adapter.getSession(sessionId);
+			await this.messagesArtifactUploader.uploadMessagesFile({
+				sessionId,
+				path,
+				contents,
+				row,
+			});
+		} catch (error) {
+			console.warn(
+				`Failed to upload persisted session messages for ${sessionId}`,
+				error,
+			);
+		}
 	}
 
 	// ── Subagent status ───────────────────────────────────────────────
@@ -620,8 +638,10 @@ export class UnifiedSessionPersistenceService {
 
 		const sessionId = makeTeamTaskSubSessionId(rootSessionId, agentId);
 		const startedAt = nowIso();
-		const { transcriptPath, hookPath, messagesPath } =
-			this.artifacts.subagentArtifactPaths(sessionId, agentId);
+		const { messagesPath } = this.artifacts.subagentArtifactPaths(
+			sessionId,
+			agentId,
+		);
 
 		await this.adapter.upsertSession(
 			this.buildSubsessionRow(root, {
@@ -631,13 +651,10 @@ export class UnifiedSessionPersistenceService {
 				agentId,
 				prompt: message || `Team task for ${agentId}`,
 				startedAt,
-				transcriptPath,
-				hookPath,
 				messagesPath,
 			}),
 		);
 		this.initializeMessagesFile(sessionId, messagesPath, startedAt);
-		await this.appendSubagentTranscriptLine(sessionId, `[start] ${message}`);
 
 		const key = this.teamTaskQueueKey(rootSessionId, agentId);
 		const queue = this.teamTaskSessionsByAgent.get(key) ?? [];
@@ -649,7 +666,7 @@ export class UnifiedSessionPersistenceService {
 		rootSessionId: string,
 		agentId: string,
 		status: SessionStatus,
-		summary?: string,
+		_summary?: string,
 		result?: AgentResult,
 		messages?: LlmsProviders.Message[],
 	): Promise<void> {
@@ -670,10 +687,6 @@ export class UnifiedSessionPersistenceService {
 		if (persistedMessages) {
 			await this.persistSessionMessages(sessionId, persistedMessages);
 		}
-		await this.appendSubagentTranscriptLine(
-			sessionId,
-			summary ?? `[done] ${status}`,
-		);
 		await this.applySubagentStatusBySessionId(sessionId, status);
 		this.teamTaskLastHeartbeatBySession.delete(sessionId);
 		this.teamTaskLastProgressLineBySession.delete(sessionId);
@@ -713,7 +726,6 @@ export class UnifiedSessionPersistenceService {
 					: `[progress] ${trimmed}`;
 		if (this.teamTaskLastProgressLineBySession.get(sessionId) === line) return;
 		this.teamTaskLastProgressLineBySession.set(sessionId, line);
-		await this.appendSubagentTranscriptLine(sessionId, line);
 	}
 
 	// ── SubAgent lifecycle ────────────────────────────────────────────
@@ -730,10 +742,6 @@ export class UnifiedSessionPersistenceService {
 			rootSessionId,
 		});
 		if (!subSessionId) return;
-		await this.appendSubagentTranscriptLine(
-			subSessionId,
-			`[start] ${context.input.task}`,
-		);
 		await this.applySubagentStatusBySessionId(subSessionId, "running");
 	}
 
@@ -751,15 +759,10 @@ export class UnifiedSessionPersistenceService {
 		if (!subSessionId) return;
 
 		if (context.error) {
-			await this.appendSubagentTranscriptLine(
-				subSessionId,
-				`[error] ${context.error.message}`,
-			);
 			await this.applySubagentStatusBySessionId(subSessionId, "failed");
 			return;
 		}
 		const reason = context.result?.finishReason ?? "completed";
-		await this.appendSubagentTranscriptLine(subSessionId, `[done] ${reason}`);
 		await this.applySubagentStatusBySessionId(
 			subSessionId,
 			reason === "aborted" ? "cancelled" : "completed",
@@ -825,24 +828,22 @@ export class UnifiedSessionPersistenceService {
 			const { path: manifestPath } = this.readManifestFile(latest.sessionId);
 			this.writeManifestFile(manifestPath, manifest);
 
-			appendFileSync(
-				latest.hookPath,
-				`${JSON.stringify({
-					ts: detectedAt,
-					hookName: "session_shutdown",
-					reason,
-					sessionId: latest.sessionId,
-					pid: latest.pid,
-					source: UnifiedSessionPersistenceService.STALE_SOURCE,
-				})}\n`,
-				"utf8",
-			);
-			appendFileSync(
-				latest.transcriptPath,
-				`[shutdown] ${reason} (pid=${latest.pid})\n`,
-				"utf8",
-			);
-
+			{
+				const envPath = process.env.CLINE_HOOKS_LOG_PATH?.trim() || undefined;
+				const logPath = envPath ?? join(ensureHookLogDir(), "hooks.jsonl");
+				appendFileSync(
+					logPath,
+					`${JSON.stringify({
+						ts: detectedAt,
+						hookName: "session_shutdown",
+						reason,
+						sessionId: latest.sessionId,
+						pid: latest.pid,
+						source: UnifiedSessionPersistenceService.STALE_SOURCE,
+					})}\n`,
+					"utf8",
+				);
+			}
 			return {
 				...latest,
 				status: "failed",
@@ -907,22 +908,37 @@ export class UnifiedSessionPersistenceService {
 				parentSessionId: id,
 			});
 			await this.adapter.deleteSession(id, true);
-			for (const child of children) {
-				unlinkIfExists(child.transcriptPath);
-				unlinkIfExists(child.hookPath);
-				unlinkIfExists(child.messagesPath);
-				unlinkIfExists(
-					this.artifacts.sessionManifestPath(child.sessionId, false),
-				);
-				this.artifacts.removeSessionDirIfEmpty(child.sessionId);
-			}
+			await Promise.allSettled(
+				children.map(async (child) => {
+					await deleteCheckpointRefs(child.cwd, child.sessionId);
+					unlinkIfExists(child.messagesPath);
+					unlinkIfExists(
+						this.artifacts.sessionManifestPath(child.sessionId, false),
+					);
+					this.artifacts.removeSessionDirIfEmpty(child.sessionId);
+				}),
+			);
 		}
 
-		unlinkIfExists(row.transcriptPath);
-		unlinkIfExists(row.hookPath);
+		await deleteCheckpointRefs(row.cwd, id);
+
 		unlinkIfExists(row.messagesPath);
 		unlinkIfExists(this.artifacts.sessionManifestPath(id, false));
-		this.artifacts.removeSessionDirIfEmpty(id);
+		if (row.isSubagent) {
+			this.artifacts.removeSessionDirIfEmpty(id);
+		} else {
+			const candidateDirs = new Set<string>([
+				this.artifacts.sessionArtifactsDir(id),
+			]);
+			for (const path of [row.messagesPath]) {
+				if (typeof path === "string" && path.trim().length > 0) {
+					candidateDirs.add(dirname(path));
+				}
+			}
+			for (const dir of candidateDirs) {
+				this.artifacts.removeDir(dir);
+			}
+		}
 		return { deleted: true };
 	}
 }

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

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync } from "node:fs";
 import { RpcSessionClient, type RpcSessionRow } from "@clinebot/rpc";
+import type { SessionMessagesArtifactUploader } from "../types/session";
 import type {
 	PersistedSessionUpdateInput,
 	SessionPersistenceAdapter,
@@ -79,19 +80,25 @@ class RpcSessionPersistenceAdapter implements SessionPersistenceAdapter {
 export interface RpcCoreSessionServiceOptions {
 	address?: string;
 	sessionsDir: string;
+	messagesArtifactUploader?: SessionMessagesArtifactUploader;
 }
 
 export class RpcCoreSessionService extends UnifiedSessionPersistenceService {
 	private readonly sessionsDirPath: string;
 	private readonly client: RpcSessionClient;
+	public readonly address: string;
 
 	constructor(options: RpcCoreSessionServiceOptions) {
+		const address = options.address?.trim() || "127.0.0.1:4317";
 		const client = new RpcSessionClient({
-			address: options.address?.trim() || "127.0.0.1:4317",
+			address,
+		});
+		super(new RpcSessionPersistenceAdapter(client), {
+			messagesArtifactUploader: options.messagesArtifactUploader,
 		});
-		super(new RpcSessionPersistenceAdapter(client));
 		this.sessionsDirPath = options.sessionsDir;
 		this.client = client;
+		this.address = address;
 	}
 
 	override ensureSessionsDir(): string {

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

@@ -2,7 +2,7 @@ import { existsSync, mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
-import { AgentTeamsRuntime } from "../team";
+import { AgentTeamsRuntime } from "../extensions/tools/team";
 import { FileTeamPersistenceStore } from "./session-service";
 
 describe("FileTeamPersistenceStore", () => {