@clinebot/core 0.0.33 → 0.0.35

package/src/runtime/runtime-builder.ts

@@ -16,13 +16,6 @@ import {
 	registerMcpServersFromSettingsFile,
 	resolveDefaultMcpSettingsPath,
 } from "../extensions/mcp";
-import { createLocalTeamStore } from "../storage/team-store";
-import {
-	AgentTeamsRuntime,
-	bootstrapAgentTeams,
-	createDelegatedAgentConfigProvider,
-	type TeamEvent,
-} from "../team";
 import {
 	createBuiltinTools,
 	DEFAULT_MODEL_TOOL_ROUTING_RULES,
@@ -32,14 +25,20 @@ import {
 	type ToolExecutors,
 	ToolPresets,
 	type ToolRoutingRule,
-} from "../tools";
+} from "../extensions/tools";
+import {
+	AgentTeamsRuntime,
+	bootstrapAgentTeams,
+	createDelegatedAgentConfigProvider,
+	type TeamEvent,
+} from "../extensions/tools/team";
+import { createLocalTeamStore } from "../services/storage/team-store";
 import type { CoreAgentMode, CoreSessionConfig } from "../types/config";
 import type {
 	RuntimeBuilder,
 	RuntimeBuilderInput,
 	BuiltRuntime as RuntimeEnvironment,
 } from "./session-runtime";
