@clinebot/core 0.0.22 → 0.0.24

package/src/chat/chat-schema.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+
+export const ChatSessionConfigSchema = z.object({
+	workspaceRoot: z.string().min(1),
+	cwd: z.string().optional(),
+	provider: z.string().min(1),
+	model: z.string().min(1),
+	mode: z.enum(["act", "plan"]).default("act"),
+	apiKey: z.string(),
+	systemPrompt: z.string().optional(),
+	rules: z.string().optional(),
+	maxIterations: z.number().int().positive().optional(),
+	enableTools: z.boolean(),
+	enableSpawn: z.boolean(),
+	enableTeams: z.boolean(),
+	autoApproveTools: z.boolean().optional(),
+	teamName: z.string().min(1),
+	missionStepInterval: z.number().int().positive(),
+	missionTimeIntervalMs: z.number().int().positive(),
+});
+
+export const ChatSessionStatusSchema = z.enum([
+	"idle",
+	"starting",
+	"running",
+	"stopping",
+	"completed",
+	"cancelled",
+	"failed",
+	"error",
+]);
+
+export const ChatMessageRoleSchema = z.enum([
+	"user",
+	"assistant",
+	"tool",
+	"system",
+	"status",
+	"error",
+]);
+
+export const ChatMessageSchema = z.object({
+	id: z.string().min(1),
+	sessionId: z.string().nullable(),
+	role: ChatMessageRoleSchema,
+	content: z.string(),
+	createdAt: z.number().int().nonnegative(),
+	meta: z
+		.object({
+			stream: z.enum(["stdout", "stderr"]).optional(),
+			toolName: z.string().optional(),
+			iteration: z.number().int().nonnegative().optional(),
+			agentId: z.string().optional(),
+			conversationId: z.string().optional(),
+			hookEventName: z.string().optional(),
+			inputTokens: z.number().int().nonnegative().optional(),
+			outputTokens: z.number().int().nonnegative().optional(),
+		})
+		.optional(),
+});
+
+export const ChatSummarySchema = z.object({
+	toolCalls: z.number().int().nonnegative(),
+	tokensIn: z.number().int().nonnegative(),
+	tokensOut: z.number().int().nonnegative(),
+});
+
+export const ChatViewStateSchema = z.object({
+	sessionId: z.string().nullable(),
+	status: ChatSessionStatusSchema,
+	config: ChatSessionConfigSchema,
+	messages: z.array(ChatMessageSchema),
+	rawTranscript: z.string(),
+	error: z.string().nullable(),
+	summary: ChatSummarySchema,
+});
+
+export type ChatSessionConfig = z.infer<typeof ChatSessionConfigSchema>;
+export type ChatSessionStatus = z.infer<typeof ChatSessionStatusSchema>;
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export type ChatSummary = z.infer<typeof ChatSummarySchema>;
+export type ChatViewState = z.infer<typeof ChatViewStateSchema>;

package/src/index.ts

