@clinebot/core 0.0.33 → 0.0.35

package/src/{session/utils/helpers.ts → services/session-data.ts}

@@ -1,17 +1,21 @@
-import { writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import type * as LlmsProviders from "@clinebot/llms";
 import type { AgentConfig, AgentEvent, AgentResult } from "@clinebot/shared";
 import { normalizeUserInput } from "@clinebot/shared";
 import { nanoid } from "nanoid";
-import type { SessionSource, SessionStatus } from "../../types/common";
-import type { SessionRecord } from "../../types/sessions";
-import { parseSubSessionId, parseTeamTaskSubSessionId } from "../session-graph";
+import {
+	parseSubSessionId,
+	parseTeamTaskSubSessionId,
+} from "../session/session-graph";
 import {
 	type SessionManifest,
 	SessionManifestSchema,
-} from "../session-manifest";
-import type { SessionRow } from "../session-service";
-import type { StoredMessageWithMetadata } from "./types";
+} from "../session/session-manifest";
+import type { SessionRow } from "../session/session-service";
+import type { SessionSource, SessionStatus } from "../types/common";
+import type { StoredMessageWithMetadata } from "../types/session";
+import type { SessionRecord } from "../types/sessions";
 
 export function hasRuntimeHooks(hooks: AgentConfig["hooks"]): boolean {
 	if (!hooks) {
@@ -197,15 +201,11 @@ export function toSessionRecord(row: SessionRow): SessionRecord {
 		isSubagent: row.isSubagent,
 		prompt: row.prompt ?? undefined,
 		metadata: row.metadata ?? undefined,
-		transcriptPath: row.transcriptPath,
-		hookPath: row.hookPath,
 		messagesPath: row.messagesPath ?? undefined,
 		updatedAt: row.updatedAt,
 	};
 }
 
-// ── Metadata helpers ──────────────────────────────────────────────────
-
 const MAX_TITLE_LENGTH = 120;
 
 export function normalizeTitle(title?: string | null): string | undefined {
@@ -251,38 +251,59 @@ export function resolveMetadataWithTitle(input: {
 	return Object.keys(base).length > 0 ? base : undefined;
 }
 
-// ── Messages file helpers ─────────────────────────────────────────────
-
 export type MessagesFileContext = {
 	agent: "lead" | "subagent" | "teammate";
 	sessionId: string;
 	taskType?: string;
 };
 
-export type MessagesFilePayload = {
-	version: number;
-	updated_at: string;
-	agent: "lead" | "subagent" | "teammate";
-	sessionId: string;
-	taskType?: string;
-	systemPrompt?: string;
-	messages: LlmsProviders.Message[];
-};
+export function resolveMessagesFileContext(
+	sessionId: string,
+): MessagesFileContext {
+	const teamTaskMatch = parseTeamTaskSubSessionId(sessionId);
+	if (teamTaskMatch) {
+		return {
+			agent: "teammate",
+			sessionId: teamTaskMatch.rootSessionId,
+			taskType: "team",
+		};
+	}
+	const subSessionMatch = parseSubSessionId(sessionId);
+	if (subSessionMatch) {
+		return {
+			agent: "subagent",
+			sessionId: subSessionMatch.rootSessionId,
+			taskType: "subagent_task",
+		};
+	}
+	return {
+		agent: "lead",
+		sessionId,
+	};
+}
 
 export function buildMessagesFilePayload(input: {
 	updatedAt: string;
 	context: MessagesFileContext;
-	messages: LlmsProviders.Message[];
+	messages: LlmsProviders.MessageWithMetadata[];
 	systemPrompt?: string;
-}): MessagesFilePayload {
+}): {
+	version: 1;
+	updated_at: string;
+	agent: "lead" | "subagent" | "teammate";
+	sessionId: string;
+	taskType?: string;
+	messages: StoredMessageWithMetadata[];
+	system_prompt?: string;
+} {
 	return {
 		version: 1,
 		updated_at: input.updatedAt,
 		agent: input.context.agent,
 		sessionId: input.context.sessionId,
 		...(input.context.taskType ? { taskType: input.context.taskType } : {}),
-		...(input.systemPrompt ? { systemPrompt: input.systemPrompt } : {}),
-		messages: input.messages,
+		messages: normalizeStoredMessagesForPersistence(input.messages),
+		...(input.systemPrompt ? { system_prompt: input.systemPrompt } : {}),
 	};
 }
 
@@ -291,6 +312,7 @@ export function writeEmptyMessagesFile(
 	startedAt: string,
 	context: MessagesFileContext,
 ): void {
+	mkdirSync(dirname(path), { recursive: true });
 	writeFileSync(
 		path,
 		`${JSON.stringify(
@@ -306,40 +328,12 @@ export function writeEmptyMessagesFile(
 	);
 }
 
-export function resolveMessagesFileContext(
-	sessionId: string,
-): MessagesFileContext {
-	const teamTask = parseTeamTaskSubSessionId(sessionId);
-	if (teamTask) {
-		return {
-			agent: "teammate",
-			sessionId: teamTask.rootSessionId,
-			taskType: "team",
-		};
-	}
-
-	const subagent = parseSubSessionId(sessionId);
-	if (subagent) {
-		return {
-			agent: "subagent",
-			sessionId: subagent.rootSessionId,
-		};
-	}
-
-	return {
-		agent: "lead",
-		sessionId,
-	};
-}
-
-// ── Manifest helper ───────────────────────────────────────────────────
-
 export function buildManifestFromRow(
 	row: SessionRow,
 	overrides?: {
 		status?: SessionStatus;
-		endedAt?: string | null;
-		exitCode?: number | null;
+		endedAt?: string;
+		exitCode?: number;
 		metadata?: Record<string, unknown>;
 	},
 ): SessionManifest {
@@ -351,7 +345,7 @@ export function buildManifestFromRow(
 		started_at: row.startedAt,
 		ended_at: overrides?.endedAt ?? row.endedAt ?? undefined,
 		exit_code: overrides?.exitCode ?? row.exitCode ?? undefined,
-		status: overrides?.status ?? row.status,
+		status: (overrides?.status ?? row.status) as SessionStatus,
 		interactive: row.interactive,
 		provider: row.provider,
 		model: row.model,
@@ -367,20 +361,30 @@ export function buildManifestFromRow(
 	});
 }
 
-// ── OCC retry helper ──────────────────────────────────────────────────
-
-export const OCC_MAX_RETRIES = 4;
-
-export async function withOccRetry<T>(
-	getRow: () => Promise<{ statusLock: number } | undefined>,
-	action: (statusLock: number) => Promise<{ updated: boolean } & T>,
-	maxRetries = OCC_MAX_RETRIES,
-): Promise<({ updated: true } & T) | { updated: false }> {
-	for (let attempt = 0; attempt < maxRetries; attempt++) {
-		const row = getRow ? await getRow() : undefined;
-		if (!row) return { updated: false } as { updated: false };
-		const result = await action(row.statusLock);
-		if (result.updated) return result as { updated: true } & T;
+export async function withOccRetry<TFetch, TResult>(
+	load: () => Promise<TFetch | undefined>,
+	update: (loaded: TFetch) => Promise<TResult>,
+	maxRetries: number,
+): Promise<TResult | { updated: false }> {
+	let attempt = 0;
+	while (true) {
+		const loaded = await load();
+		if (loaded === undefined) {
+			return { updated: false };
+		}
+		const result = await update(loaded);
+		if (
+			typeof result === "object" &&
+			result !== null &&
+			"updated" in result &&
+			(result as { updated?: boolean }).updated === false
+		) {
+			attempt += 1;
+			if (attempt >= maxRetries) {
+				return result as TResult;
+			}
+			continue;
+		}
+		return result;
 	}
-	return { updated: false } as { updated: false };
 }

package/src/{session → services}/session-telemetry.ts

@@ -1,9 +1,8 @@
 import type { ITelemetryService } from "@clinebot/shared";
-import {
-	listHookConfigFiles,
-	resolveDocumentsHooksDirectoryPath,
-} from "../extensions/config/hooks-config-loader";
-import type { enrichPromptWithMentions } from "../input";
+import { resolveDocumentsExtensionPath } from "@clinebot/shared/storage";
+import { listHookConfigFiles } from "../extensions/config/hooks-config-loader";
+import type { SessionSource } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
 import {
 	captureHookDiscovery,
 	captureMentionFailed,
@@ -12,9 +11,8 @@ import {
 	captureTaskCreated,
 	captureTaskRestarted,
 	type TelemetryAgentIdentityProperties,
-} from "../telemetry/core-events";
-import type { SessionSource } from "../types/common";
-import type { CoreSessionConfig } from "../types/config";
+} from "./telemetry/core-events";
+import type { enrichPromptWithMentions } from "./workspace";
 
 export function emitSessionCreationTelemetry(
 	config: CoreSessionConfig,
@@ -57,7 +55,7 @@ export function captureHookDiscoveryTelemetry(
 	telemetry: ITelemetryService | undefined,
 	options: { workspacePath: string },
 ): void {
-	const globalHooksDir = resolveDocumentsHooksDirectoryPath();
+	const globalHooksDir = resolveDocumentsExtensionPath("Hooks");
 	const entries = listHookConfigFiles(options.workspacePath);
 	const counts = new Map<string, { global: number; workspace: number }>();
 	for (const entry of entries) {

package/src/services/storage/artifact-store.ts

@@ -0,0 +1 @@
+export type { ArtifactStore } from "../../types/storage";

package/src/{storage → services/storage}/file-team-store.ts

@@ -10,8 +10,8 @@ import {
 import { join } from "node:path";
 import type { TeamRuntimeState, TeamTeammateSpec } from "@clinebot/shared";
 import { resolveTeamDataDir } from "@clinebot/shared/storage";
-import type { TeamEvent } from "../team";
-import type { TeamStore } from "../types/storage";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { TeamStore } from "../../types/storage";
 
 function nowIso(): string {
 	return new Date().toISOString();

package/src/{storage → services/storage}/provider-settings-legacy-migration.test.ts

@@ -111,7 +111,7 @@ describe("migrateLegacyProviderSettings", () => {
 		);
 		expect(manager.getProviderSettings("anthropic")).toEqual({
 			provider: "anthropic",
-			model: "claude-sonnet-4-6",
+			model: "claude-opus-4-7",
 			apiKey: "legacy-key",
 		});
 		expect(manager.read().providers.openai?.tokenSource).toBe("manual");

package/src/{storage → services/storage}/provider-settings-legacy-migration.ts

@@ -3,8 +3,8 @@ import { dirname, join } from "node:path";
 import * as LlmsModels from "@clinebot/llms";
 import * as LlmsProviders from "@clinebot/llms";
 import { resolveClineDataDir } from "@clinebot/shared/storage";
-import type { ProviderSettings } from "../types/provider-settings";
-import { emptyStoredProviderSettings } from "../types/provider-settings";
+import type { ProviderSettings } from "../../types/provider-settings";
+import { emptyStoredProviderSettings } from "../../types/provider-settings";
 import type { ProviderSettingsManager } from "./provider-settings-manager";
 
 type LegacyMode = "plan" | "act";

package/src/{storage → services/storage}/provider-settings-manager.ts

@@ -1,7 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
 import { resolveProviderSettingsPath } from "@clinebot/shared/storage";
-import { ensureCustomProvidersLoadedSync } from "../providers/local-provider-registry";
 import {
 	emptyStoredProviderSettings,
 	type ProviderConfig,
@@ -11,7 +10,8 @@ import {
 	type StoredProviderSettings,
 	StoredProviderSettingsSchema,
 	toProviderConfig,
-} from "../types/provider-settings";
+} from "../../types/provider-settings";
+import { ensureCustomProvidersLoadedSync } from "../providers/local-provider-registry";
 import { migrateLegacyProviderSettings } from "./provider-settings-legacy-migration";
 
 function nowIso(): string {

package/src/services/storage/session-store.ts

@@ -0,0 +1 @@
+export type { SessionStore } from "../../types/storage";

package/src/{storage → services/storage}/sqlite-session-store.ts

@@ -10,14 +10,10 @@ import {
 	type SqliteDb,
 	toBoolInt,
 } from "@clinebot/shared/db";
-import { resolveSessionDataDir } from "@clinebot/shared/storage";
-import type { SessionStatus } from "../types/common";
-import type { SessionRecord } from "../types/sessions";
-import type { SessionStore } from "../types/storage";
-
-function defaultSessionsDir(): string {
-	return resolveSessionDataDir();
-}
+import { resolveDbDataDir } from "@clinebot/shared/storage";
+import type { SessionStatus } from "../../types/common";
+import type { SessionRecord } from "../../types/sessions";
+import type { SessionStore } from "../../types/storage";
 
 export interface SqliteSessionStoreOptions {
 	sessionsDir?: string;
@@ -28,7 +24,7 @@ export class SqliteSessionStore implements SessionStore {
 	private db: SqliteDb | undefined;
 
 	constructor(options: SqliteSessionStoreOptions = {}) {
-		this.sessionsDirPath = options.sessionsDir ?? defaultSessionsDir();
+		this.sessionsDirPath = options.sessionsDir ?? resolveDbDataDir();
 	}
 
 	init(): void {
@@ -115,7 +111,7 @@ export class SqliteSessionStore implements SessionStore {
 				toBoolInt(record.isSubagent),
 				record.prompt ?? null,
 				record.metadata ? JSON.stringify(record.metadata) : null,
-				record.transcriptPath ?? "",
+				"",
 				record.hookPath ?? "",
 				record.messagesPath ?? null,
 				now,
@@ -196,7 +192,7 @@ export class SqliteSessionStore implements SessionStore {
 				provider, model, cwd, workspace_root, team_name,
 				enable_tools, enable_spawn, enable_teams,
 				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent,
-				prompt, metadata_json, transcript_path, hook_path, messages_path, updated_at
+				prompt, metadata_json, hook_path, messages_path, updated_at
 			 FROM sessions WHERE session_id = ?`,
 			[sessionId],
 		);
@@ -241,7 +237,6 @@ export class SqliteSessionStore implements SessionStore {
 				}
 				return undefined;
 			})(),
-			transcriptPath: asOptionalString(row.transcript_path),
 			hookPath: asOptionalString(row.hook_path),
 			messagesPath: asOptionalString(row.messages_path),
 			updatedAt: asOptionalString(row.updated_at) ?? nowIso(),

package/src/{storage → services/storage}/sqlite-team-store.ts

@@ -6,12 +6,12 @@ import {
 	type TeamTeammateSpec,
 } from "@clinebot/shared";
 import { loadSqliteDb, nowIso, type SqliteDb } from "@clinebot/shared/db";
-import { resolveTeamDataDir } from "@clinebot/shared/storage";
-import type { TeamEvent } from "../team";
-import type { TeamStore } from "../types/storage";
+import { resolveDbDataDir } from "@clinebot/shared/storage";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { TeamStore } from "../../types/storage";
 
 function defaultTeamDir(): string {
-	return resolveTeamDataDir();
+	return resolveDbDataDir();
 }
 
 function sanitizeTeamName(name: string): string {

package/src/{storage → services/storage}/team-store.ts

@@ -1,4 +1,4 @@
-export type { TeamStore } from "../types/storage";
+export type { TeamStore } from "../../types/storage";
 export {
 	FileTeamStore,
 	type FileTeamStoreOptions,

package/src/{session/utils → services}/usage.ts

@@ -1,4 +1,4 @@
-import type { SessionAccumulatedUsage } from "../session-manager";
+import type { SessionAccumulatedUsage } from "../runtime/runtime-host";
 
 export function createInitialAccumulatedUsage(): SessionAccumulatedUsage {
 	return {

package/src/{input → services/workspace}/file-indexer.test.ts

@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { describe, expect, it, vi } from "vitest";
@@ -85,6 +85,35 @@ describe("file indexer", () => {
 		}
 	});
 
+	it("skips unreadable directories during fallback indexing", async () => {
+		const cwd = await createTempWorkspace();
+		const unreadableDir = path.join(cwd, "private");
+		try {
+			await mkdir(unreadableDir, { recursive: true });
+			await writeFile(
+				path.join(cwd, "visible.ts"),
+				"export const ok = 1\n",
+				"utf8",
+			);
+			await writeFile(
+				path.join(unreadableDir, "hidden.ts"),
+				"export const hidden = 1\n",
+				"utf8",
+			);
+			await chmod(unreadableDir, 0o000);
+
+			await expect(
+				prewarmFileIndex(cwd, { ttlMs: 0 }),
+			).resolves.toBeUndefined();
+
+			const index = await getFileIndex(cwd, { ttlMs: 0 });
+			expect(index.has("visible.ts")).toBe(true);
+		} finally {
+			await chmod(unreadableDir, 0o755).catch(() => undefined);
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
 	it("evicts stale workspace indexes after 10 minutes when multiple workspaces exist", async () => {
 		vi.useFakeTimers();
 		const firstWorkspace = await createTempWorkspace();

package/src/{input → services/workspace}/file-indexer.ts

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import type { Dirent } from "node:fs";
 import { readdir } from "node:fs/promises";
 import path from "node:path";
 import { isMainThread, parentPort, Worker } from "node:worker_threads";
@@ -19,6 +20,14 @@ const DEFAULT_EXCLUDE_DIRS = new Set([
 	"out",
 ]);
 
+function shouldSkipWalkError(error: unknown): boolean {
+	const code =
+		error && typeof error === "object" && "code" in error
+			? String((error as { code?: unknown }).code ?? "")
+			: "";
+	return code === "EACCES" || code === "EPERM" || code === "ENOENT";
+}
+
 interface CacheEntry {
 	files: Set<string>;
 	lastBuiltAt: number;
@@ -103,14 +112,29 @@ async function walkDir(
 	dir: string,
 	files: Set<string>,
 ): Promise<void> {
-	const entries = await readdir(dir, { withFileTypes: true });
+	let entries: Dirent[];
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch (error) {
+		if (shouldSkipWalkError(error)) {
+			return;
+		}
+		throw error;
+	}
 	for (const entry of entries) {
 		const absolutePath = path.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			if (DEFAULT_EXCLUDE_DIRS.has(entry.name)) {
 				continue;
 			}
-			await walkDir(cwd, absolutePath, files);
+			try {
+				await walkDir(cwd, absolutePath, files);
+			} catch (error) {
+				if (shouldSkipWalkError(error)) {
+					continue;
+				}
+				throw error;
+			}
 			continue;
 		}
 		if (entry.isFile()) {

package/src/{input → services/workspace}/mention-enricher.test.ts

@@ -82,4 +82,25 @@ describe("enrichPromptWithMentions", () => {
 			await rm(cwd, { recursive: true, force: true });
 		}
 	});
+
+	it("does not over-count totalBytes across multiple mentions", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await writeFile(path.join(cwd, "a.ts"), "aaa", "utf8");
+			await writeFile(path.join(cwd, "b.ts"), "bbb", "utf8");
+			await writeFile(path.join(cwd, "c.ts"), "ccc", "utf8");
+
+			const result = await enrichPromptWithMentions(
+				"Use @a.ts @b.ts @c.ts",
+				cwd,
+				{ maxTotalBytes: 15, maxFiles: 5, maxFileBytes: 5 },
+			);
+
+			expect(result.mentions).toEqual(["a.ts", "b.ts", "c.ts"]);
+			expect(result.matchedFiles).toEqual(["a.ts", "b.ts", "c.ts"]);
+			expect(result.ignoredMentions).toEqual([]);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
 });

package/src/{input → services/workspace}/mention-enricher.ts

@@ -106,7 +106,7 @@ export async function enrichPromptWithMentions(
 				continue;
 			}
 
-			totalBytes += nextBytes;
+			totalBytes = nextBytes;
 			matched.push(relativePath);
 		} catch {
 			ignored.push(mention);

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

@@ -7,6 +7,7 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { resolveSessionDataDir } from "@clinebot/shared/storage";
+import type { SessionMessagesArtifactUploader } from "../types/session";
 import type {
 	PersistedSessionUpdateInput,
 	SessionPersistenceAdapter,
@@ -45,13 +46,9 @@ function atomicWriteJson(path: string, value: unknown): void {
 	renameSync(tempPath, path);
 }
 
-function defaultSessionsDir(): string {
-	return resolveSessionDataDir();
-}
-
 class FileSessionPersistenceAdapter implements SessionPersistenceAdapter {
 	constructor(
-		private readonly sessionsDirPath: string = defaultSessionsDir(),
+		private readonly sessionsDirPath: string = resolveSessionDataDir(),
 	) {}
 
 	ensureSessionsDir(): string {
@@ -270,8 +267,13 @@ class FileSessionPersistenceAdapter implements SessionPersistenceAdapter {
 }
 
 export class FileSessionService extends UnifiedSessionPersistenceService {
-	constructor(sessionsDir?: string) {
-		super(new FileSessionPersistenceAdapter(sessionsDir));
+	constructor(
+		sessionsDir?: string,
+		options: {
+			messagesArtifactUploader?: SessionMessagesArtifactUploader;
+		} = {},
+	) {
+		super(new FileSessionPersistenceAdapter(sessionsDir), options);
 	}
 
 	override ensureSessionsDir(): string {

package/src/session/index.ts

@@ -7,8 +7,32 @@ export {
 export type {
 	ClineCore,
 	ClineCoreOptions,
+	ClineCoreStartInput,
 } from "../ClineCore";
-export { DefaultSessionManager } from "./default-session-manager";
+export type { SessionBackend } from "../runtime/host";
+export {
+	createRuntimeHost,
+	resolveSessionBackend,
+} from "../runtime/host";
+export type {
+	LocalRuntimeConfigOverrides,
+	LocalRuntimeStartOptions,
+	RuntimeHost,
+	RuntimeHost as SessionHost,
+	RuntimeHostMode,
+	RuntimeSessionConfig,
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	StartSessionInput,
+	StartSessionResult,
+} from "../runtime/runtime-host";
+export { splitCoreSessionConfig } from "../runtime/runtime-host";
+export {
+	generateWorkspaceInfo,
+	normalizeWorkspacePath,
+} from "../services/workspace-manifest";
+export { LocalRuntimeHost } from "../transports/local";
+export { RpcRuntimeHost } from "../transports/rpc";
 export { RpcCoreSessionService } from "./rpc-session-service";
 export {
 	deriveSubsessionStatus,
@@ -16,18 +40,6 @@ export {
 	makeTeamTaskSubSessionId,
 	sanitizeSessionToken,
 } from "./session-graph";
-export type {
-	SessionBackend,
-	SessionHost,
-} from "./session-host";
-export { createSessionHost, resolveSessionBackend } from "./session-host";
-export type {
-	SendSessionInput,
-	SessionAccumulatedUsage,
-	SessionManager,
-	StartSessionInput,
-	StartSessionResult,
-} from "./session-manager";
 export type { SessionManifest } from "./session-manifest";
 export type {
 	CreateRootSessionWithArtifactsInput,
@@ -39,7 +51,3 @@ export type {
 	WorkspaceManagerEvent,
 } from "./workspace-manager";
 export { InMemoryWorkspaceManager } from "./workspace-manager";
-export {
-	generateWorkspaceInfo,
-	normalizeWorkspacePath,
-} from "./workspace-manifest";