@oh-my-pi/pi-coding-agent 16.4.4 → 16.4.6

package/src/modes/controllers/selector-controller.ts

@@ -3,7 +3,7 @@ import { PASTE_CODE_LOGIN_PROVIDERS } from "@oh-my-pi/pi-ai";
 import { getOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
 import type { OAuthProvider } from "@oh-my-pi/pi-ai/oauth/types";
 import type { Component, OverlayHandle } from "@oh-my-pi/pi-tui";
-import { Input, Loader, Spacer, setTuiTight, Text } from "@oh-my-pi/pi-tui";
+import { Loader, Spacer, setTuiTight, Text } from "@oh-my-pi/pi-tui";
 import { getAgentDbPath, getAgentDir, getProjectDir, normalizePathForComparison } from "@oh-my-pi/pi-utils";
 import {
 	type AdvisorConfigScope,
@@ -65,8 +65,9 @@ import { AssistantMessageComponent } from "../components/assistant-message";
 import { CopySelectorComponent } from "../components/copy-selector";
 import { ExtensionDashboard } from "../components/extensions";
 import { HistorySearchComponent } from "../components/history-search";
+import { LoginDialogComponent } from "../components/login-dialog";
 import { LogoutAccountSelectorComponent } from "../components/logout-account-selector";
-import { ModelSelectorComponent } from "../components/model-selector";
+import { ModelHubComponent, type ModelHubMode } from "../components/model-hub";
 import { OAuthSelectorComponent } from "../components/oauth-selector";
 import { PluginSelectorComponent } from "../components/plugin-selector";
 import { ResetUsageSelectorComponent } from "../components/reset-usage-selector";
@@ -585,50 +586,45 @@ export class SelectorController {
 	}
 
 	showModelSelector(options?: { temporaryOnly?: boolean }): void {
+		this.#showModelHub({ mode: options?.temporaryOnly ? "pick" : "roles" });
+	}
+
+	/**
+	 * Fullscreen model hub on the alternate screen (the /settings idiom): the
+	 * overlay enables mouse tracking for its lifetime and the transcript stays
+	 * untouched underneath. `initialProviderId` preselects a provider's sidebar
+	 * entry — used when reopening the hub after a /login round-trip.
+	 */
+	#showModelHub(hubOptions: { mode: ModelHubMode; initialProviderId?: string }): void {
 		const currentContextTokens = this.ctx.session.getContextUsage()?.tokens ?? 0;
-		this.showSelector(done => {
-			const selector = new ModelSelectorComponent(
-				this.ctx.ui,
-				this.ctx.session.model,
-				this.ctx.settings,
-				this.ctx.session.modelRegistry,
-				this.ctx.session.scopedModels,
-				async (model, role, thinkingLevel, selector, action) => {
+		let overlayHandle: OverlayHandle | undefined;
+		let hub: ModelHubComponent | undefined;
+		let closed = false;
+		const done = () => {
+			// Re-entrant guard: cancel paths (Esc, pick, login forward) may race;
+			// the overlay must hide exactly once.
+			if (closed) return;
+			closed = true;
+			hub?.dispose();
+			overlayHandle?.hide();
+			this.focusActiveEditorArea();
+			this.ctx.ui.requestRender();
+		};
+		hub = new ModelHubComponent(
+			this.ctx.ui,
+			this.ctx.settings,
+			this.ctx.session.modelRegistry,
+			this.ctx.session.scopedModels,
+			{
+				onAssign: async (model, role, thinkingLevel, selector) => {
 					// `auto` is session-global: never baked into a per-role model value
 					// (it can't round-trip through `model:<level>`). Apply it to the session
 					// separately and persist via `defaultThinkingLevel`.
 					const isAuto = thinkingLevel === AUTO_THINKING;
-					const concreteThinking = isAuto ? undefined : thinkingLevel;
+					const concreteThinking = isAuto || thinkingLevel === undefined ? undefined : thinkingLevel;
 					const selectorValue = selector ?? `${model.provider}/${model.id}`;
 					try {
-						if (action === "retryFallback" && role !== null) {
-							const fallbackSelector = formatModelSelectorValue(selectorValue, concreteThinking);
-							const fallbackChains = this.ctx.settings.get("retry.fallbackChains");
-							const chain = Array.isArray(fallbackChains[role]) ? fallbackChains[role] : [];
-							this.ctx.settings.set("retry.fallbackChains", {
-								...fallbackChains,
-								[role]: [fallbackSelector, ...chain.filter(existing => existing !== fallbackSelector)],
-							});
-							const roleInfo = getRoleInfo(role, settings);
-							const roleLabel = roleInfo?.name ?? role;
-							this.ctx.showStatus(`${roleLabel} fallback model: ${fallbackSelector}`);
-							return;
-						}
-						if (role === null) {
-							// Temporary: update agent state but don't persist the model to settings
-							await this.ctx.session.setModelTemporary(model);
-							if (isAuto) {
-								this.ctx.session.setThinkingLevel(AUTO_THINKING, true);
-							}
-							this.ctx.statusLine.invalidate();
-							this.ctx.updateEditorBorderColor();
-							const roleSelectorHint = this.ctx.keybindings.getKeys("app.model.select")[0] ?? "Alt+M";
-							this.ctx.showStatus(
-								`Session-only model: ${selector ?? model.id}. Use ${roleSelectorHint} or /model for roles.`,
-							);
-							done();
-							this.ctx.ui.requestRender();
-						} else if (role === "default") {
+						if (role === "default") {
 							const { switched } = await this.ctx.session.setModel(model, role, {
 								selector,
 								thinkingLevel: concreteThinking,
@@ -649,33 +645,101 @@ export class SelectorController {
 								this.ctx.updateEditorBorderColor();
 							}
 							this.ctx.showStatus(`Default model: ${selector ?? model.id}`);
-							// Don't call done() - selector stays open for role assignment
 						} else {
-							// Other roles (smol, slow): just update settings, not current model
-							this.ctx.settings.setModelRole(
-								role,
-								formatModelSelectorValue(selector ?? `${model.provider}/${model.id}`, concreteThinking),
-							);
+							// Other roles (smol, slow, custom): update settings, not the current model.
+							this.ctx.settings.setModelRole(role, formatModelSelectorValue(selectorValue, concreteThinking));
 							if (isAuto) {
 								this.ctx.session.setThinkingLevel(AUTO_THINKING, true);
 							}
 							const roleInfo = getRoleInfo(role, settings);
-							const roleLabel = roleInfo?.name ?? role;
-							this.ctx.showStatus(`${roleLabel} model: ${selector ?? model.id}`);
-							// Don't call done() - selector stays open
+							this.ctx.showStatus(`${roleInfo?.name ?? role} model: ${selector ?? model.id}`);
 						}
 					} catch (error) {
 						this.ctx.showError(error instanceof Error ? error.message : String(error));
 					}
 				},
-				() => {
+				onUnassign: role => {
+					try {
+						this.ctx.settings.setModelRole(role, undefined);
+						const roleInfo = getRoleInfo(role, settings);
+						this.ctx.showStatus(`${roleInfo?.name ?? role} role cleared — auto-selection applies`);
+					} catch (error) {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					}
+				},
+				onFallbackChainChange: (role, chain) => {
+					try {
+						const chains = { ...this.ctx.settings.get("retry.fallbackChains") };
+						if (chain.length === 0) {
+							delete chains[role];
+						} else {
+							chains[role] = chain;
+						}
+						this.ctx.settings.set("retry.fallbackChains", chains);
+						const roleInfo = getRoleInfo(role, settings);
+						this.ctx.showStatus(
+							chain.length > 0
+								? `${roleInfo?.name ?? role} fallbacks: ${chain.join(" → ")}`
+								: `${roleInfo?.name ?? role} fallbacks cleared`,
+						);
+					} catch (error) {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					}
+				},
+				onPick: async (model, selector) => {
+					try {
+						// Session-only: update agent state but don't persist the model to settings.
+						await this.ctx.session.setModelTemporary(model);
+						this.ctx.statusLine.invalidate();
+						this.ctx.updateEditorBorderColor();
+						const roleSelectorHint = this.ctx.keybindings.getKeys("app.model.select")[0] ?? "Alt+M";
+						this.ctx.showStatus(
+							`Session-only model: ${selector ?? model.id}. Use ${roleSelectorHint} or /model for roles.`,
+						);
+						done();
+					} catch (error) {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					}
+				},
+				onLoginRequest: providerId => {
 					done();
-					this.ctx.ui.requestRender();
+					void this.#loginThenReopenModelHub(providerId);
 				},
-				{ ...options, currentContextTokens },
-			);
-			return { component: selector, focus: selector };
+				onCycleOrderChange: order => {
+					try {
+						this.ctx.settings.set("cycleOrder", order);
+						this.ctx.showStatus(
+							order.length > 0 ? `Quick-switch cycle: ${order.join(" → ")}` : "Quick-switch cycle cleared",
+						);
+					} catch (error) {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					}
+				},
+				onCancel: () => done(),
+			},
+			{
+				mode: hubOptions.mode,
+				currentContextTokens,
+				initialProviderId: hubOptions.initialProviderId,
+			},
+		);
+		overlayHandle = this.ctx.ui.showOverlay(hub, {
+			anchor: "bottom-center",
+			width: "100%",
+			maxHeight: "100%",
+			margin: 0,
+			fullscreen: true,
 		});
+		this.ctx.ui.setFocus(hub);
+		this.ctx.ui.requestRender();
+	}
+
+	/** /login round-trip for a locked provider; reopen the hub on that provider only after a successful login. */
+	async #loginThenReopenModelHub(providerId: string): Promise<void> {
+		const succeeded = await this.#handleOAuthLogin(providerId);
+		if (succeeded) {
+			this.#showModelHub({ mode: "roles", initialProviderId: providerId });
+		}
 	}
 
 	async showPluginSelector(mode: "install" | "uninstall" = "install"): Promise<void> {
@@ -1122,60 +1186,51 @@ export class SelectorController {
 		await this.showSessionSelector();
 	}
 
-	async #handleOAuthLogin(providerId: string): Promise<void> {
+	/**
+	 * Run the OAuth login flow for `providerId` inside a cancellable
+	 * {@link LoginDialogComponent} that replaces the editor slot. Esc aborts:
+	 * the dialog's abort signal reaches the provider flow, any pending prompt
+	 * rejects, and the editor is restored immediately. Returns true when
+	 * credentials were stored.
+	 */
+	async #handleOAuthLogin(providerId: string): Promise<boolean> {
 		this.ctx.showStatus(`Logging in to ${providerId}…`);
 		const manualInput = this.ctx.oauthManualInput;
 		const useManualInput = PASTE_CODE_LOGIN_PROVIDERS.has(providerId);
+		let restored = false;
+		const restoreEditor = () => {
+			if (restored) return;
+			restored = true;
+			this.ctx.editorContainer.clear();
+			this.ctx.editorContainer.addChild(this.ctx.editor);
+			this.ctx.ui.setFocus(this.ctx.editor);
+			this.ctx.ui.requestRender();
+		};
+		const dialog = new LoginDialogComponent(this.ctx.ui, providerId, (_success, message) => {
+			// Fires on Esc: unblock the editor immediately; the aborted flow's
+			// rejection settles the awaited login below.
+			restoreEditor();
+			if (message) this.ctx.showStatus(message);
+		});
+		this.ctx.editorContainer.clear();
+		this.ctx.editorContainer.addChild(dialog);
+		this.ctx.ui.setFocus(dialog);
+		this.ctx.ui.requestRender();
 		try {
 			await this.ctx.session.modelRegistry.authStorage.login(providerId as OAuthProvider, {
+				signal: dialog.signal,
 				onAuth: (info: { url: string; launchUrl?: string; instructions?: string }) => {
-					const block = new TranscriptBlock();
-					// Full URL first: works from any machine, including SSH boxes
-					// where the OMP-hosted `launchUrl` would resolve against the
-					// user's local browser and fail.
-					block.addChild(new Text(theme.fg("dim", info.url), 1, 0));
-					const hyperlink = `\x1b]8;;${info.url}\x07Click here to login\x1b]8;;\x07`;
-					block.addChild(new Text(theme.fg("accent", hyperlink), 1, 0));
-					if (info.launchUrl && info.launchUrl !== info.url) {
-						block.addChild(
-							new Text(theme.fg("dim", `Local shortcut (this machine only): ${info.launchUrl}`), 1, 0),
-						);
-					}
-					if (info.instructions) {
-						block.addChild(new Spacer(1));
-						block.addChild(new Text(theme.fg("warning", info.instructions), 1, 0));
-					}
+					// The dialog renders the full URL (SSH-safe copy target) and
+					// opens the browser best-effort.
+					dialog.showAuth(info.url, info.instructions, info.launchUrl);
 					if (useManualInput) {
-						block.addChild(new Spacer(1));
-						block.addChild(new Text(theme.fg("dim", MANUAL_LOGIN_TIP), 1, 0));
-					}
-					this.ctx.present(block);
-					this.ctx.openInBrowser(info.url);
-				},
-				onPrompt: async (prompt: { message: string; placeholder?: string }) => {
-					const promptBlock = new TranscriptBlock();
-					promptBlock.addChild(new Text(theme.fg("warning", prompt.message), 1, 0));
-					if (prompt.placeholder) {
-						promptBlock.addChild(new Text(theme.fg("dim", prompt.placeholder), 1, 0));
+						dialog.showProgress(MANUAL_LOGIN_TIP);
 					}
-					this.ctx.present(promptBlock);
-					const { promise, resolve } = Promise.withResolvers<string>();
-					const codeInput = new Input();
-					codeInput.onSubmit = () => {
-						const code = codeInput.getValue();
-						this.ctx.editorContainer.clear();
-						this.ctx.editorContainer.addChild(this.ctx.editor);
-						this.ctx.ui.setFocus(this.ctx.editor);
-						resolve(code);
-					};
-					this.ctx.editorContainer.clear();
-					this.ctx.editorContainer.addChild(codeInput);
-					this.ctx.ui.setFocus(codeInput);
-					this.ctx.ui.requestRender();
-					return promise;
 				},
+				onPrompt: (prompt: { message: string; placeholder?: string }) =>
+					dialog.showPrompt(prompt.message, prompt.placeholder),
 				onProgress: (message: string) => {
-					this.ctx.present(new Text(theme.fg("dim", message), 1, 0));
+					dialog.showProgress(message);
 				},
 				onManualCodeInput: useManualInput ? () => manualInput.waitForInput(providerId) : undefined,
 			});
@@ -1186,12 +1241,20 @@ export class SelectorController {
 			);
 			block.addChild(new Text(theme.fg("dim", `Credentials saved to ${getAgentDbPath()}`), 1, 0));
 			this.ctx.present(block);
+			return true;
 		} catch (error: unknown) {
+			if (dialog.signal.aborted) {
+				// User-cancelled: the dialog already restored the editor and
+				// surfaced "Login cancelled".
+				return false;
+			}
 			this.ctx.showError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
+			return false;
 		} finally {
 			if (useManualInput) {
 				manualInput.clear(`Manual OAuth input cleared for ${providerId}`);
 			}
+			restoreEditor();
 		}
 	}
 

package/src/modes/controllers/tan-command-controller.ts

@@ -160,7 +160,7 @@ export class TanCommandController {
 						}
 					}
 				},
-				{ ownerId },
+				{ ownerId, agentId: cloneId },
 			);
 		} catch (error) {
 			if (cloneFile) await removeCloneSession(cloneFile);

package/src/modes/controllers/todo-command-controller.ts

@@ -133,8 +133,7 @@ export class TodoCommandController {
 
 	/**
 	 * True latest todo state for the user-facing /todo verbs. Reads from session
-	 * entries so that completed/abandoned tasks remain visible after resume
-	 * (where `session.getTodoPhases()` would have stripped them).
+	 * entries or falls back to the active session state.
 	 */
 	#currentPhases(): TodoPhase[] {
 		const fromEntries = getLatestTodoPhasesFromEntries(this.ctx.sessionManager.getBranch());

package/src/modes/interactive-mode.ts

@@ -566,6 +566,9 @@ export class InteractiveMode implements InteractiveModeContext {
 	get focusedAgentId(): string | undefined {
 		return this.#focusController.focusedAgentId;
 	}
+	get sessionName(): string | undefined {
+		return this.session.sessionName;
+	}
 	focusAgentSession(id: string): Promise<void> {
 		return this.#focusController.focusAgent(id);
 	}
@@ -4284,6 +4287,11 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#inputController.handleImagePaste();
 	}
 
+	/** Queue slash-command input behind the active turn. */
+	handleQueueCommand(message: string): Promise<void> {
+		return this.#inputController.handleQueueCommand(message);
+	}
+
 	handleBtwCommand(question: string): Promise<void> {
 		return this.#btwController.start(question);
 	}

package/src/modes/queue-input.ts

@@ -0,0 +1,132 @@
+const QUEUE_PREFIXES: readonly string[] = ["->", "=>"];
+/** Prefix matcher shared by queue-list parsing and editor highlighting. */
+export const QUEUE_LIST_MARKER_RE = /^([\t ]*)(\d+|[A-Za-z]+)([.)])(?=[\t ]|$)/;
+const CANONICAL_ROMAN_RE = /^(?=[MDCLXVI])M{0,3}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})$/i;
+
+interface EnumeratedItem {
+	line: number;
+	indent: string;
+	marker: string;
+	punctuation: string;
+	content: string;
+}
+
+interface EnumeratedList {
+	source: string;
+	lines: string[];
+	items: EnumeratedItem[];
+}
+
+/** Extract the message body from the `->` / `=>` yield-queue shorthand. */
+export function parseQueueShorthand(text: string): string | undefined {
+	const prefix = QUEUE_PREFIXES.find(candidate => text.startsWith(candidate));
+	return prefix ? text.slice(prefix.length).trim() : undefined;
+}
+
+function parseEnumeratedItem(line: string, lineIndex: number): EnumeratedItem | undefined {
+	const match = QUEUE_LIST_MARKER_RE.exec(line);
+	if (!match) return undefined;
+	const [matched, indent, marker, punctuation] = match;
+	if (indent === undefined || marker === undefined || punctuation === undefined) return undefined;
+	return { line: lineIndex, indent, marker, punctuation, content: line.slice(matched.length).trimStart() };
+}
+
+function decodeDecimal(marker: string): number | undefined {
+	if (!/^\d+$/.test(marker)) return undefined;
+	const value = Number(marker);
+	return Number.isSafeInteger(value) ? value : undefined;
+}
+
+function decodeRoman(marker: string): number | undefined {
+	if (!CANONICAL_ROMAN_RE.test(marker)) return undefined;
+	const values: Readonly<Record<string, number>> = {
+		I: 1,
+		V: 5,
+		X: 10,
+		L: 50,
+		C: 100,
+		D: 500,
+		M: 1000,
+	};
+	const upper = marker.toUpperCase();
+	let value = 0;
+	for (let index = 0; index < upper.length; index++) {
+		const current = values[upper[index] ?? ""];
+		if (current === undefined) return undefined;
+		const next = values[upper[index + 1] ?? ""] ?? 0;
+		value += current < next ? -current : current;
+	}
+	return value;
+}
+
+function decodeAlpha(marker: string): number | undefined {
+	if (!/^[A-Za-z]+$/.test(marker)) return undefined;
+	let value = 0;
+	for (const char of marker.toUpperCase()) {
+		value = value * 26 + char.charCodeAt(0) - 64;
+		if (!Number.isSafeInteger(value)) return undefined;
+	}
+	return value;
+}
+
+function isSequential(markers: readonly string[], decode: (marker: string) => number | undefined): boolean {
+	let previous = decode(markers[0] ?? "");
+	if (previous === undefined) return false;
+	for (let index = 1; index < markers.length; index++) {
+		const current = decode(markers[index] ?? "");
+		if (current === undefined || current !== previous + 1) return false;
+		previous = current;
+	}
+	return true;
+}
+
+function isEnumeratedSequence(items: readonly EnumeratedItem[]): boolean {
+	const markers = items.map(item => item.marker);
+	if (markers.every(marker => /^\d+$/.test(marker))) return isSequential(markers, decodeDecimal);
+	if (
+		!markers.every(marker => marker === marker.toUpperCase()) &&
+		!markers.every(marker => marker === marker.toLowerCase())
+	) {
+		return false;
+	}
+	return isSequential(markers, decodeRoman) || isSequential(markers, decodeAlpha);
+}
+
+function parseEnumeratedList(text: string): EnumeratedList | undefined {
+	const source = text.trim();
+	if (!source) return undefined;
+	const lines = source.split(/\r?\n/);
+	const first = parseEnumeratedItem(lines[0] ?? "", 0);
+	if (!first) return undefined;
+
+	const items = [first];
+	for (let lineIndex = 1; lineIndex < lines.length; lineIndex++) {
+		const item = parseEnumeratedItem(lines[lineIndex] ?? "", lineIndex);
+		if (item?.indent === first.indent) items.push(item);
+	}
+	if (items.length < 2 || items.some(item => item.punctuation !== first.punctuation) || !isEnumeratedSequence(items)) {
+		return undefined;
+	}
+	return { source, lines, items };
+}
+
+/** Whether text currently forms a sequential queue list, including an unfinished trailing item. */
+export function isQueuedMessageList(text: string): boolean {
+	return parseEnumeratedList(text) !== undefined;
+}
+
+/** Split a sequential numeric, Roman-numeral, or alphabetic list into queue entries. */
+export function splitQueuedMessages(text: string): string[] {
+	const list = parseEnumeratedList(text);
+	if (!list) {
+		const source = text.trim();
+		return source ? [source] : [];
+	}
+
+	const messages = list.items.map((item, index) => {
+		const nextLine = list.items[index + 1]?.line ?? list.lines.length;
+		return [item.content, ...list.lines.slice(item.line + 1, nextLine)].join("\n").trim();
+	});
+	while (messages.at(-1) === "") messages.pop();
+	return messages.length > 0 && messages.every(Boolean) ? messages : [list.source];
+}

package/src/modes/shared.ts

@@ -18,7 +18,7 @@ export function sanitizeStatusText(text: string): string {
 // Tab Bar Theme
 // ═══════════════════════════════════════════════════════════════════════════
 
-/** Shared tab bar theme used by model-selector and settings-selector. */
+/** Shared tab bar theme used by fullscreen overlays (settings, agent hub). */
 export function getTabBarTheme(): TabBarTheme {
 	return {
 		label: (text: string) => theme.bold(theme.fg("accent", text)),

package/src/modes/theme/theme.ts

@@ -249,7 +249,7 @@ const UNICODE_SYMBOLS: SymbolMap = {
 	"status.disabled": "⦸",
 	"status.enabled": "●",
 	"status.running": "⟳",
-	"status.shadowed": "◌",
+	"status.shadowed": "○",
 	"status.aborted": "⏹",
 	"status.done": "•",
 	// Navigation
@@ -464,8 +464,8 @@ const NERD_SYMBOLS: SymbolMap = {
 	"status.enabled": "\uf111",
 	// pick:  | alt:   
 	"status.running": "\uf110",
-	// pick: ◐ | alt: ◑ ◒ ◓ ◔
-	"status.shadowed": "◐",
+	// pick:  (nf-fa-circle_o, pairs with status.enabled's nf-fa-circle) | alt: ◐ ◑
+	"status.shadowed": "\uf10c",
 	// pick:  | alt:  
 	"status.aborted": "\uf04d",
 	// pick: • | alt: ● ·

package/src/modes/types.ts

@@ -113,6 +113,8 @@ export interface InteractiveModeContext {
 	// Session access
 	session: AgentSession;
 	sessionManager: SessionManager;
+	/** The current session display name / title. */
+	readonly sessionName: string | undefined;
 	/** Session the transcript/editor/status are attached to: the focused agent's, else `session`. */
 	readonly viewSession: AgentSession;
 	/** Id of the focused agent, undefined when the main session is attached. */
@@ -375,6 +377,8 @@ export interface InteractiveModeContext {
 	handleCtrlZ(): void;
 	handleDequeue(): void;
 	handleImagePaste(): Promise<boolean>;
+	/** Queue a message for delivery only after the active agent turn would stop. */
+	handleQueueCommand(message: string): Promise<void>;
 	handleBtwCommand(question: string): Promise<void>;
 	handleTanCommand(work: string): Promise<void>;
 	hasActiveBtw(): boolean;