-import { TeamRuntimeRegistry } from "./team-runtime-registry";
 
 type SkillsExecutorMetadataItem = {
 	id: string;
@@ -52,6 +51,29 @@ type SkillsExecutorWithMetadata = SkillsExecutor & {
 	configuredSkills?: SkillsExecutorMetadataItem[];
 };
 
+function isToolEnabledByPolicies(
+	toolName: string,
+	toolPolicies: CoreSessionConfig["toolPolicies"],
+): boolean {
+	const globalPolicy = toolPolicies?.["*"] ?? {};
+	const toolPolicy = toolPolicies?.[toolName] ?? {};
+	return (
+		{
+			...globalPolicy,
+			...toolPolicy,
+		}.enabled !== false
+	);
+}
+
+function filterToolsByPolicies(
+	tools: Tool[],
+	toolPolicies: CoreSessionConfig["toolPolicies"],
+): Tool[] {
+	return tools.filter((tool) =>
+		isToolEnabledByPolicies(tool.name, toolPolicies),
+	);
+}
+
 export function createTeamName(): string {
 	return `team-${nanoid(5)}`;
 }
@@ -60,13 +82,13 @@ function createBuiltinToolsList(
 	cwd: string,
 	providerId: string,
 	mode: CoreAgentMode,
-	yolo: boolean | undefined,
 	modelId: string,
 	toolRoutingRules: ToolRoutingRule[] | undefined,
+	toolPolicies: CoreSessionConfig["toolPolicies"],
 	skillsExecutor?: SkillsExecutorWithMetadata,
 	executorOverrides?: Partial<ToolExecutors>,
 ): Tool[] {
-	const preset = ToolPresets[resolveToolPresetName({ mode, yolo })];
+	const preset = ToolPresets[resolveToolPresetName({ mode })];
 	const toolRoutingConfig = resolveToolRoutingConfig(
 		providerId,
 		modelId,
@@ -74,20 +96,23 @@ function createBuiltinToolsList(
 		toolRoutingRules ?? DEFAULT_MODEL_TOOL_ROUTING_RULES,
 	);
 
-	return createBuiltinTools({
-		cwd,
-		...preset,
-		enableSkills: !!skillsExecutor,
-		...toolRoutingConfig,
-		executors: {
-			...(skillsExecutor
-				? {
-						skills: skillsExecutor,
-					}
-				: {}),
-			...(executorOverrides ?? {}),
-		},
-	});
+	return filterToolsByPolicies(
+		createBuiltinTools({
+			cwd,
+			...preset,
+			enableSkills: !!skillsExecutor,
+			...toolRoutingConfig,
+			executors: {
+				...(skillsExecutor
+					? {
+							skills: skillsExecutor,
+						}
+					: {}),
+				...(executorOverrides ?? {}),
+			},
+		}),
+		toolPolicies,
+	);
 }
 
 const SKILL_FILE_NAME = "SKILL.md";
@@ -96,7 +121,7 @@ function listAvailableSkillNames(
 	watcher: UserInstructionConfigWatcher,
 	allowedSkillNames?: ReadonlyArray<string>,
 ): string[] {
-	return listConfiguredSkills(watcher, allowedSkillNames)
+	return getConfiguredSkills(watcher, allowedSkillNames)
 		.filter((skill) => !skill.disabled)
 		.map((skill) => skill.name.trim())
 		.filter((name) => name.length > 0)
@@ -143,10 +168,14 @@ function isSkillAllowed(
 	);
 }
 
-function listConfiguredSkills(
+type ConfiguredSkill = SkillsExecutorMetadataItem & {
+	skill: SkillConfig;
+};
+
+function getConfiguredSkills(
 	watcher: UserInstructionConfigWatcher,
 	allowedSkillNames?: ReadonlyArray<string>,
-): SkillsExecutorMetadataItem[] {
+): ConfiguredSkill[] {
 	const allowedSkills = toAllowedSkillSet(allowedSkillNames);
 	const snapshot = watcher.getSnapshot("skill");
 	return [...snapshot.entries()]
@@ -157,6 +186,7 @@ function listConfiguredSkills(
 				name: skill.name.trim(),
 				description: skill.description?.trim(),
 				disabled: skill.disabled === true,
+				skill,
 			};
 		})
 		.filter((skill) => isSkillAllowed(skill.id, skill.name, allowedSkills));
@@ -254,28 +284,22 @@ function resolveSkillRecord(
 	requestedSkill: string,
 	allowedSkillNames?: ReadonlyArray<string>,
 ): { id: string; skill: SkillConfig } | { error: string } {
-	const allowedSkills = toAllowedSkillSet(allowedSkillNames);
 	const normalized = requestedSkill.trim().replace(/^\/+/, "").toLowerCase();
 	if (!normalized) {
 		return { error: "Missing skill name." };
 	}
 
-	const snapshot = watcher.getSnapshot("skill");
-	const scopedEntries = [...snapshot.entries()].filter(([id, record]) => {
-		const skill = record.item as SkillConfig;
-		return isSkillAllowed(id, skill.name, allowedSkills);
-	});
-	const scopedSnapshot = new Map(scopedEntries);
-	const exact = scopedSnapshot.get(normalized);
+	const configuredSkills = getConfiguredSkills(watcher, allowedSkillNames);
+	const exact = configuredSkills.find((entry) => entry.id === normalized);
 	if (exact) {
-		const skill = exact.item as SkillConfig;
+		const { skill } = exact;
 		if (skill.disabled === true) {
 			return {
 				error: `Skill "${skill.name}" is configured but disabled.`,
 			};
 		}
 		return {
-			id: normalized,
+			id: exact.id,
 			skill,
 		};
 	}
@@ -284,30 +308,38 @@ function resolveSkillRecord(
 		? (normalized.split(":").at(-1) ?? normalized)
 		: normalized;
 
-	const suffixMatches = [...scopedSnapshot.entries()].filter(([id]) => {
+	const suffixMatches = configuredSkills.filter(({ id }) => {
 		if (id === bareName) {
 			return true;
 		}
 		return id.endsWith(`:${bareName}`);
 	});
 
+	const enabledSuffixMatches = suffixMatches.filter(
+		({ skill }) => skill.disabled !== true,
+	);
+
+	if (enabledSuffixMatches.length === 1) {
+		const { id, skill } = enabledSuffixMatches[0];
+		return { id, skill };
+	}
+
+	if (enabledSuffixMatches.length > 1) {
+		return {
+			error: `Skill "${requestedSkill}" is ambiguous. Use one of: ${enabledSuffixMatches.map(({ id }) => id).join(", ")}`,
+		};
+	}
+
 	if (suffixMatches.length === 1) {
-		const [id, record] = suffixMatches[0];
-		const skill = record.item as SkillConfig;
-		if (skill.disabled === true) {
-			return {
-				error: `Skill "${skill.name}" is configured but disabled.`,
-			};
-		}
+		const { skill } = suffixMatches[0];
 		return {
-			id,
-			skill,
+			error: `Skill "${skill.name}" is configured but disabled.`,
 		};
 	}
 
 	if (suffixMatches.length > 1) {
 		return {
-			error: `Skill "${requestedSkill}" is ambiguous. Use one of: ${suffixMatches.map(([id]) => id).join(", ")}`,
+			error: `Skill "${requestedSkill}" is ambiguous, and all matches are disabled: ${suffixMatches.map(({ id }) => id).join(", ")}`,
 		};
 	}
 
@@ -354,7 +386,10 @@ function createSkillsExecutor(
 		}
 	};
 	Object.defineProperty(executor, "configuredSkills", {
-		get: () => listConfiguredSkills(watcher, allowedSkillNames),
+		get: () =>
+			getConfiguredSkills(watcher, allowedSkillNames).map(
+				({ skill: _skill, ...metadata }) => metadata,
+			),
 		enumerable: true,
 		configurable: false,
 	});
@@ -386,27 +421,24 @@ function normalizeConfig(
 		| "enableTools"
 		| "enableSpawnAgent"
 		| "enableAgentTeams"
+		| "disableMcpSettingsTools"
 		| "yolo"
 		| "missionLogIntervalSteps"
 		| "missionLogIntervalMs"
 		| "sessionId"
 	>
 > {
-	const preset =
-		ToolPresets[
-			resolveToolPresetName({
-				mode: config.mode,
-				yolo: config.yolo,
-			})
-		];
+	const preset = ToolPresets[resolveToolPresetName({ mode: config.mode })];
 	return {
 		sessionId: config.sessionId || "",
-		mode: config.mode === "plan" ? "plan" : "act",
+		mode:
+			config.mode === "plan" ? "plan" : config.mode === "yolo" ? "yolo" : "act",
 		enableTools: config.enableTools !== false,
 		enableSpawnAgent:
 			config.enableSpawnAgent ?? preset.enableSpawnAgent ?? true,
 		enableAgentTeams:
 			config.enableAgentTeams ?? preset.enableAgentTeams ?? true,
+		disableMcpSettingsTools: config.disableMcpSettingsTools === true,
 		yolo: config.yolo === true,
 		missionLogIntervalSteps:
 			typeof config.missionLogIntervalSteps === "number" &&
@@ -422,7 +454,15 @@ function normalizeConfig(
 }
 
 export class DefaultRuntimeBuilder implements RuntimeBuilder {
-	private readonly teamRuntimeRegistry = new TeamRuntimeRegistry();
+	private readonly teamRuntimeEntries = new Map<
+		string,
+		{
+			runtime?: AgentTeamsRuntime;
+			delegatedAgentConfigProvider: ReturnType<
+				typeof createDelegatedAgentConfigProvider
+			>;
+		}
+	>();
 
 	async build(input: RuntimeBuilderInput): Promise<RuntimeEnvironment> {
 		const {
@@ -440,6 +480,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 		const normalized = normalizeConfig(config);
 		const tools: Tool[] = [];
 		const effectiveTeamName = config.teamName?.trim() || createTeamName();
+		const hasLocalSkills = hasSkillsFiles(config.cwd);
 		let teamToolsRegistered = false;
 		const watcherProvided = Boolean(sharedUserInstructionWatcher);
 		let userInstructionWatcher = sharedUserInstructionWatcher;
@@ -447,11 +488,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 		let skillsExecutor: SkillsExecutorWithMetadata | undefined;
 		let mcpShutdown: (() => Promise<void>) | undefined;
 
-		if (
-			!userInstructionWatcher &&
-			normalized.enableTools &&
-			hasSkillsFiles(config.cwd)
-		) {
+		if (!userInstructionWatcher && normalized.enableTools && hasLocalSkills) {
 			userInstructionWatcher = createUserInstructionConfigWatcher({
 				skills: { workspacePath: config.cwd },
 				rules: { workspacePath: config.cwd },
@@ -464,8 +501,8 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			normalized.enableTools &&
 			userInstructionWatcher &&
 			(watcherProvided ||
-				hasSkillsFiles(config.cwd) ||
-				listConfiguredSkills(userInstructionWatcher, config.skills).length > 0)
+				hasLocalSkills ||
+				getConfiguredSkills(userInstructionWatcher, config.skills).length > 0)
 		) {
 			skillsExecutor = createSkillsExecutor(
 				userInstructionWatcher,
@@ -480,16 +517,18 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 					config.cwd,
 					config.providerId,
 					normalized.mode,
-					normalized.yolo,
 					config.modelId,
 					config.toolRoutingRules,
+					config.toolPolicies,
 					skillsExecutor,
 					defaultToolExecutors,
 				),
 			);
-			const mcpRuntime = await loadConfiguredMcpTools(config.logger);
-			tools.push(...mcpRuntime.tools);
-			mcpShutdown = mcpRuntime.shutdown;
+			if (!normalized.disableMcpSettingsTools) {
+				const mcpRuntime = await loadConfiguredMcpTools(config.logger);
+				tools.push(...mcpRuntime.tools);
+				mcpShutdown = mcpRuntime.shutdown;
+			}
 		}
 
 		let teamRuntime: AgentTeamsRuntime | undefined;
@@ -526,21 +565,21 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			telemetry: input.telemetry ?? config.telemetry,
 			workspaceMetadata: config.workspaceMetadata,
 		});
-		this.teamRuntimeRegistry.getOrCreate(registryKey, () => ({
-			delegatedAgentConfigProvider,
-		}));
+		if (!this.teamRuntimeEntries.has(registryKey)) {
+			this.teamRuntimeEntries.set(registryKey, {
+				delegatedAgentConfigProvider,
+			});
+		}
 
 		const ensureTeamRuntime = (): AgentTeamsRuntime | undefined => {
 			if (!normalized.enableAgentTeams) {
 				return undefined;
 			}
 
-			const registryEntry = this.teamRuntimeRegistry.getOrCreate(
-				registryKey,
-				() => ({
-					delegatedAgentConfigProvider,
-				}),
-			);
+			const registryEntry = this.teamRuntimeEntries.get(registryKey) ?? {
+				delegatedAgentConfigProvider,
+			};
+			this.teamRuntimeEntries.set(registryKey, registryEntry);
 			teamRuntime = registryEntry.runtime;
 
 			if (!teamRuntime) {
@@ -592,7 +631,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 				const factory = input.teamToolsFactory ?? bootstrapAgentTeams;
 				const teamBootstrap = factory({
 					runtime: teamRuntime,
-					leadAgentId: "lead",
+					leadAgentId: config.sessionId || "lead",
 					restoredFromPersistence: Boolean(restoredTeamState),
 					restoredTeammates: restoredTeammateSpecs,
 					includeLeadSpawnTool: true,
@@ -607,9 +646,9 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 									config.cwd,
 									config.providerId,
 									normalized.mode,
-									normalized.yolo,
 									config.modelId,
 									config.toolRoutingRules,
+									config.toolPolicies,
 									skillsExecutor,
 									defaultToolExecutors,
 								)
@@ -643,7 +682,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 
 		const completionGuard = normalized.enableAgentTeams
 			? () => {
-					const rt = this.teamRuntimeRegistry.get(registryKey)?.runtime;
+					const rt = this.teamRuntimeEntries.get(registryKey)?.runtime;
 					if (!rt) return undefined;
 					const tasks = rt.listTasks();
 					const hasInProgress = tasks.some(
@@ -668,20 +707,20 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 						if (pending) parts.push(`Unfinished tasks: ${pending}`);
 						if (activeRunSummary)
 							parts.push(`Active runs: ${activeRunSummary}`);
-						return `[SYSTEM] You still have team obligations. ${parts.join(". ")}. Use team_run_task to delegate work, or team_task with action=complete to mark tasks done, or team_await_run / team_await_all_runs to wait for active runs. Do NOT stop until all tasks are completed.`;
+						return `[SYSTEM] You still have team obligations. ${parts.join(". ")}. Use team_run_task to delegate work, or team_task with action=complete to mark tasks done, or team_await_runs to wait for active runs. Do NOT stop until all tasks are completed.`;
 					}
 					return undefined;
 				}
 			: undefined;
 
 		return {
-			tools,
+			tools: filterToolsByPolicies(tools, config.toolPolicies),
 			logger: logger ?? config.logger,
 			telemetry: telemetry ?? config.telemetry,
 			teamRuntime,
 			teamRestoredFromPersistence: Boolean(restoredTeamState),
 			delegatedAgentConfigProvider:
-				this.teamRuntimeRegistry.get(registryKey)
+				this.teamRuntimeEntries.get(registryKey)
 					?.delegatedAgentConfigProvider ?? delegatedAgentConfigProvider,
 			completionGuard,
 			registerLeadAgent: (agent) => {
@@ -692,7 +731,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			},
 			shutdown: async (reason: string) => {
 				shutdownTeamRuntime(teamRuntime, reason);
-				this.teamRuntimeRegistry.delete(registryKey);
+				this.teamRuntimeEntries.delete(registryKey);
 				await mcpShutdown?.();
 				if (!watcherProvided) {
 					userInstructionWatcher?.stop();

package/src/runtime/runtime-host.ts

@@ -0,0 +1,178 @@
+import type * as LlmsProviders from "@clinebot/llms";
+import type {
+	AgentResult,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+} from "@clinebot/shared";
+import type { HookEventPayload } from "../hooks";
+import type { SessionManifest } from "../session/session-manifest";
+import type { SessionSource } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { SessionRecord } from "../types/sessions";
+
+export interface RuntimeSessionConfig {
+	sessionId?: string;
+	providerId: string;
+	modelId: string;
+	apiKey?: string;
+	cwd: string;
+	workspaceRoot?: string;
+	systemPrompt: string;
+	mode: CoreSessionConfig["mode"];
+	rules?: CoreSessionConfig["rules"];
+	maxIterations?: CoreSessionConfig["maxIterations"];
+	enableTools: boolean;
+	enableSpawnAgent: boolean;
+	enableAgentTeams: boolean;
+	disableMcpSettingsTools?: boolean;
+	teamName?: string;
+	missionLogIntervalSteps?: number;
+	missionLogIntervalMs?: number;
+}
+
+export type LocalRuntimeConfigOverrides = Omit<
+	CoreSessionConfig,
+	keyof RuntimeSessionConfig
+>;
+
+export interface LocalRuntimeStartOptions {
+	configOverrides?: Partial<LocalRuntimeConfigOverrides>;
+	userInstructionWatcher?: import("../extensions/config").UserInstructionConfigWatcher;
+	onTeamRestored?: () => void;
+}
+
+export interface StartSessionInput {
+	config: RuntimeSessionConfig;
+	source?: SessionSource;
+	prompt?: string;
+	interactive?: boolean;
+	sessionMetadata?: Record<string, unknown>;
+	initialMessages?: LlmsProviders.Message[];
+	userImages?: string[];
+	userFiles?: string[];
+	/**
+	 * Local runtime bootstrap options. These are intentionally isolated under a
+	 * local-only bag so the transport-facing host contract stays transport-safe.
+	 */
+	localRuntime?: LocalRuntimeStartOptions;
+	toolPolicies?: import("@clinebot/shared").AgentConfig["toolPolicies"];
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult>;
+}
+
+export function splitCoreSessionConfig(config: CoreSessionConfig): {
+	config: RuntimeSessionConfig;
+	localRuntime?: LocalRuntimeStartOptions;
+} {
+	const {
+		sessionId,
+		providerId,
+		modelId,
+		apiKey,
+		cwd,
+		workspaceRoot,
+		systemPrompt,
+		mode,
+		rules,
+		maxIterations,
+		enableTools,
+		enableSpawnAgent,
+		enableAgentTeams,
+		disableMcpSettingsTools,
+		teamName,
+		missionLogIntervalSteps,
+		missionLogIntervalMs,
+		...localConfigOverrides
+	} = config;
+
+	const localRuntime =
+		Object.keys(localConfigOverrides).length > 0
+			? {
+					configOverrides:
+						localConfigOverrides as Partial<LocalRuntimeConfigOverrides>,
+				}
+			: undefined;
+
+	return {
+		config: {
+			...(sessionId ? { sessionId } : {}),
+			providerId,
+			modelId,
+			...(apiKey ? { apiKey } : {}),
+			cwd,
+			...(workspaceRoot ? { workspaceRoot } : {}),
+			systemPrompt,
+			mode,
+			rules,
+			maxIterations,
+			enableTools,
+			enableSpawnAgent,
+			enableAgentTeams,
+			disableMcpSettingsTools,
+			teamName,
+			missionLogIntervalSteps,
+			missionLogIntervalMs,
+		},
+		...(localRuntime ? { localRuntime } : {}),
+	};
+}
+
+export interface StartSessionResult {
+	sessionId: string;
+	manifest: SessionManifest;
+	manifestPath: string;
+	messagesPath: string;
+	result?: AgentResult;
+}
+
+export interface SendSessionInput {
+	sessionId: string;
+	prompt: string;
+	userImages?: string[];
+	userFiles?: string[];
+	delivery?: "queue" | "steer";
+}
+
+export interface SessionAccumulatedUsage {
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	totalCost: number;
+}
+
+/**
+ * RuntimeHost is the transport/runtime boundary for core session execution.
+ * Callers must normalize broad local config into `RuntimeSessionConfig`
+ * plus optional `localRuntime` overrides before invoking a host.
+ */
+export interface RuntimeHost {
+	readonly runtimeAddress?: string;
+	start(input: StartSessionInput): Promise<StartSessionResult>;
+	send(input: SendSessionInput): Promise<AgentResult | undefined>;
+	getAccumulatedUsage(
+		sessionId: string,
+	): Promise<SessionAccumulatedUsage | undefined>;
+	abort(sessionId: string, reason?: unknown): Promise<void>;
+	stop(sessionId: string): Promise<void>;
+	dispose(reason?: string): Promise<void>;
+	get(sessionId: string): Promise<SessionRecord | undefined>;
+	list(limit?: number): Promise<SessionRecord[]>;
+	delete(sessionId: string): Promise<boolean>;
+	update(
+		sessionId: string,
+		updates: {
+			prompt?: string | null;
+			metadata?: Record<string, unknown> | null;
+			title?: string | null;
+		},
+	): Promise<{ updated: boolean }>;
+	readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+	handleHookEvent(payload: HookEventPayload): Promise<void>;
+	subscribe(listener: (event: CoreSessionEvent) => void): () => void;
+	updateSessionModel?(sessionId: string, modelId: string): Promise<void>;
+}
+
+export type RuntimeHostMode = "auto" | "rpc" | "local";

package/src/{session → runtime}/runtime-oauth-token-manager.ts

@@ -11,7 +11,7 @@ import {
 import { getValidOpenAICodexCredentials } from "../auth/codex";
 import { getValidOcaCredentials } from "../auth/oca";
 import { decodeJwtPayload } from "../auth/utils";
-import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+import { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
 
 const DEFAULT_CLINE_API_BASE_URL = "https://api.cline.bot";
 const WORKOS_TOKEN_PREFIX = "workos:";

package/src/runtime/runtime-parity.test.ts

@@ -3,7 +3,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { Tool } from "@clinebot/shared";
 import { describe, expect, it } from "vitest";
-import { createBuiltinTools } from "../tools";
+import { createBuiltinTools } from "../extensions/tools";
 import { DefaultRuntimeBuilder } from "./runtime-builder";
 
 type LegacyConfig = {

package/src/runtime/session-runtime.ts

@@ -9,12 +9,12 @@ import type {
 	Tool,
 } from "@clinebot/shared";
 import type { UserInstructionConfigWatcher } from "../extensions/config";
+import type { ToolExecutors } from "../extensions/tools";
 import type {
 	AgentTeamsRuntime,
 	DelegatedAgentConfigProvider,
 	TeamEvent,
-} from "../team";
-import type { ToolExecutors } from "../tools";
+} from "../extensions/tools/team";
 import type { CoreSessionConfig } from "../types/config";
 
 export interface BuiltRuntime {