@clinebot/core 0.0.33 → 0.0.35

package/src/{session/default-session-manager.ts → transports/local.ts}

@@ -1,4 +1,3 @@
-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";
@@ -19,68 +18,71 @@ import {
 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,
-	captureConversationTurnEvent,
-	captureModeSwitch,
-	captureSubagentExecution,
-	captureTaskCompleted,
-} from "../telemetry/core-events";
-import { resolveCoreDistinctId } from "../telemetry/distinct-id";
 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";
-import type { SessionRecord } from "../types/sessions";
-import type { FileSessionService } from "./file-session-service";
-import type { RpcCoreSessionService } from "./rpc-session-service";
+} from "../extensions/tools";
+import { createSpawnAgentTool, type TeamEvent } from "../extensions/tools/team";
+import type { HookEventPayload } from "../hooks";
+import { DefaultRuntimeBuilder } from "../runtime/runtime-builder";
+import type {
+	RuntimeHost,
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	StartSessionInput,
+	StartSessionResult,
+} from "../runtime/runtime-host";
 import {
 	OAuthReauthRequiredError,
 	type RuntimeOAuthResolution,
 	RuntimeOAuthTokenManager,
-} from "./runtime-oauth-token-manager";
+} from "../runtime/runtime-oauth-token-manager";
+import type { RuntimeBuilder } from "../runtime/session-runtime";
 import {
 	type AgentEventContext,
 	buildTelemetryAgentIdentity,
 	extractAgentEventMetadata,
 	handleAgentEvent,
-} from "./session-agent-events";
-import { nowIso } from "./session-artifacts";
+} from "../services/agent-events";
+import { resolveWorkspacePath } from "../services/config";
+import { prepareLocalRuntimeBootstrap } from "../services/local-runtime-bootstrap";
+import { nowIso } from "../services/session-artifacts";
 import {
-	buildEffectiveConfig,
-	buildResolvedProviderConfig,
-	resolveReasoningSettings,
-	resolveWorkspacePath,
-} from "./session-config-builder";
-import type {
-	SendSessionInput,
-	SessionAccumulatedUsage,
-	SessionManager,
-	StartSessionInput,
-	StartSessionResult,
-} from "./session-manager";
+	toSessionRecord,
+	withLatestAssistantTurnMetadata,
+} from "../services/session-data";
+import {
+	emitMentionTelemetry,
+	emitSessionCreationTelemetry,
+} from "../services/session-telemetry";
+import { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import {
+	captureAgentCreated,
+	captureAgentTeamCreated,
+	captureConversationTurnEvent,
+	captureModeSwitch,
+	captureSubagentExecution,
+	captureTaskCompleted,
+} from "../services/telemetry/core-events";
+import { resolveCoreDistinctId } from "../services/telemetry/distinct-id";
+import {
+	accumulateUsageTotals,
+	createInitialAccumulatedUsage,
+} from "../services/usage";
+import { enrichPromptWithMentions } from "../services/workspace";
+import type { FileSessionService } from "../session/file-session-service";
+import type { RpcCoreSessionService } from "../session/rpc-session-service";
 import {
 	type SessionManifest,
 	SessionManifestSchema,
-} from "./session-manifest";
+} from "../session/session-manifest";
 import type {
 	CoreSessionService,
 	RootSessionArtifacts,
 	SessionRow,
-} from "./session-service";
+} from "../session/session-service";
 import {
 	buildTeamRunContinuationPrompt,
 	dispatchTeamEventToBackend,
@@ -91,21 +93,18 @@ import {
 	shouldAutoContinueTeamRuns,
 	trackTeamRunState,
 	waitForTeamRunUpdates,
-} from "./session-team-coordination";
-import {
-	emitMentionTelemetry,
-	emitSessionCreationTelemetry,
-} from "./session-telemetry";
-import {
-	toSessionRecord,
-	withLatestAssistantTurnMetadata,
-} from "./utils/helpers";
-import type { ActiveSession, PreparedTurnInput } from "./utils/types";
+} from "../session/session-team-coordination";
+import { SessionSource, type SessionStatus } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { ActiveSession, PreparedTurnInput } from "../types/session";
+import type { SessionRecord } from "../types/sessions";
 import {
-	accumulateUsageTotals,
-	createInitialAccumulatedUsage,
-} from "./utils/usage";
-import { buildWorkspaceMetadata } from "./workspace-manifest";
+	cloneAccumulatedUsage,
+	RuntimeHostEventBus,
+	readPersistedMessagesFile,
+	replaySubagentHookEvent,
+} from "./runtime-host-support";
 
 type SessionBackend =
 	| CoreSessionService
