@oh-my-pi/pi-coding-agent 6.9.69 → 8.0.0

package/src/{core/python-executor.ts → ipy/executor.ts}

@@ -6,8 +6,8 @@ import {
 	type KernelExecuteResult,
 	type PreludeHelper,
 	PythonKernel,
-} from "./python-kernel";
-import { OutputSink } from "./streaming-output";
+} from "$c/ipy/kernel";
+import { OutputSink } from "$c/session/streaming-output";
 export type PythonKernelMode = "session" | "per-call";
 
 export interface PythonExecutorOptions {
@@ -27,6 +27,13 @@ export interface PythonExecutorOptions {
 	reset?: boolean;
 	/** Use shared gateway across pi instances (default: true) */
 	useSharedGateway?: boolean;
+	/** Session file path for accessing task outputs */
+	sessionFile?: string;
+	/** Artifacts directory for $ARTIFACTS env var and artifact storage */
+	artifactsDir?: string;
+	/** Artifact path/id for full output storage */
+	artifactPath?: string;
+	artifactId?: string;
 }
 
 export interface PythonKernelExecutor {
@@ -42,8 +49,16 @@ export interface PythonResult {
 	cancelled: boolean;
 	/** Whether the output was truncated */
 	truncated: boolean;
-	/** Path to temp file containing full output (if output exceeded truncation threshold) */
-	fullOutputPath?: string;
+	/** Artifact ID if full output was saved to artifact storage */
+	artifactId?: string;
+	/** Total number of lines in the output stream */
+	totalLines: number;
+	/** Total number of bytes in the output stream */
+	totalBytes: number;
+	/** Number of lines included in the output text */
+	outputLines: number;
+	/** Number of bytes included in the output text */
+	outputBytes: number;
 	/** Rich display outputs captured from display_data/execute_result */
 	displayOutputs: KernelDisplayOutput[];
 	/** Whether stdin was requested */
@@ -79,6 +94,7 @@ export async function warmPythonEnvironment(
 	cwd: string,
 	sessionId?: string,
 	useSharedGateway?: boolean,
+	sessionFile?: string,
 ): Promise<{ ok: boolean; reason?: string; docs: PreludeHelper[] }> {
 	try {
 		await ensureKernelAvailable(cwd);
@@ -97,6 +113,7 @@ export async function warmPythonEnvironment(
 			cwd,
 			async (kernel) => kernel.introspectPrelude(),
 			useSharedGateway,
+			sessionFile,
 		);
 		cachedPreludeDocs = docs;
 		return { ok: true, docs };
@@ -115,8 +132,21 @@ export function resetPreludeDocsCache(): void {
 	cachedPreludeDocs = null;
 }
 
-async function createKernelSession(sessionId: string, cwd: string, useSharedGateway?: boolean): Promise<KernelSession> {
-	const kernel = await PythonKernel.start({ cwd, useSharedGateway });
+async function createKernelSession(
+	sessionId: string,
+	cwd: string,
+	useSharedGateway?: boolean,
+	sessionFile?: string,
+	artifactsDir?: string,
+): Promise<KernelSession> {
+	const env: Record<string, string> | undefined =
+		sessionFile || artifactsDir
+			? {
+					...(sessionFile ? { OMP_SESSION_FILE: sessionFile } : {}),
+					...(artifactsDir ? { ARTIFACTS: artifactsDir } : {}),
+				}
+			: undefined;
+	const kernel = await PythonKernel.start({ cwd, useSharedGateway, env });
 	const session: KernelSession = {
 		id: sessionId,
 		kernel,
@@ -137,7 +167,13 @@ async function createKernelSession(sessionId: string, cwd: string, useSharedGate
 	return session;
 }
 
-async function restartKernelSession(session: KernelSession, cwd: string, useSharedGateway?: boolean): Promise<void> {
+async function restartKernelSession(
+	session: KernelSession,
+	cwd: string,
+	useSharedGateway?: boolean,
+	sessionFile?: string,
+	artifactsDir?: string,
+): Promise<void> {
 	session.restartCount += 1;
 	if (session.restartCount > 1) {
 		throw new Error("Python kernel restarted too many times in this session");
@@ -147,7 +183,14 @@ async function restartKernelSession(session: KernelSession, cwd: string, useShar
 	} catch (err) {
 		logger.warn("Failed to shutdown crashed kernel", { error: err instanceof Error ? err.message : String(err) });
 	}
-	const kernel = await PythonKernel.start({ cwd, useSharedGateway });
+	const env: Record<string, string> | undefined =
+		sessionFile || artifactsDir
+			? {
+					...(sessionFile ? { OMP_SESSION_FILE: sessionFile } : {}),
+					...(artifactsDir ? { ARTIFACTS: artifactsDir } : {}),
+				}
+			: undefined;
+	const kernel = await PythonKernel.start({ cwd, useSharedGateway, env });
 	session.kernel = kernel;
 	session.dead = false;
 	session.lastUsedAt = Date.now();
@@ -170,17 +213,19 @@ async function withKernelSession<T>(
 	cwd: string,
 	handler: (kernel: PythonKernel) => Promise<T>,
 	useSharedGateway?: boolean,
+	sessionFile?: string,
+	artifactsDir?: string,
 ): Promise<T> {
 	let session = kernelSessions.get(sessionId);
 	if (!session) {
-		session = await createKernelSession(sessionId, cwd, useSharedGateway);
+		session = await createKernelSession(sessionId, cwd, useSharedGateway, sessionFile, artifactsDir);
 		kernelSessions.set(sessionId, session);
 	}
 
 	const run = async (): Promise<T> => {
 		session!.lastUsedAt = Date.now();
 		if (session!.dead || !session!.kernel.isAlive()) {
-			await restartKernelSession(session!, cwd, useSharedGateway);
+			await restartKernelSession(session!, cwd, useSharedGateway, sessionFile, artifactsDir);
 		}
 		try {
 			const result = await handler(session!.kernel);
@@ -190,7 +235,7 @@ async function withKernelSession<T>(
 			if (!session!.dead && session!.kernel.isAlive()) {
 				throw err;
 			}
-			await restartKernelSession(session!, cwd, useSharedGateway);
+			await restartKernelSession(session!, cwd, useSharedGateway, sessionFile, artifactsDir);
 			const result = await handler(session!.kernel);
 			session!.restartCount = 0;
 			return result;
@@ -210,7 +255,11 @@ async function executeWithKernel(
 	code: string,
 	options: PythonExecutorOptions | undefined,
 ): Promise<PythonResult> {
-	const sink = new OutputSink({ onChunk: options?.onChunk });
+	const sink = new OutputSink({
+		onChunk: options?.onChunk,
+		artifactPath: options?.artifactPath,
+		artifactId: options?.artifactId,
+	});
 	const displayOutputs: KernelDisplayOutput[] = [];
 
 	try {
@@ -273,8 +322,18 @@ export async function executePython(code: string, options?: PythonExecutorOption
 
 	const kernelMode = options?.kernelMode ?? "session";
 	const useSharedGateway = options?.useSharedGateway;
+	const sessionFile = options?.sessionFile;
+	const artifactsDir = options?.artifactsDir;
+
 	if (kernelMode === "per-call") {
-		const kernel = await PythonKernel.start({ cwd, useSharedGateway });
+		const env: Record<string, string> | undefined =
+			sessionFile || artifactsDir
+				? {
+						...(sessionFile ? { OMP_SESSION_FILE: sessionFile } : {}),
+						...(artifactsDir ? { ARTIFACTS: artifactsDir } : {}),
+					}
+				: undefined;
+		const kernel = await PythonKernel.start({ cwd, useSharedGateway, env });
 		try {
 			return await executeWithKernel(kernel, code, options);
 		} finally {
@@ -294,5 +353,7 @@ export async function executePython(code: string, options?: PythonExecutorOption
 		cwd,
 		async (kernel) => executeWithKernel(kernel, code, options),
 		useSharedGateway,
+		sessionFile,
+		artifactsDir,
 	);
 }

package/src/{core/python-gateway-coordinator.ts → ipy/gateway-coordinator.ts}

@@ -3,7 +3,6 @@ import {
 	existsSync,
 	mkdirSync,
 	openSync,
-	readdirSync,
 	readFileSync,
 	renameSync,
 	statSync,
@@ -15,16 +14,14 @@ import { createServer } from "node:net";
 import { delimiter, join } from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { Subprocess } from "bun";
-import { getAgentDir } from "../config";
-import { getShellConfig, killProcessTree } from "../utils/shell";
-import { getOrCreateSnapshot } from "../utils/shell-snapshot";
+import { getAgentDir } from "$c/config";
+import { getShellConfig, killProcessTree } from "$c/utils/shell";
+import { getOrCreateSnapshot } from "$c/utils/shell-snapshot";
 
 const GATEWAY_DIR_NAME = "python-gateway";
 const GATEWAY_INFO_FILE = "gateway.json";
 const GATEWAY_LOCK_FILE = "gateway.lock";
-const GATEWAY_CLIENT_PREFIX = "client-";
 const GATEWAY_STARTUP_TIMEOUT_MS = 30000;
-const GATEWAY_IDLE_TIMEOUT_MS = 30000;
 const GATEWAY_LOCK_TIMEOUT_MS = GATEWAY_STARTUP_TIMEOUT_MS + 5000;
 const GATEWAY_LOCK_RETRY_MS = 50;
 const GATEWAY_LOCK_STALE_MS = GATEWAY_STARTUP_TIMEOUT_MS * 2;
@@ -140,8 +137,6 @@ export interface GatewayInfo {
 	url: string;
 	pid: number;
 	startedAt: number;
-	refCount: number;
-	cwd: string;
 	pythonPath?: string;
 	venvPath?: string | null;
 }
@@ -158,9 +153,7 @@ interface AcquireResult {
 
 let localGatewayProcess: Subprocess | null = null;
 let localGatewayUrl: string | null = null;
-let idleShutdownTimer: ReturnType<typeof setTimeout> | null = null;
 let isCoordinatorInitialized = false;
-let localClientFile: string | null = null;
 
 function filterEnv(env: Record<string, string | undefined>): Record<string, string | undefined> {
 	const filtered: Record<string, string | undefined> = {};
@@ -346,6 +339,7 @@ async function withGatewayLock<T>(handler: () => Promise<T>): Promise<T> {
 function readGatewayInfo(): GatewayInfo | null {
 	const infoPath = getGatewayInfoPath();
 	if (!existsSync(infoPath)) return null;
+
 	try {
 		const content = readFileSync(infoPath, "utf-8");
 		const parsed = JSON.parse(content) as Partial<GatewayInfo>;
@@ -353,16 +347,10 @@ function readGatewayInfo(): GatewayInfo | null {
 		if (typeof parsed.url !== "string" || typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number") {
 			return null;
 		}
-		if (typeof parsed.cwd !== "string") return null;
-		const clients = pruneStaleClientInfos(listClientInfos());
-		const totalRefCount = clients.reduce((sum, client) => sum + client.info.refCount, 0);
-		const recoveredRefCount = clients.length > 0 ? totalRefCount : 0;
 		return {
 			url: parsed.url,
 			pid: parsed.pid,
 			startedAt: parsed.startedAt,
-			refCount: recoveredRefCount,
-			cwd: parsed.cwd,
 			pythonPath: typeof parsed.pythonPath === "string" ? parsed.pythonPath : undefined,
 			venvPath: typeof parsed.venvPath === "string" || parsed.venvPath === null ? parsed.venvPath : undefined,
 		};
@@ -398,103 +386,6 @@ function isPidRunning(pid: number): boolean {
 	}
 }
 
-interface GatewayClientInfo {
-	pid: number;
-	refCount: number;
-	updatedAt?: number;
-}
-
-function getClientFilePath(pid: number): string {
-	return join(getGatewayDir(), `${GATEWAY_CLIENT_PREFIX}${pid}.json`);
-}
-
-function readClientInfo(path: string): GatewayClientInfo | null {
-	try {
-		const raw = readFileSync(path, "utf-8");
-		const parsed = JSON.parse(raw) as GatewayClientInfo;
-		if (typeof parsed.pid !== "number" || typeof parsed.refCount !== "number") return null;
-		return parsed;
-	} catch {
-		return null;
-	}
-}
-
-function listClientInfos(): Array<{ path: string; info: GatewayClientInfo }> {
-	const dir = getGatewayDir();
-	if (!existsSync(dir)) return [];
-	const entries = readdirSync(dir);
-	const results: Array<{ path: string; info: GatewayClientInfo }> = [];
-	for (const entry of entries) {
-		if (!entry.startsWith(GATEWAY_CLIENT_PREFIX)) continue;
-		const path = join(dir, entry);
-		const info = readClientInfo(path);
-		if (!info) continue;
-		results.push({ path, info });
-	}
-	return results;
-}
-
-function pruneStaleClientInfos(
-	clients: Array<{ path: string; info: GatewayClientInfo }>,
-): Array<{ path: string; info: GatewayClientInfo }> {
-	const active: Array<{ path: string; info: GatewayClientInfo }> = [];
-	for (const client of clients) {
-		if (!isPidRunning(client.info.pid)) {
-			try {
-				unlinkSync(client.path);
-			} catch {
-				// Ignore cleanup errors
-			}
-			continue;
-		}
-		active.push(client);
-	}
-	return active;
-}
-
-function updateLocalClientRefCount(delta: number): { totalRefCount: number; localRefCount: number } {
-	ensureGatewayDir();
-	const clients = pruneStaleClientInfos(listClientInfos());
-	const localPath = localClientFile ?? getClientFilePath(process.pid);
-	const localEntry = clients.find((client) => client.info.pid === process.pid);
-	const baseCount = localEntry?.info.refCount ?? 0;
-	const nextCount = Math.max(0, baseCount + delta);
-	const otherClients = clients.filter((client) => client.info.pid !== process.pid);
-
-	if (nextCount <= 0) {
-		if (localEntry) {
-			try {
-				unlinkSync(localEntry.path);
-			} catch {
-				// Ignore cleanup errors
-			}
-		}
-		if (localClientFile === localPath) {
-			localClientFile = null;
-		}
-	} else {
-		const payload: GatewayClientInfo = { pid: process.pid, refCount: nextCount, updatedAt: Date.now() };
-		writeFileSync(localPath, JSON.stringify(payload, null, 2));
-		localClientFile = localPath;
-	}
-
-	const totalRefCount =
-		otherClients.reduce((sum, client) => sum + client.info.refCount, 0) + (nextCount > 0 ? nextCount : 0);
-	return { totalRefCount, localRefCount: nextCount };
-}
-
-function clearClientFiles(): void {
-	const clients = listClientInfos();
-	for (const client of clients) {
-		try {
-			unlinkSync(client.path);
-		} catch {
-			// Ignore cleanup errors
-		}
-	}
-	localClientFile = null;
-}
-
 async function isGatewayHealthy(url: string): Promise<boolean> {
 	try {
 		const controller = new AbortController();
@@ -533,11 +424,6 @@ async function startGatewayProcess(
 		OMP_SHELL_SNAPSHOT: snapshotPath ?? undefined,
 	};
 
-	const pythonPathParts = [cwd, kernelEnv.PYTHONPATH].filter(Boolean).join(delimiter);
-	if (pythonPathParts) {
-		kernelEnv.PYTHONPATH = pythonPathParts;
-	}
-
 	const gatewayPort = await allocatePort();
 	const gatewayUrl = `http://127.0.0.1:${gatewayPort}`;
 
@@ -570,7 +456,6 @@ async function startGatewayProcess(
 			exited = true;
 		});
 
-	// Wait for gateway to become healthy
 	const startTime = Date.now();
 	while (Date.now() - startTime < GATEWAY_STARTUP_TIMEOUT_MS) {
 		if (exited) {
@@ -593,70 +478,15 @@ async function startGatewayProcess(
 	throw new Error("Gateway startup timeout");
 }
 
-function scheduleIdleShutdown(): void {
-	if (idleShutdownTimer) {
-		clearTimeout(idleShutdownTimer);
-	}
-	idleShutdownTimer = setTimeout(async () => {
-		try {
-			await withGatewayLock(async () => {
-				const info = readGatewayInfo();
-				if (!info) {
-					clearClientFiles();
-					return;
-				}
-				const clients = pruneStaleClientInfos(listClientInfos());
-				const totalRefCount = clients.reduce((sum, client) => sum + client.info.refCount, 0);
-				if (totalRefCount > 0) {
-					if (info.refCount !== totalRefCount) {
-						writeGatewayInfo({ ...info, refCount: totalRefCount });
-					}
-					return;
-				}
-				logger.debug("Shutting down idle shared gateway", { pid: info.pid });
-				if (localGatewayProcess) {
-					await shutdownLocalGateway();
-				} else if (isPidRunning(info.pid)) {
-					try {
-						await killProcessTree(info.pid);
-					} catch (err) {
-						logger.warn("Failed to kill idle shared gateway", {
-							error: err instanceof Error ? err.message : String(err),
-							pid: info.pid,
-						});
-					}
-				}
-				clearGatewayInfo();
-				clearClientFiles();
-			});
-		} catch (err) {
-			logger.warn("Failed to shutdown idle shared gateway", {
-				error: err instanceof Error ? err.message : String(err),
-			});
-		} finally {
-			idleShutdownTimer = null;
-		}
-	}, GATEWAY_IDLE_TIMEOUT_MS);
-}
-
-function cancelIdleShutdown(): void {
-	if (idleShutdownTimer) {
-		clearTimeout(idleShutdownTimer);
-		idleShutdownTimer = null;
-	}
-}
-
-async function shutdownLocalGateway(): Promise<void> {
-	if (localGatewayProcess) {
-		try {
-			await killProcessTree(localGatewayProcess.pid);
-		} catch (err) {
-			logger.warn("Failed to kill shared gateway process", {
-				error: err instanceof Error ? err.message : String(err),
-			});
-		}
-		localGatewayProcess = null;
-		localGatewayUrl = null;
+async function killGateway(pid: number, context: string): Promise<void> {
+	try {
+		await killProcessTree(pid);
+	} catch (err) {
+		logger.warn("Failed to kill shared gateway process", {
+			error: err instanceof Error ? err.message : String(err),
+			pid,
+			context,
+		});
 	}
 }
 
@@ -668,67 +498,32 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 	try {
 		return await withGatewayLock(async () => {
 			const existingInfo = readGatewayInfo();
-			if (existingInfo && (await isGatewayAlive(existingInfo))) {
-				const { env } = await getShellConfig();
-				const filteredEnv = filterEnv(env);
-				const runtime = await resolvePythonRuntime(cwd, filteredEnv);
-				const existingVenv = existingInfo.venvPath ?? null;
-				const runtimeVenv = runtime.venvPath ?? null;
-				if (
-					existingInfo.cwd !== cwd ||
-					!existingInfo.pythonPath ||
-					existingInfo.pythonPath !== runtime.pythonPath ||
-					existingVenv !== runtimeVenv
-				) {
-					logger.debug("Shared gateway metadata mismatch", {
-						existingCwd: existingInfo.cwd,
-						requestedCwd: cwd,
-						existingPython: existingInfo.pythonPath,
-						runtimePython: runtime.pythonPath,
-						existingVenv,
-						runtimeVenv,
-					});
-					return null;
+			if (existingInfo) {
+				if (await isGatewayAlive(existingInfo)) {
+					localGatewayUrl = existingInfo.url;
+					isCoordinatorInitialized = true;
+					logger.debug("Reusing global Python gateway", { url: existingInfo.url });
+					return { url: existingInfo.url, isShared: true };
 				}
-				const { totalRefCount } = updateLocalClientRefCount(1);
-				const updatedInfo = { ...existingInfo, refCount: totalRefCount };
-				writeGatewayInfo(updatedInfo);
-				cancelIdleShutdown();
-				logger.debug("Reusing shared gateway", { url: existingInfo.url, refCount: updatedInfo.refCount });
-				isCoordinatorInitialized = true;
-				return { url: existingInfo.url, isShared: true };
-			}
 
-			if (existingInfo) {
 				logger.debug("Cleaning up stale gateway info", { pid: existingInfo.pid });
 				if (isPidRunning(existingInfo.pid)) {
-					try {
-						await killProcessTree(existingInfo.pid);
-					} catch (err) {
-						logger.warn("Failed to kill stale shared gateway process", {
-							error: err instanceof Error ? err.message : String(err),
-							pid: existingInfo.pid,
-						});
-					}
+					await killGateway(existingInfo.pid, "stale");
 				}
 				clearGatewayInfo();
-				clearClientFiles();
 			}
 
 			const { url, pid, pythonPath, venvPath } = await startGatewayProcess(cwd);
-			const { totalRefCount } = updateLocalClientRefCount(1);
 			const info: GatewayInfo = {
 				url,
 				pid,
 				startedAt: Date.now(),
-				refCount: totalRefCount,
-				cwd,
 				pythonPath,
 				venvPath,
 			};
 			writeGatewayInfo(info);
 			isCoordinatorInitialized = true;
-			logger.debug("Started shared gateway", { url, pid });
+			logger.debug("Started global Python gateway", { url, pid });
 			return { url, isShared: true };
 		});
 	} catch (err) {
@@ -741,48 +536,24 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 
 export async function releaseSharedGateway(): Promise<void> {
 	if (!isCoordinatorInitialized) return;
-
-	try {
-		await withGatewayLock(async () => {
-			const { totalRefCount } = updateLocalClientRefCount(-1);
-			const info = readGatewayInfo();
-			if (!info) return;
-
-			const newRefCount = Math.max(0, totalRefCount);
-			if (newRefCount === 0) {
-				const updatedInfo = { ...info, refCount: 0 };
-				writeGatewayInfo(updatedInfo);
-				scheduleIdleShutdown();
-				logger.debug("Scheduled idle shutdown for shared gateway", { pid: info.pid });
-				return;
-			}
-			const updatedInfo = { ...info, refCount: newRefCount };
-			writeGatewayInfo(updatedInfo);
-			logger.debug("Released shared gateway reference", { url: info.url, refCount: newRefCount });
-		});
-	} catch (err) {
-		logger.warn("Failed to release shared gateway", {
-			error: err instanceof Error ? err.message : String(err),
-		});
-	}
 }
 
 export function getSharedGatewayUrl(): string | null {
-	return localGatewayUrl;
+	if (localGatewayUrl) return localGatewayUrl;
+	return readGatewayInfo()?.url ?? null;
 }
 
 export function isSharedGatewayActive(): boolean {
-	return localGatewayProcess !== null && localGatewayUrl !== null;
+	return getGatewayStatus().active;
 }
 
 export interface GatewayStatus {
 	active: boolean;
-	shared: boolean;
 	url: string | null;
 	pid: number | null;
-	refCount: number;
-	cwd: string | null;
 	uptime: number | null;
+	pythonPath: string | null;
+	venvPath: string | null;
 }
 
 export function getGatewayStatus(): GatewayStatus {
@@ -790,45 +561,44 @@ export function getGatewayStatus(): GatewayStatus {
 	if (!info) {
 		return {
 			active: false,
-			shared: false,
 			url: null,
 			pid: null,
-			refCount: 0,
-			cwd: null,
 			uptime: null,
+			pythonPath: null,
+			venvPath: null,
 		};
 	}
 	const active = isPidRunning(info.pid);
-	const clients = pruneStaleClientInfos(listClientInfos());
-	const clientRefCount = clients.reduce((sum, client) => sum + client.info.refCount, 0);
-	const refCount = clientRefCount > 0 ? clientRefCount : info.refCount;
 	return {
 		active,
-		shared: active && refCount > 1,
 		url: info.url,
 		pid: info.pid,
-		refCount,
-		cwd: info.cwd,
-		uptime: Date.now() - info.startedAt,
+		uptime: active ? Date.now() - info.startedAt : null,
+		pythonPath: info.pythonPath ?? null,
+		venvPath: info.venvPath ?? null,
 	};
 }
 
 export async function shutdownSharedGateway(): Promise<void> {
-	cancelIdleShutdown();
 	try {
 		await withGatewayLock(async () => {
 			const info = readGatewayInfo();
-			if (info) {
-				clearGatewayInfo();
+			if (!info) return;
+			if (isPidRunning(info.pid)) {
+				await killGateway(info.pid, "shutdown");
 			}
-			clearClientFiles();
+			clearGatewayInfo();
 		});
 	} catch (err) {
 		logger.warn("Failed to shutdown shared gateway", {
 			error: err instanceof Error ? err.message : String(err),
 		});
 	} finally {
-		await shutdownLocalGateway();
+		if (localGatewayProcess) {
+			await killGateway(localGatewayProcess.pid, "shutdown-local");
+		}
+		localGatewayProcess = null;
+		localGatewayUrl = null;
 		isCoordinatorInitialized = false;
 	}
 }