@@ -0,0 +1,479 @@
+/**
+ * @clinebot/core
+ *
+ * Core contracts, shared state utilities, and Node runtime services.
+ */
+
+export {
+	type AgentConfig,
+	type CreateMcpToolsOptions,
+	createMcpTools,
+	createTool,
+	getClineDefaultSystemPrompt,
+	type Tool,
+	type ToolApprovalRequest,
+	type ToolApprovalResult,
+	type ToolContext,
+} from "@clinebot/agents";
+export * as LlmsModels from "@clinebot/llms/models";
+export * as LlmsProviders from "@clinebot/llms/providers";
+// Shared contracts and path helpers re-exported for app consumers.
+export type {
+	AgentMode,
+	BasicLogger,
+	ConnectorHookEvent,
+	HookSessionContext,
+	ITelemetryService,
+	RpcAddProviderActionRequest,
+	RpcChatMessage,
+	RpcChatRunTurnRequest,
+	RpcChatRuntimeConfigBase,
+	RpcChatRuntimeLoggerConfig,
+	RpcChatStartSessionArtifacts,
+	RpcChatStartSessionRequest,
+	RpcChatTurnResult,
+	RpcClineAccountActionRequest,
+	RpcOAuthProviderId,
+	RpcProviderActionRequest,
+	RpcProviderCapability,
+	RpcProviderCatalogResponse,
+	RpcProviderListItem,
+	RpcProviderModel,
+	RpcProviderOAuthLoginResponse,
+	RpcSaveProviderSettingsActionRequest,
+	SessionLineage,
+	TeamProgressProjectionEvent,
+	TelemetryArray,
+	TelemetryMetadata,
+	TelemetryObject,
+	TelemetryPrimitive,
+	TelemetryProperties,
+	TelemetryValue,
+	ToolPolicy,
+} from "@clinebot/shared";
+export {
+	normalizeUserInput,
+	RPC_TEAM_LIFECYCLE_EVENT_TYPE,
+	RPC_TEAM_PROGRESS_EVENT_TYPE,
+	resolveHookLogPath,
+} from "@clinebot/shared";
+export * from "@clinebot/shared/storage";
+export {
+	type ClineAccountBalance,
+	type ClineAccountOperations,
+	type ClineAccountOrganization,
+	type ClineAccountOrganizationBalance,
+	type ClineAccountOrganizationUsageTransaction,
+	type ClineAccountPaymentTransaction,
+	ClineAccountService,
+	type ClineAccountServiceOptions,
+	type ClineAccountUsageTransaction,
+	type ClineAccountUser,
+	type ClineOrganization,
+	executeRpcClineAccountAction,
+	type FeaturebaseTokenResponse,
+	isRpcClineAccountActionRequest,
+	RpcClineAccountService,
+	type RpcProviderActionExecutor,
+	type UserRemoteConfigResponse,
+} from "./account";
+export type {
+	AgentConfigWatcher,
+	AgentConfigWatcherEvent,
+	AgentYamlConfig,
+	BuildAgentConfigOverridesOptions,
+	CreateAgentConfigWatcherOptions,
+	CreateInstructionWatcherOptions,
+	CreateRulesConfigDefinitionOptions,
+	CreateSkillsConfigDefinitionOptions,
+	CreateUserInstructionConfigWatcherOptions,
+	CreateWorkflowsConfigDefinitionOptions,
+	HookConfigFileEntry,
+	LoadAgentPluginFromPathOptions,
+	ParseMarkdownFrontmatterResult,
+	ParseYamlFrontmatterResult,
+	ResolveAgentPluginPathsOptions,
+	RuleConfig,
+	SkillConfig,
+	UnifiedConfigDefinition,
+	UnifiedConfigFileCandidate,
+	UnifiedConfigFileContext,
+	UnifiedConfigRecord,
+	UnifiedConfigWatcherEvent,
+	UnifiedConfigWatcherOptions,
+	UserInstructionConfig,
+	UserInstructionConfigType,
+	UserInstructionConfigWatcher,
+	UserInstructionConfigWatcherEvent,
+	WorkflowConfig,
+} from "./agents";
+export {
+	createAgentConfigDefinition,
+	createAgentConfigWatcher,
+	createRulesConfigDefinition,
+	createSkillsConfigDefinition,
+	createUserInstructionConfigWatcher,
+	createWorkflowsConfigDefinition,
+	discoverPluginModulePaths,
+	HOOK_CONFIG_FILE_EVENT_MAP,
+	HOOKS_CONFIG_DIRECTORY_NAME,
+	HookConfigFileName,
+	listHookConfigFiles,
+	loadAgentPluginFromPath,
+	loadAgentPluginsFromPaths,
+	parseAgentConfigFromYaml,
+	parsePartialAgentConfigFromYaml,
+	parseRuleConfigFromMarkdown,
+	parseSkillConfigFromMarkdown,
+	parseWorkflowConfigFromMarkdown,
+	RULES_CONFIG_DIRECTORY_NAME,
+	resolveAgentPluginPaths,
+	resolveAgentTools,
+	resolveAndLoadAgentPlugins,
+	resolveDocumentsHooksDirectoryPath,
+	resolveDocumentsRulesDirectoryPath,
+	resolveDocumentsWorkflowsDirectoryPath,
+	resolveHooksConfigSearchPaths,
+	resolvePluginConfigSearchPaths,
+	resolveRulesConfigSearchPaths,
+	resolveSkillsConfigSearchPaths,
+	resolveWorkflowsConfigSearchPaths,
+	SKILLS_CONFIG_DIRECTORY_NAME,
+	toHookConfigFileName,
+	toPartialAgentConfig,
+	UnifiedConfigFileWatcher,
+	WORKFLOWS_CONFIG_DIRECTORY_NAME,
+} from "./agents";
+export {
+	createOAuthClientCallbacks,
+	type OAuthClientCallbacksOptions,
+} from "./auth/client";
+export {
+	createClineOAuthProvider,
+	getValidClineCredentials,
+	loginClineOAuth,
+	refreshClineToken,
+} from "./auth/cline";
+export {
+	getValidOpenAICodexCredentials,
+	isOpenAICodexTokenExpired,
+	loginOpenAICodex,
+	normalizeOpenAICodexCredentials,
+	openaiCodexOAuthProvider,
+	refreshOpenAICodexToken,
+} from "./auth/codex";
+export {
+	createOcaOAuthProvider,
+	createOcaRequestHeaders,
+	DEFAULT_EXTERNAL_IDCS_CLIENT_ID,
+	DEFAULT_EXTERNAL_IDCS_SCOPES,
+	DEFAULT_EXTERNAL_IDCS_URL,
+	DEFAULT_EXTERNAL_OCA_BASE_URL,
+	DEFAULT_INTERNAL_IDCS_CLIENT_ID,
+	DEFAULT_INTERNAL_IDCS_SCOPES,
+	DEFAULT_INTERNAL_IDCS_URL,
+	DEFAULT_INTERNAL_OCA_BASE_URL,
+	generateOcaOpcRequestId,
+	getValidOcaCredentials,
+	loginOcaOAuth,
+	OCI_HEADER_OPC_REQUEST_ID,
+	refreshOcaToken,
+} from "./auth/oca";
+export { startLocalOAuthServer } from "./auth/server";
+export type {
+	OAuthCredentials,
+	OAuthLoginCallbacks,
+	OAuthPrompt,
+	OAuthProviderInterface,
+	OcaClientMetadata,
+	OcaMode,
+	OcaOAuthConfig,
+	OcaOAuthEnvironmentConfig,
+	OcaOAuthProviderOptions,
+	OcaTokenResolution,
+} from "./auth/types";
+export {
+	ClineCore,
+	type ClineCoreOptions,
+	type RpcOptions,
+} from "./ClineCore";
+export type {
+	ChatMessage,
+	ChatSessionConfig,
+	ChatSessionStatus,
+	ChatSummary,
+	ChatViewState,
+} from "./chat/chat-schema";
+export {
+	ChatMessageRoleSchema,
+	ChatMessageSchema,
+	ChatSessionConfigSchema,
+	ChatSessionStatusSchema,
+	ChatSummarySchema,
+	ChatViewStateSchema,
+} from "./chat/chat-schema";
+export type {
+	FastFileIndexOptions,
+	MentionEnricherOptions,
+	MentionEnrichmentResult,
+} from "./input";
+export {
+	enrichPromptWithMentions,
+	getFileIndex,
+	prewarmFileIndex,
+} from "./input";
+export {
+	hasMcpSettingsFile,
+	InMemoryMcpManager,
+	type LoadMcpSettingsOptions,
+	loadMcpSettingsFile,
+	type McpConnectionStatus,
+	type McpManager,
+	type McpManagerOptions,
+	type McpServerClient,
+	type McpServerClientFactory,
+	type McpServerRegistration,
+	type McpServerSnapshot,
+	type McpServerTransportConfig,
+	type McpSettingsFile,
+	type McpSseTransportConfig,
+	type McpStdioTransportConfig,
+	type McpStreamableHttpTransportConfig,
+	type RegisterMcpServersFromSettingsOptions,
+	registerMcpServersFromSettingsFile,
+	resolveDefaultMcpSettingsPath,
+	resolveMcpServerRegistrations,
+} from "./mcp";
+export {
+	addLocalProvider,
+	ensureCustomProvidersLoaded,
+	getLocalProviderModels,
+	listLocalProviders,
+	loginLocalProvider,
+	normalizeOAuthProvider,
+	resolveLocalClineAuthToken,
+	saveLocalProviderOAuthCredentials,
+	saveLocalProviderSettings,
+} from "./providers/local-provider-service";
+export type { AvailableRuntimeCommand } from "./runtime/commands";
+export {
+	listAvailableRuntimeCommandsFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./runtime/commands";
+export {
+	formatRulesForSystemPrompt,
+	isRuleEnabled,
+	listEnabledRulesFromWatcher,
+	loadRulesForSystemPromptFromWatcher,
+} from "./runtime/rules";
+export {
+	createTeamName,
+	DefaultRuntimeBuilder,
+} from "./runtime/runtime-builder";
+export {
+	type SandboxCallOptions,
+	SubprocessSandbox,
+	type SubprocessSandboxOptions,
+} from "./runtime/sandbox/subprocess-sandbox";
+export type {
+	BuiltRuntime,
+	RuntimeBuilder,
+	RuntimeBuilderInput,
+	SessionRuntime,
+} from "./runtime/session-runtime";
+export type { AvailableSkill } from "./runtime/skills";
+export {
+	listAvailableSkillsFromWatcher,
+	resolveSkillsSlashCommandFromWatcher,
+} from "./runtime/skills";
+export {
+	type DesktopToolApprovalOptions,
+	requestDesktopToolApproval,
+} from "./runtime/tool-approval";
+export type { AvailableWorkflow } from "./runtime/workflows";
+export {
+	listAvailableWorkflowsFromWatcher,
+	resolveWorkflowSlashCommandFromWatcher,
+} from "./runtime/workflows";
+export { DefaultSessionManager } from "./session/default-session-manager";
+export {
+	clearRpcDiscoveryIfAddressMatches,
+	type EnsureRpcRuntimeOptions,
+	ensureRpcRuntimeAddress,
+	isCompatibleRuntime,
+	type ResolveRpcRuntimeResult,
+	RPC_BUILD_ID_ENV,
+	RPC_DISCOVERY_PATH_ENV,
+	RPC_OWNER_ID_ENV,
+	RPC_STARTUP_LOCK_BYPASS_ENV,
+	type RpcDiscoveryRecord,
+	type RpcOwnerContext,
+	recordRpcDiscovery,
+	resolveEnsuredRpcRuntime,
+	resolveRpcOwnerContext,
+	resolveRpcRuntimeBuildKey,
+	waitForCompatibleRpcRuntime,
+	withRpcStartupLock,
+} from "./session/rpc-runtime-ensure";
+export { RpcCoreSessionService } from "./session/rpc-session-service";
+export {
+	type RpcSpawnLease,
+	tryAcquireRpcSpawnLease,
+} from "./session/rpc-spawn-lease";
+export {
+	deriveSubsessionStatus,
+	makeSubSessionId,
+	makeTeamTaskSubSessionId,
+	sanitizeSessionToken,
+} from "./session/session-graph";
+export type {
+	SessionBackend,
+	SessionHost,
+} from "./session/session-host";
+export {
+	createSessionHost,
+	resolveSessionBackend,
+} from "./session/session-host";
+export type {
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	SessionManager,
+	StartSessionInput,
+	StartSessionResult,
+} from "./session/session-manager";
+export type { SessionManifest } from "./session/session-manifest";
+export type {
+	CreateRootSessionWithArtifactsInput,
+	RootSessionArtifacts,
+} from "./session/session-service";
+export { CoreSessionService } from "./session/session-service";
+export {
+	createSqliteRpcSessionBackend,
+	SqliteRpcSessionBackend,
+	type SqliteRpcSessionBackendOptions,
+} from "./session/sqlite-rpc-session-backend";
+export {
+	accumulateUsageTotals,
+	createInitialAccumulatedUsage,
+} from "./session/utils/usage";
+export type {
+	WorkspaceManager,
+	WorkspaceManagerEvent,
+} from "./session/workspace-manager";
+export { InMemoryWorkspaceManager } from "./session/workspace-manager";
+export type { WorkspaceManifest } from "./session/workspace-manifest";
+export {
+	buildWorkspaceMetadata,
+	emptyWorkspaceManifest,
+	generateWorkspaceInfo,
+	normalizeWorkspacePath,
+	upsertWorkspaceInfo,
+	WorkspaceInfoSchema,
+	WorkspaceManifestSchema,
+} from "./session/workspace-manifest";
+export {
+	type MigrateLegacyProviderSettingsOptions,
+	type MigrateLegacyProviderSettingsResult,
+	migrateLegacyProviderSettings,
+} from "./storage/provider-settings-legacy-migration";
+export { ProviderSettingsManager } from "./storage/provider-settings-manager";
+export { SqliteSessionStore } from "./storage/sqlite-session-store";
+export {
+	SqliteTeamStore,
+	type SqliteTeamStoreOptions,
+} from "./storage/team-store";
+export {
+	buildTeamProgressSummary,
+	toTeamProgressLifecycleEvent,
+} from "./team";
+export type {
+	TelemetryAgentIdentityProperties,
+	TelemetryAgentKind,
+} from "./telemetry/core-events";
+export {
+	CORE_TELEMETRY_EVENTS,
+	captureAgentCreated,
+	captureAgentTeamCreated,
+	captureAuthFailed,
+	captureAuthLoggedOut,
+	captureAuthStarted,
+	captureAuthSucceeded,
+	captureConversationTurnEvent,
+	captureDiffEditFailure,
+	captureHookDiscovery,
+	captureMentionFailed,
+	captureMentionSearchResults,
+	captureMentionUsed,
+	captureModeSwitch,
+	captureProviderApiError,
+	captureSkillUsed,
+	captureSubagentExecution,
+	captureTaskCompleted,
+	captureTaskCreated,
+	captureTaskRestarted,
+	captureTokenUsage,
+	captureToolUsage,
+	identifyAccount,
+} from "./telemetry/core-events";
+export type { ITelemetryAdapter } from "./telemetry/ITelemetryAdapter";
+export {
+	LoggerTelemetryAdapter,
+	type LoggerTelemetryAdapterOptions,
+} from "./telemetry/LoggerTelemetryAdapter";
+export { CORE_BUILD_VERSION } from "./version";
+export async function loadOpenTelemetryAdapter() {
+	return import("./telemetry/index.js");
+}
+export {
+	TelemetryService,
+	type TelemetryServiceOptions,
+} from "./telemetry/TelemetryService";
+export {
+	ALL_DEFAULT_TOOL_NAMES,
+	type AskQuestionExecutor,
+	type CreateBuiltinToolsOptions,
+	type CreateDefaultToolsOptions,
+	createBuiltinTools,
+	createDefaultExecutors,
+	createDefaultTools,
+	createDefaultToolsWithPreset,
+	createToolPoliciesWithPreset,
+	type DefaultExecutorsOptions,
+	type DefaultToolName,
+	DefaultToolNames,
+	type DefaultToolsConfig,
+	type ToolExecutors,
+	type ToolPolicyPresetName,
+	type ToolPresetName,
+	ToolPresets,
+} from "./tools";
+// Compatibility barrel (legacy imports).
+export type { RuntimeEnvironment, SessionEvent, StoredMessages } from "./types";
+export type { SessionStatus } from "./types/common";
+export { SESSION_STATUSES, SessionSource } from "./types/common";
+export type {
+	CoreAgentMode,
+	CoreModelConfig,
+	CoreRuntimeFeatures,
+	CoreSessionConfig,
+} from "./types/config";
+export type {
+	CoreSessionEvent,
+	SessionChunkEvent,
+	SessionEndedEvent,
+	SessionTeamProgressEvent,
+	SessionToolEvent,
+} from "./types/events";
+export type {
+	ProviderTokenSource,
+	StoredProviderSettings,
+	StoredProviderSettingsEntry,
+} from "./types/provider-settings";
+export {
+	emptyStoredProviderSettings,
+	StoredProviderSettingsEntrySchema,
+	StoredProviderSettingsSchema,
+} from "./types/provider-settings";
+export type { SessionRecord, SessionRef } from "./types/sessions";
+export type { ArtifactStore, SessionStore, TeamStore } from "./types/storage";
+export type { WorkspaceInfo } from "./types/workspace";

package/src/input/file-indexer.d.ts

@@ -0,0 +1,11 @@
+export interface FastFileIndexOptions {
+	ttlMs?: number;
+}
+export declare function getFileIndex(
+	cwd: string,
+	options?: FastFileIndexOptions,
+): Promise<Set<string>>;
+export declare function prewarmFileIndex(
+	cwd: string,
+	options?: FastFileIndexOptions,
+): Promise<void>;

package/src/input/file-indexer.test.ts

@@ -0,0 +1,127 @@
+import { 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";
+import { getFileIndex, prewarmFileIndex } from "./file-indexer";
+
+vi.mock("node:worker_threads", async () => {
+	const actual = await vi.importActual<typeof import("node:worker_threads")>(
+		"node:worker_threads",
+	);
+	return {
+		...actual,
+		isMainThread: false,
+		parentPort: null,
+	};
+});
+
+async function createTempWorkspace(): Promise<string> {
+	return mkdtemp(path.join(os.tmpdir(), "core-file-index-"));
+}
+
+describe("file indexer", () => {
+	it("indexes files by relative posix path", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await mkdir(path.join(cwd, "src"), { recursive: true });
+			await writeFile(path.join(cwd, "src", "main.ts"), "export {}\n", "utf8");
+			await writeFile(path.join(cwd, "README.md"), "# Demo\n", "utf8");
+
+			const index = await getFileIndex(cwd, { ttlMs: 0 });
+			expect(index.has("src/main.ts")).toBe(true);
+			expect(index.has("README.md")).toBe(true);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("always excludes .git files from index", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await mkdir(path.join(cwd, ".git"), { recursive: true });
+			await mkdir(path.join(cwd, "node_modules", "pkg"), { recursive: true });
+			await writeFile(path.join(cwd, ".git", "config"), "[core]\n", "utf8");
+			await writeFile(
+				path.join(cwd, "node_modules", "pkg", "index.js"),
+				"module.exports = {}\n",
+				"utf8",
+			);
+			await writeFile(
+				path.join(cwd, "app.ts"),
+				"export const app = 1\n",
+				"utf8",
+			);
+
+			const index = await getFileIndex(cwd, { ttlMs: 0 });
+			expect(index.has("app.ts")).toBe(true);
+			expect(index.has(".git/config")).toBe(false);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
+	it("prewarm rebuilds index and includes new files", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await writeFile(
+				path.join(cwd, "first.ts"),
+				"export const first = 1\n",
+				"utf8",
+			);
+			const firstIndex = await getFileIndex(cwd, { ttlMs: 60_000 });
+			expect(firstIndex.has("first.ts")).toBe(true);
+
+			await writeFile(
+				path.join(cwd, "second.ts"),
+				"export const second = 2\n",
+				"utf8",
+			);
+			await prewarmFileIndex(cwd, { ttlMs: 60_000 });
+
+			const rebuilt = await getFileIndex(cwd, { ttlMs: 60_000 });
+			expect(rebuilt.has("second.ts")).toBe(true);
+		} finally {
+			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();
+		const secondWorkspace = await createTempWorkspace();
+		try {
+			await writeFile(
+				path.join(firstWorkspace, "first.ts"),
+				"export const first = 1\n",
+				"utf8",
+			);
+			await writeFile(
+				path.join(secondWorkspace, "second.ts"),
+				"export const second = 2\n",
+				"utf8",
+			);
+
+			const firstIndex = await getFileIndex(firstWorkspace, { ttlMs: 60_000 });
+			expect(firstIndex.has("first.ts")).toBe(true);
+
+			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
+			vi.advanceTimersByTime(10 * 60_000 + 1);
+
+			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
+			await writeFile(
+				path.join(firstWorkspace, "later.ts"),
+				"export const later = 3\n",
+				"utf8",
+			);
+
+			const rebuiltFirstIndex = await getFileIndex(firstWorkspace, {
+				ttlMs: 60_000,
+			});
+			expect(rebuiltFirstIndex.has("later.ts")).toBe(true);
+		} finally {
+			vi.useRealTimers();
+			await rm(firstWorkspace, { recursive: true, force: true });
+			await rm(secondWorkspace, { recursive: true, force: true });
+		}
+	});
+});