@@ -130,12 +129,13 @@ async function loadUserFileContent(path: string): Promise<string> {
 	return content;
 }
 
-export interface DefaultSessionManagerOptions {
+export interface LocalRuntimeHostOptions {
 	distinctId?: string;
 	sessionService: SessionBackend;
 	runtimeBuilder?: RuntimeBuilder;
 	createAgent?: (config: AgentConfig) => Agent;
 	defaultToolExecutors?: Partial<ToolExecutors>;
+	teamToolsFactory?: import("../runtime/session-runtime").TeamToolsFactory;
 	toolPolicies?: AgentConfig["toolPolicies"];
 	providerSettingsManager?: ProviderSettingsManager;
 	oauthTokenManager?: RuntimeOAuthTokenManager;
@@ -145,11 +145,13 @@ export interface DefaultSessionManagerOptions {
 	) => Promise<ToolApprovalResult>;
 }
 
-export class DefaultSessionManager implements SessionManager {
+export class LocalRuntimeHost implements RuntimeHost {
+	public readonly runtimeAddress = undefined;
 	private readonly sessionService: SessionBackend;
 	private readonly runtimeBuilder: RuntimeBuilder;
 	private readonly createAgentInstance: (config: AgentConfig) => Agent;
 	private readonly defaultToolExecutors?: Partial<ToolExecutors>;
+	private readonly teamToolsFactory?: import("../runtime/session-runtime").TeamToolsFactory;
 	private readonly defaultToolPolicies?: AgentConfig["toolPolicies"];
 	private readonly providerSettingsManager: ProviderSettingsManager;
 	private readonly oauthTokenManager: RuntimeOAuthTokenManager;
@@ -157,7 +159,7 @@ export class DefaultSessionManager implements SessionManager {
 	private readonly defaultRequestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
-	private readonly listeners = new Set<(event: CoreSessionEvent) => void>();
+	private readonly events = new RuntimeHostEventBus();
 	private readonly sessions = new Map<string, ActiveSession>();
 	private readonly usageBySession = new Map<string, SessionAccumulatedUsage>();
 	private readonly subAgentStarts = new Map<
@@ -165,7 +167,7 @@ export class DefaultSessionManager implements SessionManager {
 		{ startedAt: number; rootSessionId: string }
 	>();
 
-	constructor(options: DefaultSessionManagerOptions) {
+	constructor(options: LocalRuntimeHostOptions) {
 		const homeDir = homedir();
 		if (homeDir) setHomeDirIfUnset(homeDir);
 		const distinctId = resolveCoreDistinctId(options.distinctId);
@@ -174,6 +176,7 @@ export class DefaultSessionManager implements SessionManager {
 		this.createAgentInstance =
 			options.createAgent ?? ((config) => new Agent(config));
 		this.defaultToolExecutors = options.defaultToolExecutors;
+		this.teamToolsFactory = options.teamToolsFactory;
 		this.defaultToolPolicies = options.toolPolicies;
 		this.providerSettingsManager =
 			options.providerSettingsManager ?? new ProviderSettingsManager();
@@ -223,8 +226,6 @@ export class DefaultSessionManager implements SessionManager {
 		}
 
 		const sessionDir = join(sessionsDir, sessionId);
-		const transcriptPath = join(sessionDir, `${sessionId}.log`);
-		const hookPath = join(sessionDir, `${sessionId}.hooks.jsonl`);
 		const messagesPath = join(sessionDir, `${sessionId}.messages.json`);
 		const manifestPath = join(sessionDir, `${sessionId}.json`);
 		const workspacePath = resolveWorkspacePath(input.config);
@@ -249,64 +250,36 @@ export class DefaultSessionManager implements SessionManager {
 			messages_path: messagesPath,
 		});
 
-		const { config: effectiveConfig, pluginSandboxShutdown } =
-			await buildEffectiveConfig(
-				startInput,
-				hookPath,
-				sessionId,
-				this.defaultTelemetry,
-				(e) => void this.handlePluginEvent(sessionId, e),
-			);
-		const workspaceMetadata = await buildWorkspaceMetadata(
-			startInput.config.cwd,
-		);
-		const providerConfig = buildResolvedProviderConfig(
-			effectiveConfig,
-			this.providerSettingsManager,
-			resolveReasoningSettings,
-		);
-		const configWithProvider: CoreSessionConfig = {
-			...effectiveConfig,
-			providerConfig,
-			workspaceMetadata,
-		};
-		configWithProvider.hooks = mergeAgentHooks([
-			effectiveConfig.hooks,
-			effectiveConfig.checkpoint?.enabled === true
-				? createCheckpointHooks({
-						cwd: configWithProvider.cwd,
-						sessionId,
-						logger: configWithProvider.logger,
-						createCheckpoint: effectiveConfig.checkpoint?.createCheckpoint,
-						readSessionMetadata: async () =>
-							(await this.get(sessionId))?.metadata as
-								| Record<string, unknown>
-								| undefined,
-						writeSessionMetadata: async (metadata) => {
-							await this.persistSessionMetadata(sessionId, () => metadata);
-						},
-					})
-				: undefined,
-		]);
-
-		const runtime = await this.runtimeBuilder.build({
-			config: configWithProvider,
-			hooks: configWithProvider.hooks,
-			extensions: effectiveConfig.extensions,
-			logger: configWithProvider.logger,
-			telemetry: configWithProvider.telemetry,
+		let bootstrap!: Awaited<ReturnType<typeof prepareLocalRuntimeBootstrap>>;
+		bootstrap = await prepareLocalRuntimeBootstrap({
+			input: startInput,
+			localRuntime: input.localRuntime,
+			sessionId,
+			providerSettingsManager: this.providerSettingsManager,
+			defaultTelemetry: this.defaultTelemetry,
+			defaultToolExecutors: this.defaultToolExecutors,
+			teamToolsFactory: this.teamToolsFactory,
+			defaultToolPolicies: this.defaultToolPolicies,
+			defaultRequestToolApproval: this.defaultRequestToolApproval,
+			onPluginEvent: (event) => void this.handlePluginEvent(sessionId, event),
 			onTeamEvent: (event: TeamEvent) => {
 				void this.handleTeamEvent(sessionId, event);
-				configWithProvider.onTeamEvent?.(event);
+				bootstrap.config.onTeamEvent?.(event);
+			},
+			createSpawnTool: () => this.createSpawnTool(bootstrap.config, sessionId),
+			readSessionMetadata: async () =>
+				(await this.get(sessionId))?.metadata as
+					| Record<string, unknown>
+					| undefined,
+			writeSessionMetadata: async (metadata) => {
+				await this.persistSessionMetadata(sessionId, () => metadata);
 			},
-			createSpawnTool: () =>
-				this.createSpawnTool(configWithProvider, sessionId),
-			onTeamRestored: input.onTeamRestored,
-			userInstructionWatcher: input.userInstructionWatcher,
-			defaultToolExecutors:
-				input.defaultToolExecutors ?? this.defaultToolExecutors,
-			teamToolsFactory: input.teamToolsFactory,
 		});
+		const runtime = await this.runtimeBuilder.build(
+			bootstrap.runtimeBuilderInput,
+		);
+		const configWithProvider = bootstrap.config;
+		const providerConfig = bootstrap.providerConfig;
 		if (runtime.teamRuntime && !configWithProvider.teamName?.trim()) {
 			configWithProvider.teamName = runtime.teamRuntime.getTeamName();
 		}
@@ -329,14 +302,13 @@ export class DefaultSessionManager implements SessionManager {
 			execution: configWithProvider.execution,
 			prepareTurn: createContextCompactionPrepareTurn(configWithProvider),
 			tools,
-			hooks: configWithProvider.hooks,
-			extensions: effectiveConfig.extensions,
+			hooks: bootstrap.hooks,
+			extensions: bootstrap.extensions,
 			hookErrorMode: configWithProvider.hookErrorMode,
-			initialMessages: input.initialMessages,
+			initialMessages: bootstrap.effectiveInput.initialMessages,
 			userFileContentLoader: loadUserFileContent,
-			toolPolicies: input.toolPolicies ?? this.defaultToolPolicies,
-			requestToolApproval:
-				input.requestToolApproval ?? this.defaultRequestToolApproval,
+			toolPolicies: bootstrap.toolPolicies,
+			requestToolApproval: bootstrap.requestToolApproval,
 			onConsecutiveMistakeLimitReached:
 				configWithProvider.onConsecutiveMistakeLimitReached,
 			completionGuard: runtime.completionGuard,
@@ -384,6 +356,7 @@ export class DefaultSessionManager implements SessionManager {
 		const active: ActiveSession = {
 			sessionId,
 			config: configWithProvider,
+			sessionMetadata: startInput.sessionMetadata,
 			source,
 			startedAt,
 			pendingPrompt: manifest.prompt,
@@ -398,7 +371,7 @@ export class DefaultSessionManager implements SessionManager {
 			teamRunWaiters: [],
 			pendingPrompts: [],
 			drainingPendingPrompts: false,
-			pluginSandboxShutdown,
+			pluginSandboxShutdown: bootstrap.pluginSandboxShutdown,
 		};
 		this.sessions.set(sessionId, active);
 		this.emitStatus(sessionId, "running");
@@ -424,8 +397,6 @@ export class DefaultSessionManager implements SessionManager {
 			sessionId,
 			manifest,
 			manifestPath,
-			transcriptPath,
-			hookPath,
 			messagesPath,
 			result,
 		};
@@ -474,8 +445,7 @@ export class DefaultSessionManager implements SessionManager {
 	async getAccumulatedUsage(
 		sessionId: string,
 	): Promise<SessionAccumulatedUsage | undefined> {
-		const usage = this.usageBySession.get(sessionId);
-		return usage ? { ...usage } : undefined;
+		return cloneAccumulatedUsage(this.usageBySession.get(sessionId));
 	}
 
 	async abort(sessionId: string, reason?: unknown): Promise<void> {
@@ -486,6 +456,10 @@ export class DefaultSessionManager implements SessionManager {
 			properties: { sessionId },
 		});
 		session.aborting = true;
+		if (session.pendingPrompts.length > 0) {
+			session.pendingPrompts.length = 0;
+			this.emitPendingPrompts(session);
+		}
 		(
 			session.agent as Agent & {
 				abort: (abortReason?: unknown) => void;
@@ -555,55 +529,49 @@ export class DefaultSessionManager implements SessionManager {
 		return result.deleted;
 	}
 
-	async readTranscript(sessionId: string, maxChars?: number): Promise<string> {
-		const row = await this.getRow(sessionId);
-		if (!row?.transcriptPath || !existsSync(row.transcriptPath)) return "";
-		const raw = readFileSync(row.transcriptPath, "utf8");
-		if (typeof maxChars === "number" && Number.isFinite(maxChars)) {
-			return raw.slice(-Math.max(0, Math.floor(maxChars)));
-		}
-		return raw;
+	async update(
+		sessionId: string,
+		updates: {
+			prompt?: string | null;
+			metadata?: Record<string, unknown> | null;
+			title?: string | null;
+		},
+	): Promise<{ updated: boolean }> {
+		const result = await this.invokeOptionalValue<{ updated?: boolean }>(
+			"updateSession",
+			{
+				sessionId,
+				prompt: updates.prompt,
+				metadata: updates.metadata,
+				title: updates.title,
+			},
+		);
+		return { updated: result?.updated === true };
 	}
 
 	async readMessages(sessionId: string): Promise<LlmsProviders.Message[]> {
 		const row = await this.getRow(sessionId);
-		const messagesPath = row?.messagesPath?.trim();
-		if (!messagesPath || !existsSync(messagesPath)) return [];
-		try {
-			const raw = readFileSync(messagesPath, "utf8").trim();
-			if (!raw) return [];
-			const parsed = JSON.parse(raw) as unknown;
-			if (Array.isArray(parsed)) return parsed as LlmsProviders.Message[];
-			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-				const messages = (parsed as { messages?: unknown }).messages;
-				if (Array.isArray(messages)) return messages as LlmsProviders.Message[];
-			}
-			return [];
-		} catch {
-			return [];
-		}
+		return readPersistedMessagesFile(row?.messagesPath);
 	}
 
-	async readHooks(sessionId: string, limit = 200): Promise<unknown[]> {
-		const row = await this.getRow(sessionId);
-		if (!row?.hookPath || !existsSync(row.hookPath)) return [];
-		const lines = readFileSync(row.hookPath, "utf8")
-			.split("\n")
-			.filter((line) => line.trim().length > 0);
-		return lines.slice(-Math.max(1, Math.floor(limit))).map((line) => {
-			try {
-				return JSON.parse(line) as unknown;
-			} catch {
-				return { raw: line };
-			}
+	async handleHookEvent(payload: HookEventPayload): Promise<void> {
+		await replaySubagentHookEvent(payload, {
+			queueSpawnRequest: (event: HookEventPayload) =>
+				this.invokeOptional("queueSpawnRequest", event),
+			upsertSubagentSessionFromHook: (event: HookEventPayload) =>
+				this.invokeOptionalValue<string | undefined>(
+					"upsertSubagentSessionFromHook",
+					event,
+				),
+			appendSubagentHookAudit: (sessionId: string, event: HookEventPayload) =>
+				this.invokeOptional("appendSubagentHookAudit", sessionId, event),
+			applySubagentStatus: (sessionId: string, event: HookEventPayload) =>
+				this.invokeOptional("applySubagentStatus", sessionId, event),
 		});
 	}
 
 	subscribe(listener: (event: CoreSessionEvent) => void): () => void {
-		this.listeners.add(listener);
-		return () => {
-			this.listeners.delete(listener);
-		};
+		return this.events.subscribe(listener);
 	}
 
 	async updateSessionModel(sessionId: string, modelId: string): Promise<void> {
@@ -796,6 +764,7 @@ export class DefaultSessionManager implements SessionManager {
 			enableSpawn: session.config.enableSpawnAgent,
 			enableTeams: session.config.enableAgentTeams,
 			prompt: session.pendingPrompt,
+			metadata: session.sessionMetadata,
 			startedAt: session.startedAt,
 		})) as RootSessionArtifacts;
 	}
@@ -992,7 +961,7 @@ export class DefaultSessionManager implements SessionManager {
 		},
 	): void {
 		const session = this.sessions.get(sessionId);
-		if (!session) {
+		if (!session || session.aborting) {
 			return;
 		}
 		const { prompt, delivery, userImages, userFiles } = entry;
@@ -1041,7 +1010,7 @@ export class DefaultSessionManager implements SessionManager {
 
 	private async drainPendingPrompts(sessionId: string): Promise<void> {
 		const session = this.sessions.get(sessionId);
-		if (!session || session.drainingPendingPrompts) {
+		if (!session || session.aborting || session.drainingPendingPrompts) {
 			return;
 		}
 		const canStartRun =
@@ -1181,7 +1150,6 @@ export class DefaultSessionManager implements SessionManager {
 						...ToolPresets[
 							resolveToolPresetName({
 								mode: config.mode,
-								yolo: config.yolo,
 							})
 						],
 						executors: this.defaultToolExecutors,
@@ -1391,9 +1359,7 @@ export class DefaultSessionManager implements SessionManager {
 			});
 		} catch (error) {
 			if (error instanceof OAuthReauthRequiredError) {
-				throw new Error(
-					`OAuth session for "${error.providerId}" requires re-authentication. Run "clite auth ${error.providerId}" and retry.`,
-				);
+				throw new Error(`${error.providerId} requires re-authentication.`);
 			}
 			throw error;
 		}
@@ -1466,7 +1432,7 @@ export class DefaultSessionManager implements SessionManager {
 	}
 
 	private emit(event: CoreSessionEvent): void {
-		for (const listener of this.listeners) listener(event);
+		this.events.emit(event);
 	}
 
 	private async listRows(limit: number): Promise<SessionRow[]> {

package/src/transports/rpc.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it, vi } from "vitest";
+
+const clientCloseMock = vi.hoisted(() => vi.fn());
+const streamEventsMock = vi.hoisted(() => vi.fn(() => () => {}));
+const startRuntimeSessionMock = vi.hoisted(() => vi.fn());
+const sendRuntimeSessionMock = vi.hoisted(() => vi.fn());
+const abortRuntimeSessionMock = vi.hoisted(() => vi.fn());
+const stopRuntimeSessionMock = vi.hoisted(() => vi.fn());
+const getSessionMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@clinebot/rpc", () => ({
+	RpcSessionClient: class {
+		close = clientCloseMock;
+		streamEvents = streamEventsMock;
+		startRuntimeSession = startRuntimeSessionMock;
+		sendRuntimeSession = sendRuntimeSessionMock;
+		abortRuntimeSession = abortRuntimeSessionMock;
+		stopRuntimeSession = stopRuntimeSessionMock;
+		getSession = getSessionMock;
+		respondToolApproval = vi.fn();
+	},
+}));
+
+describe("RpcRuntimeHost", () => {
+	it("emits running status when a remote session starts", async () => {
+		const { RpcRuntimeHost } = await import("./rpc");
+		startRuntimeSessionMock.mockResolvedValue({
+			sessionId: "session-1",
+			startResult: {
+				manifestPath: "/tmp/session-1.json",
+				messagesPath: "/tmp/session-1.messages.json",
+			},
+		});
+		const backend = {
+			address: "127.0.0.1:4317",
+			close: vi.fn(),
+			readSessionManifest: vi.fn().mockReturnValue({
+				session_id: "session-1",
+				status: "running",
+			}),
+		} as unknown as import("../session/rpc-session-service").RpcCoreSessionService;
+
+		const host = new RpcRuntimeHost(backend, undefined, undefined);
+		const listener = vi.fn();
+		const unsubscribe = host.subscribe(listener);
+
+		await host.start({
+			config: {
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				providerId: "mock-provider",
+				modelId: "mock-model",
+				mode: "act",
+				systemPrompt: "system",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+			interactive: true,
+		});
+
+		expect(listener).toHaveBeenCalledWith({
+			type: "status",
+			payload: { sessionId: "session-1", status: "running" },
+		});
+		unsubscribe();
+	});
+
+	it("does not close the shared backend on dispose", async () => {
+		const { RpcRuntimeHost } = await import("./rpc");
+		const backend = {
+			address: "127.0.0.1:4317",
+			close: vi.fn(),
+		} as unknown as import("../session/rpc-session-service").RpcCoreSessionService;
+
+		const host = new RpcRuntimeHost(backend, undefined, undefined);
+		await host.dispose();
+
+		expect(clientCloseMock).toHaveBeenCalledTimes(1);
+		expect(backend.close).not.toHaveBeenCalled();
+	});
+});