Phase 10: Telegram bot commands + Phase 11: Snackbar notifications

Phase 10 — Telegram Bot Commands:
- Add commands_config JSON field to TelegramBot model (enabled cmds,
  default count, response mode, rate limits, locale)
- Create command handler with 14 commands: /status, /albums, /events,
  /summary, /latest, /memory, /random, /search, /find, /person,
  /place, /favorites, /people, /help
- Add search_smart, search_metadata, search_by_person, get_random,
  download_asset, get_asset_thumbnail to ImmichClient
- Auto-register commands with Telegram setMyCommands API (EN+RU)
- Rate limiting per chat per command category
- Media mode: download thumbnails and send as photos to Telegram
- Webhook handler routes /commands before falling through to AI chat
- Frontend: expandable Commands section per bot with checkboxes,
  count/mode/locale settings, rate limit inputs, sync button

Phase 11 — Snackbar Notifications:
- Create snackbar store (snackbar.svelte.ts) with $state rune
- Create Snackbar component with fly/fade transitions, typed colors
- Mount globally in +layout.svelte
- Replace all alert() calls with typed snackbar notifications
- Add success snacks to all CRUD operations across all pages
- 4 types: success (3s), error (5s), info (3s), warning (4s)
- Max 3 visible, auto-dismiss, manual dismiss via X button

Both: Add ~30 i18n keys (EN+RU) for commands UI and snack messages.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

frontend/src/lib/components/Snackbar.svelte

@@ -0,0 +1,88 @@
+<script lang="ts">
+	import { fly, fade } from 'svelte/transition';
+	import { getSnacks, removeSnack, type Snack } from '$lib/stores/snackbar.svelte';
+	import MdiIcon from '$lib/components/MdiIcon.svelte';
+
+	const snacks = $derived(getSnacks());
+
+	let expandedIds = $state<Set<number>>(new Set());
+
+	function toggleDetail(id: number) {
+		const next = new Set(expandedIds);
+		if (next.has(id)) next.delete(id);
+		else next.add(id);
+		expandedIds = next;
+	}
+
+	const iconMap: Record<string, string> = {
+		success: 'mdiCheckCircle',
+		error: 'mdiAlertCircle',
+		info: 'mdiInformation',
+		warning: 'mdiAlert',
+	};
+
+	const borderColorMap: Record<string, string> = {
+		success: '#22c55e',
+		error: '#ef4444',
+		info: '#3b82f6',
+		warning: '#f59e0b',
+	};
+
+	const iconColorMap: Record<string, string> = {
+		success: '#22c55e',
+		error: '#ef4444',
+		info: '#3b82f6',
+		warning: '#f59e0b',
+	};
+</script>
+
+{#if snacks.length > 0}
+	<div
+		style="position: fixed; left: 50%; transform: translateX(-50%); z-index: 9999; display: flex; flex-direction: column; gap: 0.5rem; width: 90%; max-width: 28rem; pointer-events: none;"
+		class="snackbar-container"
+	>
+		{#each snacks as snack (snack.id)}
+			<div
+				in:fly={{ y: 50, duration: 250 }}
+				out:fade={{ duration: 150 }}
+				style="pointer-events: auto; border-left: 4px solid {borderColorMap[snack.type]}; background: rgba(0, 0, 0, 0.85); backdrop-filter: blur(8px); border-radius: 0.5rem; padding: 0.75rem 1rem; display: flex; align-items: flex-start; gap: 0.5rem; color: #f1f5f9; box-shadow: 0 4px 12px rgba(0,0,0,0.3);"
+			>
+				<span style="color: {iconColorMap[snack.type]}; flex-shrink: 0; margin-top: 1px;">
+					<MdiIcon name={iconMap[snack.type]} size={18} />
+				</span>
+				<div style="flex: 1; min-width: 0;">
+					<p style="font-size: 0.875rem; line-height: 1.25rem; margin: 0;">{snack.message}</p>
+					{#if snack.detail}
+						<button
+							onclick={() => toggleDetail(snack.id)}
+							style="font-size: 0.75rem; color: #94a3b8; background: none; border: none; padding: 0; margin-top: 0.25rem; cursor: pointer; text-decoration: underline;"
+						>
+							{expandedIds.has(snack.id) ? 'Hide details' : 'Show details'}
+						</button>
+						{#if expandedIds.has(snack.id)}
+							<pre style="font-size: 0.75rem; color: #94a3b8; margin: 0.25rem 0 0; white-space: pre-wrap; word-break: break-word;">{snack.detail}</pre>
+						{/if}
+					{/if}
+				</div>
+				<button
+					onclick={() => removeSnack(snack.id)}
+					style="flex-shrink: 0; background: none; border: none; color: #94a3b8; cursor: pointer; padding: 0; line-height: 1; font-size: 1.125rem;"
+					aria-label="Dismiss"
+				>
+					<MdiIcon name="mdiClose" size={16} />
+				</button>
+			</div>
+		{/each}
+	</div>
+{/if}
+
+<style>
+	.snackbar-container {
+		bottom: 5rem;
+	}
+	@media (min-width: 768px) {
+		.snackbar-container {
+			bottom: 1.5rem;
+		}
+	}
+</style>

frontend/src/lib/i18n/en.json

@@ -182,7 +182,19 @@
 		"group": "Group",
 		"supergroup": "Supergroup",
 		"channel": "Channel",
-		"confirmDelete": "Delete this bot?"
+		"confirmDelete": "Delete this bot?",
+		"commands": "Commands",
+		"enabledCommands": "Enabled Commands",
+		"defaultCount": "Default result count",
+		"responseMode": "Response mode",
+		"modeMedia": "Media (send photos)",
+		"modeText": "Text (send links)",
+		"botLocale": "Bot language",
+		"rateLimits": "Rate Limits",
+		"rateSearch": "Search cooldown",
+		"rateFind": "Find cooldown",
+		"rateDefault": "Default cooldown",
+		"syncCommands": "Sync to Telegram"
 	},
 	"trackingConfig": {
 		"title": "Tracking Configs",
@@ -344,7 +356,36 @@
 		"maxAssetSize": "Skip assets larger than this size in MB. Telegram limits files to 50 MB.",
 		"trackingConfig": "Controls which events trigger notifications and how assets are filtered.",
 		"templateConfig": "Controls the message format. Uses default templates if not set.",
-		"scanInterval": "How often to poll the Immich server for changes, in seconds. Lower = faster detection but more API calls."
+		"scanInterval": "How often to poll the Immich server for changes, in seconds. Lower = faster detection but more API calls.",
+		"defaultCount": "How many results to return when the user doesn't specify a count (1-20).",
+		"responseMode": "Media: send actual photos. Text: send filenames/links only. Media mode uses more bandwidth.",
+		"botLocale": "Language for command descriptions in Telegram's menu and bot response messages.",
+		"rateLimits": "Cooldown in seconds between uses of each command category per chat. 0 = no limit."
+	},
+	"snack": {
+		"serverSaved": "Server saved",
+		"serverDeleted": "Server deleted",
+		"trackerCreated": "Tracker created",
+		"trackerUpdated": "Tracker updated",
+		"trackerDeleted": "Tracker deleted",
+		"trackerPaused": "Tracker paused",
+		"trackerResumed": "Tracker resumed",
+		"targetSaved": "Target saved",
+		"targetDeleted": "Target deleted",
+		"targetTestSent": "Test notification sent",
+		"templateSaved": "Template config saved",
+		"templateDeleted": "Template config deleted",
+		"trackingConfigSaved": "Tracking config saved",
+		"trackingConfigDeleted": "Tracking config deleted",
+		"botRegistered": "Bot registered",
+		"botDeleted": "Bot deleted",
+		"userCreated": "User created",
+		"userDeleted": "User deleted",
+		"passwordChanged": "Password changed",
+		"copied": "Copied to clipboard",
+		"genericError": "Something went wrong",
+		"commandsSaved": "Commands config saved",
+		"commandsSynced": "Commands synced to Telegram"
 	},
 	"common": {
 		"loading": "Loading...",

frontend/src/lib/i18n/ru.json

@@ -182,7 +182,19 @@
 		"group": "Группа",
 		"supergroup": "Супергруппа",
 		"channel": "Канал",
-		"confirmDelete": "Удалить этого бота?"
+		"confirmDelete": "Удалить этого бота?",
+		"commands": "Команды",
+		"enabledCommands": "Включённые команды",
+		"defaultCount": "Кол-во результатов",
+		"responseMode": "Режим ответа",
+		"modeMedia": "Медиа (отправка фото)",
+		"modeText": "Текст (ссылки)",
+		"botLocale": "Язык бота",
+		"rateLimits": "Ограничения частоты",
+		"rateSearch": "Кулдаун поиска",
+		"rateFind": "Кулдаун поиска файлов",
+		"rateDefault": "Кулдаун по умолчанию",
+		"syncCommands": "Синхронизировать с Telegram"
 	},
 	"trackingConfig": {
 		"title": "Конфигурации отслеживания",
@@ -344,7 +356,36 @@
 		"maxAssetSize": "Пропускать файлы больше указанного размера в МБ. Лимит Telegram — 50 МБ.",
 		"trackingConfig": "Управляет тем, какие события вызывают уведомления и как фильтруются ассеты.",
 		"templateConfig": "Управляет форматом сообщений. Используются шаблоны по умолчанию, если не задано.",
-		"scanInterval": "Как часто опрашивать сервер Immich на предмет изменений (в секундах). Меньше = быстрее обнаружение, но больше запросов к API."
+		"scanInterval": "Как часто опрашивать сервер Immich на предмет изменений (в секундах). Меньше = быстрее обнаружение, но больше запросов к API.",
+		"defaultCount": "Сколько результатов возвращать, если пользователь не указал количество (1-20).",
+		"responseMode": "Медиа: отправка фото. Текст: только имена файлов/ссылки. Медиа-режим использует больше трафика.",
+		"botLocale": "Язык описаний команд в меню Telegram и ответов бота.",
+		"rateLimits": "Кулдаун в секундах между использованиями команд в каждом чате. 0 = без ограничений."
+	},
+	"snack": {
+		"serverSaved": "Сервер сохранён",
+		"serverDeleted": "Сервер удалён",
+		"trackerCreated": "Трекер создан",
+		"trackerUpdated": "Трекер обновлён",
+		"trackerDeleted": "Трекер удалён",
+		"trackerPaused": "Трекер приостановлен",
+		"trackerResumed": "Трекер возобновлён",
+		"targetSaved": "Цель сохранена",
+		"targetDeleted": "Цель удалена",
+		"targetTestSent": "Тестовое уведомление отправлено",
+		"templateSaved": "Шаблон сохранён",
+		"templateDeleted": "Шаблон удалён",
+		"trackingConfigSaved": "Конфигурация сохранена",
+		"trackingConfigDeleted": "Конфигурация удалена",
+		"botRegistered": "Бот зарегистрирован",
+		"botDeleted": "Бот удалён",
+		"userCreated": "Пользователь создан",
+		"userDeleted": "Пользователь удалён",
+		"passwordChanged": "Пароль изменён",
+		"copied": "Скопировано",
+		"genericError": "Что-то пошло не так",
+		"commandsSaved": "Конфигурация команд сохранена",
+		"commandsSynced": "Команды синхронизированы с Telegram"
 	},
 	"common": {
 		"loading": "Загрузка...",

frontend/src/lib/stores/snackbar.svelte.ts

@@ -0,0 +1,78 @@
+export type SnackType = 'success' | 'error' | 'info' | 'warning';
+
+export interface Snack {
+	id: number;
+	type: SnackType;
+	message: string;
+	detail?: string;
+	timeout: number;
+}
+
+const DEFAULT_TIMEOUTS: Record<SnackType, number> = {
+	success: 3000,
+	info: 3000,
+	warning: 4000,
+	error: 5000,
+};
+
+const MAX_VISIBLE = 3;
+
+let nextId = 1;
+let snacks = $state<Snack[]>([]);
+const timers = new Map<number, ReturnType<typeof setTimeout>>();
+
+export function getSnacks(): Snack[] {
+	return snacks;
+}
+
+export function addSnack(
+	type: SnackType,
+	message: string,
+	options?: { detail?: string; timeout?: number },
+): void {
+	const id = nextId++;
+	const timeout = options?.timeout ?? DEFAULT_TIMEOUTS[type];
+	const snack: Snack = { id, type, message, detail: options?.detail, timeout };
+
+	snacks = [snack, ...snacks];
+
+	// Enforce max visible
+	while (snacks.length > MAX_VISIBLE) {
+		const oldest = snacks[snacks.length - 1];
+		removeSnack(oldest.id);
+	}
+
+	// Auto-dismiss
+	if (timeout > 0) {
+		timers.set(
+			id,
+			setTimeout(() => removeSnack(id), timeout),
+		);
+	}
+}
+
+export function removeSnack(id: number): void {
+	const timer = timers.get(id);
+	if (timer) {
+		clearTimeout(timer);
+		timers.delete(id);
+	}
+	snacks = snacks.filter((s) => s.id !== id);
+}
+
+// Convenience functions
+export function snackSuccess(message: string): void {
+	addSnack('success', message);
+}
+
+export function snackError(message: string, detail?: string): void {
+	addSnack('error', message, { detail });
+}
+
+export function snackInfo(message: string): void {
+	addSnack('info', message);
+}
+
+export function snackWarning(message: string): void {
+	addSnack('warning', message);
+}

frontend/src/routes/+layout.svelte

@@ -10,6 +10,8 @@
 	import { getTheme, initTheme, setTheme, type Theme } from '$lib/theme.svelte';
 	import Modal from '$lib/components/Modal.svelte';
 	import MdiIcon from '$lib/components/MdiIcon.svelte';
+	import Snackbar from '$lib/components/Snackbar.svelte';
+	import { snackSuccess, snackError } from '$lib/stores/snackbar.svelte';
 
 	let { children } = $props();
 	const auth = getAuth();
@@ -28,8 +30,9 @@
 			pwdMsg = t('common.passwordChanged');
 			pwdSuccess = true;
 			pwdCurrent = ''; pwdNew = '';
+			snackSuccess(t('snack.passwordChanged'));
 			setTimeout(() => { showPasswordForm = false; pwdMsg = ''; pwdSuccess = false; }, 2000);
-		} catch (err: any) { pwdMsg = err.message; pwdSuccess = false; }
+		} catch (err: any) { pwdMsg = err.message; pwdSuccess = false; snackError(err.message); }
 	}
 
 	let collapsed = $state(false);
@@ -232,3 +235,5 @@
 		</button>
 	</form>
 </Modal>
+
+<Snackbar />

frontend/src/routes/servers/+page.svelte

@@ -10,6 +10,7 @@
 	import MdiIcon from '$lib/components/MdiIcon.svelte';
 	import ConfirmModal from '$lib/components/ConfirmModal.svelte';
 	import IconButton from '$lib/components/IconButton.svelte';
+	import { snackSuccess, snackError } from '$lib/stores/snackbar.svelte';
 
 	let servers = $state<any[]>([]);
 	let showForm = $state(false);
@@ -30,6 +31,7 @@
 			loadError = '';
 		} catch (err: any) {
 			loadError = err.message || t('servers.loadError');
+			snackError(loadError);
 		} finally { loaded = true; }
 		// Ping all servers in background
 		for (const s of servers) {
@@ -58,7 +60,8 @@
 				await api('/servers', { method: 'POST', body: JSON.stringify(form) });
 			}
 			showForm = false; editing = null; await load();
-		} catch (err: any) { error = err.message; }
+			snackSuccess(t('snack.serverSaved'));
+		} catch (err: any) { error = err.message; snackError(err.message); }
 		submitting = false;
 	}
 
@@ -70,7 +73,7 @@
 		if (!confirmDelete) return;
 		const id = confirmDelete.id;
 		confirmDelete = null;
-		try { await api(`/servers/${id}`, { method: 'DELETE' }); await load(); } catch (err: any) { error = err.message; }
+		try { await api(`/servers/${id}`, { method: 'DELETE' }); await load(); snackSuccess(t('snack.serverDeleted')); } catch (err: any) { error = err.message; snackError(err.message); }
 	}
 </script>
 

frontend/src/routes/targets/+page.svelte

@@ -11,6 +11,7 @@
 	import ConfirmModal from '$lib/components/ConfirmModal.svelte';
 	import Hint from '$lib/components/Hint.svelte';
 	import IconButton from '$lib/components/IconButton.svelte';
+	import { snackSuccess, snackError } from '$lib/stores/snackbar.svelte';
 
 	let targets = $state<any[]>([]);
 	let trackingConfigs = $state<any[]>([]);
@@ -40,7 +41,7 @@
 				api('/targets'), api('/tracking-configs'), api('/template-configs'), api('/telegram-bots')
 			]);
 			loadError = '';
-		} catch (err: any) { loadError = err.message || t('common.loadError'); } finally { loaded = true; }
+		} catch (err: any) { loadError = err.message || t('common.loadError'); snackError(loadError); } finally { loaded = true; }
 	}
 
 	async function loadBotChats() {
@@ -98,16 +99,22 @@
 				await api('/targets', { method: 'POST', body: JSON.stringify({ type: formType, name: form.name, config, tracking_config_id: trkId, template_config_id: tplId }) });
 			}
 			showForm = false; editing = null; await load();
-		} catch (err: any) { error = err.message; }
+			snackSuccess(t('snack.targetSaved'));
+		} catch (err: any) { error = err.message; snackError(err.message); }
 	}
 	async function test(id: number) {
 		testResult = '...';
-		try { const res = await api(`/targets/${id}/test`, { method: 'POST' }); testResult = res.success ? t('targets.testSent') : `Failed: ${res.error}`; }
+		try {
-		catch (err: any) { testResult = `Error: ${err.message}`; }
+			const res = await api(`/targets/${id}/test`, { method: 'POST' });
+			testResult = res.success ? t('targets.testSent') : `Failed: ${res.error}`;
+			if (res.success) snackSuccess(t('snack.targetTestSent'));
+			else snackError(`Failed: ${res.error}`);
+		}
+		catch (err: any) { testResult = `Error: ${err.message}`; snackError(err.message); }
 		setTimeout(() => testResult = '', 5000);
 	}
 	async function remove(id: number) {
-		try { await api(`/targets/${id}`, { method: 'DELETE' }); await load(); } catch (err: any) { error = err.message; }
+		try { await api(`/targets/${id}`, { method: 'DELETE' }); await load(); snackSuccess(t('snack.targetDeleted')); } catch (err: any) { error = err.message; snackError(err.message); }
 	}
 </script>
 

frontend/src/routes/telegram-bots/+page.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
 	import { onMount } from 'svelte';
+	import { slide } from 'svelte/transition';
 	import { api } from '$lib/api';
 	import { t } from '$lib/i18n';
 	import PageHeader from '$lib/components/PageHeader.svelte';
@@ -9,6 +10,22 @@
 	import MdiIcon from '$lib/components/MdiIcon.svelte';
 	import ConfirmModal from '$lib/components/ConfirmModal.svelte';
 	import IconButton from '$lib/components/IconButton.svelte';
+	import Hint from '$lib/components/Hint.svelte';
+	import { snackSuccess, snackError } from '$lib/stores/snackbar.svelte';
+
+	const ALL_COMMANDS = [
+		'status', 'albums', 'events', 'summary', 'latest',
+		'memory', 'random', 'search', 'find', 'person',
+		'place', 'favorites', 'people', 'help',
+	];
+
+	const DEFAULT_CONFIG = {
+		enabled: [...ALL_COMMANDS],
+		default_count: 5,
+		response_mode: 'media',
+		rate_limits: { search: 30, find: 30, default: 10 },
+		locale: 'en',
+	};
 
 	let bots = $state<any[]>([]);
 	let loaded = $state(false);
@@ -18,15 +35,21 @@
 	let submitting = $state(false);
 	let confirmDelete = $state<any>(null);
 
-	// Per-bot chat lists
+	// Per-bot expandable sections
 	let chats = $state<Record<number, any[]>>({});
 	let chatsLoading = $state<Record<number, boolean>>({});
 	let expandedBot = $state<number | null>(null);
+	let expandedSection = $state<Record<number, string>>({});  // bot_id -> 'chats' | 'commands'
+
+	// Commands config editing
+	let editingConfig = $state<Record<number, any>>({});
+	let savingConfig = $state<Record<number, boolean>>({});
+	let syncingCommands = $state<Record<number, boolean>>({});
 
 	onMount(load);
 	async function load() {
 		try { bots = await api('/telegram-bots'); }
-		catch (err: any) { error = err.message || t('common.loadError'); }
+		catch (err: any) { error = err.message || t('common.loadError'); snackError(error); }
 		finally { loaded = true; }
 	}
 
@@ -35,7 +58,8 @@
 		try {
 			await api('/telegram-bots', { method: 'POST', body: JSON.stringify(form) });
 			form = { name: '', icon: '', token: '' }; showForm = false; await load();
-		} catch (err: any) { error = err.message; }
+			snackSuccess(t('snack.botRegistered'));
+		} catch (err: any) { error = err.message; snackError(err.message); }
 		submitting = false;
 	}
 
@@ -43,20 +67,63 @@
 		confirmDelete = {
 			id,
 			onconfirm: async () => {
-				try { await api(`/telegram-bots/${id}`, { method: 'DELETE' }); await load(); }
+				try { await api(`/telegram-bots/${id}`, { method: 'DELETE' }); await load(); snackSuccess(t('snack.botDeleted')); }
-				catch (err: any) { error = err.message; }
+				catch (err: any) { error = err.message; snackError(err.message); }
 				finally { confirmDelete = null; }
 			}
 		};
 	}
 
-	async function loadChats(botId: number) {
+	function toggleSection(botId: number, section: string) {
-		if (expandedBot === botId) { expandedBot = null; return; }
+		if (expandedSection[botId] === section) {
-		expandedBot = botId;
+			expandedSection[botId] = '';
+			return;
+		}
+		expandedSection[botId] = section;
+
+		if (section === 'chats') {
 			chatsLoading[botId] = true;
-		try { chats[botId] = await api(`/telegram-bots/${botId}/chats`); }
+			api(`/telegram-bots/${botId}/chats`)
-		catch { chats[botId] = []; }
+				.then((data: any) => chats[botId] = data)
-		chatsLoading[botId] = false;
+				.catch(() => chats[botId] = [])
+				.finally(() => chatsLoading[botId] = false);
+		}
+
+		if (section === 'commands') {
+			const bot = bots.find((b: any) => b.id === botId);
+			editingConfig[botId] = JSON.parse(JSON.stringify(bot?.commands_config || DEFAULT_CONFIG));
+		}
+	}
+
+	function toggleCommand(botId: number, cmd: string) {
+		const cfg = editingConfig[botId];
+		if (!cfg) return;
+		const idx = cfg.enabled.indexOf(cmd);
+		if (idx >= 0) cfg.enabled.splice(idx, 1);
+		else cfg.enabled.push(cmd);
+	}
+
+	async function saveConfig(botId: number) {
+		savingConfig[botId] = true;
+		try {
+			const updated = await api(`/telegram-bots/${botId}`, {
+				method: 'PUT',
+				body: JSON.stringify({ commands_config: editingConfig[botId] }),
+			});
+			const idx = bots.findIndex((b: any) => b.id === botId);
+			if (idx >= 0) bots[idx] = updated;
+			snackSuccess(t('snack.commandsSaved'));
+		} catch (err: any) { snackError(err.message); }
+		savingConfig[botId] = false;
+	}
+
+	async function syncCommands(botId: number) {
+		syncingCommands[botId] = true;
+		try {
+			await api(`/telegram-bots/${botId}/sync-commands`, { method: 'POST' });
+			snackSuccess(t('snack.commandsSynced'));
+		} catch (err: any) { snackError(err.message); }
+		syncingCommands[botId] = false;
 	}
 
 	function chatTypeLabel(type: string): string {
@@ -86,7 +153,7 @@
 			<div>
 				<label for="bot-name" class="block text-sm font-medium mb-1">{t('telegramBot.name')}</label>
 				<div class="flex gap-2">
-					<IconPicker value={form.icon} onselect={(v) => form.icon = v} />
+					<IconPicker value={form.icon} onselect={(v: string) => form.icon = v} />
 					<input id="bot-name" bind:value={form.name} required placeholder={t('telegramBot.namePlaceholder')}
 						class="flex-1 px-3 py-2 border border-[var(--color-border)] rounded-md text-sm bg-[var(--color-background)]" />
 				</div>
@@ -122,16 +189,21 @@
 						<p class="text-xs text-[var(--color-muted-foreground)] font-mono">{bot.token_preview}</p>
 					</div>
 					<div class="flex items-center gap-1">
-						<button onclick={() => loadChats(bot.id)}
+						<button onclick={() => toggleSection(bot.id, 'chats')}
-							class="text-xs text-[var(--color-muted-foreground)] hover:underline">
+							class="text-xs text-[var(--color-muted-foreground)] hover:underline px-2 py-1">
-							{t('telegramBot.chats')} {expandedBot === bot.id ? '▲' : '▼'}
+							{t('telegramBot.chats')} {expandedSection[bot.id] === 'chats' ? '▲' : '▼'}
+						</button>
+						<button onclick={() => toggleSection(bot.id, 'commands')}
+							class="text-xs text-[var(--color-muted-foreground)] hover:underline px-2 py-1">
+							{t('telegramBot.commands')} {expandedSection[bot.id] === 'commands' ? '▲' : '▼'}
 						</button>
 						<IconButton icon="mdiDelete" title={t('common.delete')} onclick={() => remove(bot.id)} variant="danger" />
 					</div>
 				</div>
 
-				{#if expandedBot === bot.id}
+				<!-- Chats section -->
-					<div class="mt-3 border-t border-[var(--color-border)] pt-3">
+				{#if expandedSection[bot.id] === 'chats'}
+					<div class="mt-3 border-t border-[var(--color-border)] pt-3" in:slide>
 						{#if chatsLoading[bot.id]}
 							<p class="text-xs text-[var(--color-muted-foreground)]">{t('common.loading')}</p>
 						{:else if (chats[bot.id] || []).length === 0}
@@ -149,12 +221,107 @@
 								{/each}
 							</div>
 						{/if}
-						<button onclick={() => loadChats(bot.id)}
+						<button onclick={() => toggleSection(bot.id, 'chats')}
 							class="text-xs text-[var(--color-muted-foreground)] hover:underline mt-2">
 							{t('telegramBot.refreshChats')}
 						</button>
 					</div>
 				{/if}
+
+				<!-- Commands config section -->
+				{#if expandedSection[bot.id] === 'commands' && editingConfig[bot.id]}
+					{@const cfg = editingConfig[bot.id]}
+					<div class="mt-3 border-t border-[var(--color-border)] pt-3 space-y-4" in:slide>
+						<!-- Enabled commands -->
+						<fieldset>
+							<legend class="text-sm font-medium mb-2">{t('telegramBot.enabledCommands')}</legend>
+							<div class="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 gap-1.5">
+								{#each ALL_COMMANDS as cmd}
+									<label class="flex items-center gap-1.5 text-sm cursor-pointer px-2 py-1 rounded hover:bg-[var(--color-muted)]">
+										<input type="checkbox" checked={cfg.enabled.includes(cmd)}
+											onchange={() => toggleCommand(bot.id, cmd)}
+											class="rounded" />
+										<span class="font-mono text-xs">/{cmd}</span>
+									</label>
+								{/each}
+							</div>
+						</fieldset>
+
+						<!-- Settings row -->
+						<div class="grid grid-cols-1 sm:grid-cols-3 gap-3">
+							<div>
+								<label class="block text-sm font-medium mb-1">
+									{t('telegramBot.defaultCount')}
+									<Hint text={t('hints.defaultCount')} />
+								</label>
+								<input type="number" min="1" max="20" bind:value={cfg.default_count}
+									class="w-full px-3 py-2 border border-[var(--color-border)] rounded-md text-sm bg-[var(--color-background)]" />
+							</div>
+							<div>
+								<label class="block text-sm font-medium mb-1">
+									{t('telegramBot.responseMode')}
+									<Hint text={t('hints.responseMode')} />
+								</label>
+								<select bind:value={cfg.response_mode}
+									class="w-full px-3 py-2 border border-[var(--color-border)] rounded-md text-sm bg-[var(--color-background)]">
+									<option value="media">{t('telegramBot.modeMedia')}</option>
+									<option value="text">{t('telegramBot.modeText')}</option>
+								</select>
+							</div>
+							<div>
+								<label class="block text-sm font-medium mb-1">
+									{t('telegramBot.botLocale')}
+									<Hint text={t('hints.botLocale')} />
+								</label>
+								<select bind:value={cfg.locale}
+									class="w-full px-3 py-2 border border-[var(--color-border)] rounded-md text-sm bg-[var(--color-background)]">
+									<option value="en">English</option>
+									<option value="ru">Русский</option>
+								</select>
+							</div>
+						</div>
+
+						<!-- Rate limits -->
+						<fieldset>
+							<legend class="text-sm font-medium mb-2">
+								{t('telegramBot.rateLimits')}
+								<Hint text={t('hints.rateLimits')} />
+							</legend>
+							<div class="grid grid-cols-1 sm:grid-cols-3 gap-3">
+								<div>
+									<label class="block text-xs text-[var(--color-muted-foreground)] mb-1">{t('telegramBot.rateSearch')} (s)</label>
+									<input type="number" min="0" max="300" bind:value={cfg.rate_limits.search}
+										class="w-full px-3 py-2 border border-[var(--color-border)] rounded-md text-sm bg-[var(--color-background)]" />
+								</div>
+								<div>
+									<label class="block text-xs text-[var(--color-muted-foreground)] mb-1">{t('telegramBot.rateFind')} (s)</label>
+									<input type="number" min="0" max="300" bind:value={cfg.rate_limits.find}
+										class="w-full px-3 py-2 border border-[var(--color-border)] rounded-md text-sm bg-[var(--color-background)]" />
+								</div>
+								<div>
+									<label class="block text-xs text-[var(--color-muted-foreground)] mb-1">{t('telegramBot.rateDefault')} (s)</label>
+									<input type="number" min="0" max="300" bind:value={cfg.rate_limits.default}
+										class="w-full px-3 py-2 border border-[var(--color-border)] rounded-md text-sm bg-[var(--color-background)]" />
+								</div>
+							</div>
+						</fieldset>
+
+						<!-- Action buttons -->
+						<div class="flex gap-2 pt-2">
+							<button onclick={() => saveConfig(bot.id)} disabled={savingConfig[bot.id]}
+								class="px-4 py-2 bg-[var(--color-primary)] text-[var(--color-primary-foreground)] rounded-md text-sm font-medium hover:opacity-90 disabled:opacity-50">
+								{savingConfig[bot.id] ? t('common.loading') : t('common.save')}
+							</button>
+							<button onclick={() => syncCommands(bot.id)} disabled={syncingCommands[bot.id]}
+								class="px-4 py-2 bg-[var(--color-muted)] text-[var(--color-foreground)] rounded-md text-sm font-medium hover:opacity-80 disabled:opacity-50">
+								<span class="flex items-center gap-1.5">
+									<MdiIcon name="mdiSync" size={16} />
+									{syncingCommands[bot.id] ? t('common.loading') : t('telegramBot.syncCommands')}
+								</span>
+							</button>
+						</div>
+					</div>
+				{/if}
 			</Card>
 		{/each}
 	</div>

frontend/src/routes/template-configs/+page.svelte

@@ -13,6 +13,7 @@
 	import IconButton from '$lib/components/IconButton.svelte';
 	import Modal from '$lib/components/Modal.svelte';
 	import JinjaEditor from '$lib/components/JinjaEditor.svelte';
+	import { snackSuccess, snackError } from '$lib/stores/snackbar.svelte';
 
 	let configs = $state<any[]>([]);
 	let loaded = $state(false);
@@ -114,7 +115,7 @@
 				api('/template-configs'),
 				api('/template-configs/variables'),
 			]);
-		} catch (err: any) { error = err.message || t('common.loadError'); }
+		} catch (err: any) { error = err.message || t('common.loadError'); snackError(error); }
 		finally { loaded = true; }
 	}
 
@@ -132,7 +133,8 @@
 			if (editing) await api(`/template-configs/${editing}`, { method: 'PUT', body: JSON.stringify(form) });
 			else await api('/template-configs', { method: 'POST', body: JSON.stringify(form) });
 			showForm = false; editing = null; await load();
-		} catch (err: any) { error = err.message; }
+			snackSuccess(t('snack.templateSaved'));
+		} catch (err: any) { error = err.message; snackError(err.message); }
 	}
 
 	async function preview(configId: number, slotKey: string) {
@@ -150,8 +152,8 @@
 		confirmDelete = {
 			id,
 			onconfirm: async () => {
-				try { await api(`/template-configs/${id}`, { method: 'DELETE' }); await load(); }
+				try { await api(`/template-configs/${id}`, { method: 'DELETE' }); await load(); snackSuccess(t('snack.templateDeleted')); }
-				catch (err: any) { error = err.message; }
+				catch (err: any) { error = err.message; snackError(err.message); }
 				finally { confirmDelete = null; }
 			}
 		};

frontend/src/routes/trackers/+page.svelte

@@ -11,6 +11,7 @@
 	import ConfirmModal from '$lib/components/ConfirmModal.svelte';
 	import Hint from '$lib/components/Hint.svelte';
 	import IconButton from '$lib/components/IconButton.svelte';
+	import { snackSuccess, snackError } from '$lib/stores/snackbar.svelte';
 
 	let loaded = $state(false);
 	let loadError = $state('');
@@ -41,6 +42,7 @@
 			[trackers, servers, targets] = await Promise.all([api('/trackers'), api('/servers'), api('/targets')]);
 		} catch (err: any) {
 			loadError = err.message || 'Failed to load data';
+			snackError(loadError);
 		} finally {
 			loaded = true;
 		}
@@ -64,11 +66,13 @@
 		try {
 			if (editing) {
 				await api(`/trackers/${editing}`, { method: 'PUT', body: JSON.stringify(form) });
+				snackSuccess(t('snack.trackerUpdated'));
 			} else {
 				await api('/trackers', { method: 'POST', body: JSON.stringify(form) });
+				snackSuccess(t('snack.trackerCreated'));
 			}
 			showForm = false; editing = null; await load();
-		} catch (err: any) { error = err.message; } finally { submitting = false; }
+		} catch (err: any) { error = err.message; snackError(err.message); } finally { submitting = false; }
 	}
 	async function toggle(tracker: any) {
 		if (toggling[tracker.id]) return;
@@ -76,7 +80,8 @@
 		try {
 			await api(`/trackers/${tracker.id}`, { method: 'PUT', body: JSON.stringify({ enabled: !tracker.enabled }) });
 			await load();
-		} finally { toggling[tracker.id] = false; }
+			snackSuccess(tracker.enabled ? t('snack.trackerPaused') : t('snack.trackerResumed'));
+		} catch (err: any) { snackError(err.message); } finally { toggling[tracker.id] = false; }
 	}
 	function startDelete(tracker: any) { confirmDelete = tracker; }
 	async function doDelete() {
@@ -84,7 +89,8 @@
 		try {
 			await api(`/trackers/${confirmDelete.id}`, { method: 'DELETE' });
 			await load();
-		} catch (err: any) { error = err.message; }
+			snackSuccess(t('snack.trackerDeleted'));
+		} catch (err: any) { error = err.message; snackError(err.message); }
 		confirmDelete = null;
 	}
 	async function testPeriodic(tracker: any) {

frontend/src/routes/tracking-configs/+page.svelte

@@ -11,6 +11,7 @@
 	import ConfirmModal from '$lib/components/ConfirmModal.svelte';
 	import Hint from '$lib/components/Hint.svelte';
 	import IconButton from '$lib/components/IconButton.svelte';
+	import { snackSuccess, snackError } from '$lib/stores/snackbar.svelte';
 
 	let configs = $state<any[]>([]);
 	let loaded = $state(false);
@@ -37,7 +38,7 @@
 	onMount(load);
 	async function load() {
 		try { configs = await api('/tracking-configs'); }
-		catch (err: any) { error = err.message || t('common.loadError'); }
+		catch (err: any) { error = err.message || t('common.loadError'); snackError(error); }
 		finally { loaded = true; }
 	}
 
@@ -53,15 +54,16 @@
 			if (editing) await api(`/tracking-configs/${editing}`, { method: 'PUT', body: JSON.stringify(form) });
 			else await api('/tracking-configs', { method: 'POST', body: JSON.stringify(form) });
 			showForm = false; editing = null; await load();
-		} catch (err: any) { error = err.message; }
+			snackSuccess(t('snack.trackingConfigSaved'));
+		} catch (err: any) { error = err.message; snackError(err.message); }
 	}
 
 	function remove(id: number) {
 		confirmDelete = {
 			id,
 			onconfirm: async () => {
-				try { await api(`/tracking-configs/${id}`, { method: 'DELETE' }); await load(); }
+				try { await api(`/tracking-configs/${id}`, { method: 'DELETE' }); await load(); snackSuccess(t('snack.trackingConfigDeleted')); }
-				catch (err: any) { error = err.message; }
+				catch (err: any) { error = err.message; snackError(err.message); }
 				finally { confirmDelete = null; }
 			}
 		};

frontend/src/routes/users/+page.svelte

@@ -9,6 +9,7 @@
 	import Modal from '$lib/components/Modal.svelte';
 	import ConfirmModal from '$lib/components/ConfirmModal.svelte';
 	import IconButton from '$lib/components/IconButton.svelte';
+	import { snackSuccess, snackError } from '$lib/stores/snackbar.svelte';
 
 	const auth = getAuth();
 	let users = $state<any[]>([]);
@@ -28,21 +29,21 @@
 	onMount(load);
 	async function load() {
 		try { users = await api('/users'); }
-		catch (err: any) { error = err.message || t('common.loadError'); }
+		catch (err: any) { error = err.message || t('common.loadError'); snackError(error); }
 		finally { loaded = true; }
 	}
 
 	async function create(e: SubmitEvent) {
 		e.preventDefault(); error = '';
-		try { await api('/users', { method: 'POST', body: JSON.stringify(form) }); form = { username: '', password: '', role: 'user' }; showForm = false; await load(); }
+		try { await api('/users', { method: 'POST', body: JSON.stringify(form) }); form = { username: '', password: '', role: 'user' }; showForm = false; await load(); snackSuccess(t('snack.userCreated')); }
-		catch (err: any) { error = err.message; }
+		catch (err: any) { error = err.message; snackError(err.message); }
 	}
 	function remove(id: number) {
 		confirmDelete = {
 			id,
 			onconfirm: async () => {
-				try { await api(`/users/${id}`, { method: 'DELETE' }); await load(); }
+				try { await api(`/users/${id}`, { method: 'DELETE' }); await load(); snackSuccess(t('snack.userDeleted')); }
-				catch (err: any) { error = err.message; }
+				catch (err: any) { error = err.message; snackError(err.message); }
 				finally { confirmDelete = null; }
 			}
 		};
@@ -56,8 +57,9 @@
 			await api(`/users/${resetUserId}/password`, { method: 'PUT', body: JSON.stringify({ new_password: resetPassword }) });
 			resetMsg = t('common.passwordChanged');
 			resetSuccess = true;
+			snackSuccess(t('snack.passwordChanged'));
 			setTimeout(() => { resetUserId = null; resetMsg = ''; resetSuccess = false; }, 2000);
-		} catch (err: any) { resetMsg = err.message; resetSuccess = false; }
+		} catch (err: any) { resetMsg = err.message; resetSuccess = false; snackError(err.message); }
 	}
 </script>
 

packages/core/src/immich_watcher_core/immich_client.py

@@ -358,5 +358,189 @@ class ImmichClient:
             return False
 
 
+    async def search_smart(
+        self,
+        query: str,
+        album_ids: list[str] | None = None,
+        limit: int = 10,
+    ) -> list[dict[str, Any]]:
+        """Semantic search via Immich CLIP (smart search).
+
+        Args:
+            query: Natural language search query
+            album_ids: Optional list of album IDs to scope results to
+            limit: Max results to return
+
+        Returns:
+            List of asset dicts from search results
+        """
+        payload: dict[str, Any] = {"query": query, "page": 1, "size": limit}
+        try:
+            async with self._session.post(
+                f"{self._url}/api/search/smart",
+                headers=self._json_headers,
+                json=payload,
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    items = data.get("assets", {}).get("items", [])
+                    if album_ids:
+                        # Post-filter: only keep assets from tracked albums
+                        tracked = set(album_ids)
+                        items = [
+                            a for a in items
+                            if any(
+                                alb.get("id") in tracked
+                                for alb in a.get("albums", [])
+                            )
+                        ]
+                    return items[:limit]
+                _LOGGER.warning("Smart search failed: HTTP %s", response.status)
+        except aiohttp.ClientError as err:
+            _LOGGER.warning("Smart search error: %s", err)
+        return []
+
+    async def search_metadata(
+        self,
+        query: str,
+        album_ids: list[str] | None = None,
+        limit: int = 10,
+    ) -> list[dict[str, Any]]:
+        """Search assets by metadata (filename, description).
+
+        Args:
+            query: Text to search for
+            album_ids: Optional list of album IDs to scope results to
+            limit: Max results to return
+
+        Returns:
+            List of asset dicts from search results
+        """
+        payload: dict[str, Any] = {
+            "originalFileName": query,
+            "page": 1,
+            "size": limit,
+        }
+        try:
+            async with self._session.post(
+                f"{self._url}/api/search/metadata",
+                headers=self._json_headers,
+                json=payload,
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    items = data.get("assets", {}).get("items", [])
+                    if album_ids:
+                        tracked = set(album_ids)
+                        items = [
+                            a for a in items
+                            if any(
+                                alb.get("id") in tracked
+                                for alb in a.get("albums", [])
+                            )
+                        ]
+                    return items[:limit]
+                _LOGGER.warning("Metadata search failed: HTTP %s", response.status)
+        except aiohttp.ClientError as err:
+            _LOGGER.warning("Metadata search error: %s", err)
+        return []
+
+    async def search_by_person(
+        self,
+        person_id: str,
+        limit: int = 10,
+    ) -> list[dict[str, Any]]:
+        """Find assets containing a specific person.
+
+        Args:
+            person_id: Immich person ID
+            limit: Max results to return
+
+        Returns:
+            List of asset dicts
+        """
+        try:
+            async with self._session.get(
+                f"{self._url}/api/people/{person_id}/assets",
+                headers=self._headers,
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    return data[:limit]
+                _LOGGER.warning("Person assets failed: HTTP %s", response.status)
+        except aiohttp.ClientError as err:
+            _LOGGER.warning("Person assets error: %s", err)
+        return []
+
+    async def get_random_assets(
+        self,
+        count: int = 5,
+    ) -> list[dict[str, Any]]:
+        """Get random assets from Immich.
+
+        Args:
+            count: Number of random assets to return
+
+        Returns:
+            List of asset dicts
+        """
+        try:
+            async with self._session.get(
+                f"{self._url}/api/assets/random",
+                headers=self._headers,
+                params={"count": count},
+            ) as response:
+                if response.status == 200:
+                    return await response.json()
+                _LOGGER.warning("Random assets failed: HTTP %s", response.status)
+        except aiohttp.ClientError as err:
+            _LOGGER.warning("Random assets error: %s", err)
+        return []
+
+    async def download_asset(self, asset_id: str) -> bytes | None:
+        """Download an asset's original file.
+
+        Args:
+            asset_id: The asset ID to download
+
+        Returns:
+            Raw bytes of the asset, or None on failure
+        """
+        try:
+            async with self._session.get(
+                f"{self._url}/api/assets/{asset_id}/original",
+                headers=self._headers,
+            ) as response:
+                if response.status == 200:
+                    return await response.read()
+                _LOGGER.warning("Asset download failed: HTTP %s", response.status)
+        except aiohttp.ClientError as err:
+            _LOGGER.warning("Asset download error: %s", err)
+        return None
+
+    async def get_asset_thumbnail(self, asset_id: str, size: str = "preview") -> bytes | None:
+        """Download an asset's thumbnail/preview.
+
+        Args:
+            asset_id: The asset ID
+            size: "thumbnail" (small) or "preview" (larger)
+
+        Returns:
+            Raw bytes of the thumbnail, or None on failure
+        """
+        try:
+            async with self._session.get(
+                f"{self._url}/api/assets/{asset_id}/thumbnail",
+                headers=self._headers,
+                params={"size": size},
+            ) as response:
+                if response.status == 200:
+                    return await response.read()
+                _LOGGER.warning("Thumbnail download failed: HTTP %s", response.status)
+        except aiohttp.ClientError as err:
+            _LOGGER.warning("Thumbnail download error: %s", err)
+        return None
+
+
 class ImmichApiError(Exception):
     """Raised when an Immich API call fails."""

packages/server/src/immich_watcher_server/ai/commands.py

@@ -0,0 +1,637 @@
+"""Telegram bot command handler — implements all /commands."""
+
+from __future__ import annotations
+
+import logging
+import time
+from datetime import datetime, timezone
+from typing import Any
+
+import aiohttp
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from immich_watcher_core.immich_client import ImmichClient
+from immich_watcher_core.telegram.media import TELEGRAM_API_BASE_URL
+
+from ..database.models import (
+    AlbumTracker,
+    EventLog,
+    ImmichServer,
+    NotificationTarget,
+    TelegramBot,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+# Command descriptions for Telegram menu (EN / RU)
+COMMAND_DESCRIPTIONS: dict[str, dict[str, str]] = {
+    "status":    {"en": "Show tracker status", "ru": "Показать статус трекеров"},
+    "albums":    {"en": "List tracked albums", "ru": "Список отслеживаемых альбомов"},
+    "events":    {"en": "Show recent events", "ru": "Показать последние события"},
+    "summary":   {"en": "Send album summary now", "ru": "Отправить сводку альбомов"},
+    "latest":    {"en": "Show latest photos", "ru": "Показать последние фото"},
+    "memory":    {"en": "On This Day memories", "ru": "Воспоминания за этот день"},
+    "random":    {"en": "Send random photo", "ru": "Отправить случайное фото"},
+    "search":    {"en": "Smart search (AI)", "ru": "Умный поиск (AI)"},
+    "find":      {"en": "Search by filename", "ru": "Поиск по имени файла"},
+    "person":    {"en": "Find photos of person", "ru": "Найти фото человека"},
+    "place":     {"en": "Find photos by location", "ru": "Найти фото по месту"},
+    "favorites": {"en": "Show favorites", "ru": "Показать избранное"},
+    "people":    {"en": "List detected people", "ru": "Список людей"},
+    "help":      {"en": "Show available commands", "ru": "Показать доступные команды"},
+}
+
+# Rate limit state: { (bot_id, chat_id, command_category): last_used_timestamp }
+_rate_limits: dict[tuple[int, str, str], float] = {}
+
+# Map commands to rate limit categories
+_RATE_CATEGORY: dict[str, str] = {
+    "search": "search", "find": "search", "person": "search",
+    "place": "search", "favorites": "search", "people": "search",
+}
+
+
+def _get_rate_category(cmd: str) -> str:
+    return _RATE_CATEGORY.get(cmd, "default")
+
+
+def _check_rate_limit(bot_id: int, chat_id: str, cmd: str, limits: dict[str, int]) -> int | None:
+    """Check rate limit. Returns seconds to wait, or None if OK."""
+    category = _get_rate_category(cmd)
+    cooldown = limits.get(category, limits.get("default", 10))
+    if cooldown <= 0:
+        return None
+    key = (bot_id, chat_id, category)
+    now = time.time()
+    last = _rate_limits.get(key, 0)
+    if now - last < cooldown:
+        return int(cooldown - (now - last)) + 1
+    _rate_limits[key] = now
+    return None
+
+
+def parse_command(text: str) -> tuple[str, str, int | None]:
+    """Parse a command message into (command, args, count).
+
+    Examples:
+        "/search sunset" -> ("search", "sunset", None)
+        "/latest Family 5" -> ("latest", "Family", 5)
+        "/events 10" -> ("events", "", 10)
+    """
+    text = text.strip()
+    if not text.startswith("/"):
+        return ("", text, None)
+
+    # Strip @botname suffix: /command@botname args
+    parts = text[1:].split(None, 1)
+    cmd = parts[0].split("@")[0].lower()
+    rest = parts[1] if len(parts) > 1 else ""
+
+    # Try to extract trailing count
+    count = None
+    rest_parts = rest.rsplit(None, 1)
+    if len(rest_parts) == 2:
+        try:
+            count = int(rest_parts[1])
+            rest = rest_parts[0]
+        except ValueError:
+            pass
+    elif rest_parts and rest_parts[0]:
+        try:
+            count = int(rest_parts[0])
+            rest = ""
+        except ValueError:
+            pass
+
+    return (cmd, rest.strip(), count)
+
+
+async def handle_command(
+    bot: TelegramBot,
+    chat_id: str,
+    text: str,
+    session: AsyncSession,
+) -> str | list[dict[str, Any]] | None:
+    """Handle a bot command. Returns text response or media list, or None if not a command."""
+    cmd, args, count_override = parse_command(text)
+    if not cmd:
+        return None
+
+    config = bot.commands_config or {}
+    enabled = config.get("enabled", [])
+    default_count = min(config.get("default_count", 5), 20)
+    locale = config.get("locale", "en")
+    rate_limits = config.get("rate_limits", {})
+
+    if cmd == "start":
+        msgs = {
+            "en": "Hi! I'm your Immich Watcher bot. Use /help to see available commands.",
+            "ru": "Привет! Я бот Immich Watcher. Используйте /help для списка команд.",
+        }
+        return msgs.get(locale, msgs["en"])
+
+    if cmd not in enabled and cmd != "start":
+        return None  # Silently ignore disabled commands
+
+    # Rate limit check
+    wait = _check_rate_limit(bot.id, chat_id, cmd, rate_limits)
+    if wait is not None:
+        msgs = {
+            "en": f"Please wait {wait}s before using this command again.",
+            "ru": f"Подождите {wait} сек. перед повторным использованием.",
+        }
+        return msgs.get(locale, msgs["en"])
+
+    count = min(count_override or default_count, 20)
+
+    # Dispatch
+    if cmd == "help":
+        return _cmd_help(enabled, locale)
+    if cmd == "status":
+        return await _cmd_status(bot, session, locale)
+    if cmd == "albums":
+        return await _cmd_albums(bot, session, locale)
+    if cmd == "events":
+        return await _cmd_events(bot, session, count, locale)
+    if cmd == "people":
+        return await _cmd_people(bot, session, locale)
+    if cmd in ("search", "find", "person", "place", "latest", "random", "favorites", "summary", "memory"):
+        return await _cmd_immich(bot, cmd, args, count, session, locale)
+
+    return None
+
+
+def _cmd_help(enabled: list[str], locale: str) -> str:
+    """Generate /help response from enabled commands."""
+    lines = []
+    for cmd in enabled:
+        desc = COMMAND_DESCRIPTIONS.get(cmd, {})
+        lines.append(f"/{cmd} — {desc.get(locale, desc.get('en', ''))}")
+    header = {"en": "Available commands:", "ru": "Доступные команды:"}
+    return header.get(locale, header["en"]) + "\n" + "\n".join(lines)
+
+
+async def _cmd_status(bot: TelegramBot, session: AsyncSession, locale: str) -> str:
+    """Show tracker status."""
+    # Find trackers via targets linked to this bot
+    trackers, _ = await _get_bot_trackers(bot, session)
+
+    active = sum(1 for t in trackers if t.enabled)
+    total = len(trackers)
+    total_albums = sum(len(t.album_ids) for t in trackers)
+
+    result = await session.exec(
+        select(EventLog).order_by(EventLog.created_at.desc()).limit(1)
+    )
+    last_event = result.first()
+    last_str = last_event.created_at.strftime("%Y-%m-%d %H:%M") if last_event else "-"
+
+    if locale == "ru":
+        return (
+            f"📊 Статус\n"
+            f"Трекеры: {active}/{total} активных\n"
+            f"Альбомы: {total_albums}\n"
+            f"Последнее событие: {last_str}"
+        )
+    return (
+        f"📊 Status\n"
+        f"Trackers: {active}/{total} active\n"
+        f"Albums: {total_albums}\n"
+        f"Last event: {last_str}"
+    )
+
+
+async def _cmd_albums(bot: TelegramBot, session: AsyncSession, locale: str) -> str:
+    """List tracked albums with asset counts."""
+    trackers, servers_map = await _get_bot_trackers(bot, session)
+
+    if not trackers:
+        return "No tracked albums." if locale == "en" else "Нет отслеживаемых альбомов."
+
+    lines = []
+    async with aiohttp.ClientSession() as http:
+        for tracker in trackers:
+            server = servers_map.get(tracker.server_id)
+            if not server:
+                continue
+            client = ImmichClient(http, server.url, server.api_key)
+            for album_id in tracker.album_ids:
+                try:
+                    album = await client.get_album(album_id)
+                    if album:
+                        lines.append(f"  • {album.name} ({album.asset_count} assets)")
+                except Exception:
+                    lines.append(f"  • {album_id[:8]}... (error)")
+
+    header = "📚 Tracked albums:" if locale == "en" else "📚 Отслеживаемые альбомы:"
+    return header + "\n" + "\n".join(lines) if lines else header + "\n  (none)"
+
+
+async def _cmd_events(bot: TelegramBot, session: AsyncSession, count: int, locale: str) -> str:
+    """Show recent events."""
+    trackers, _ = await _get_bot_trackers(bot, session)
+    tracker_ids = [t.id for t in trackers]
+
+    if not tracker_ids:
+        return "No events." if locale == "en" else "Нет событий."
+
+    result = await session.exec(
+        select(EventLog)
+        .where(EventLog.tracker_id.in_(tracker_ids))
+        .order_by(EventLog.created_at.desc())
+        .limit(count)
+    )
+    events = result.all()
+
+    if not events:
+        return "No events yet." if locale == "en" else "Пока нет событий."
+
+    header = f"📋 Last {len(events)} events:" if locale == "en" else f"📋 Последние {len(events)} событий:"
+    lines = []
+    for e in events:
+        ts = e.created_at.strftime("%m/%d %H:%M")
+        lines.append(f"  {ts} — {e.event_type}: {e.album_name}")
+
+    return header + "\n" + "\n".join(lines)
+
+
+async def _cmd_people(bot: TelegramBot, session: AsyncSession, locale: str) -> str:
+    """List people detected across tracked albums."""
+    _, servers_map = await _get_bot_trackers(bot, session)
+
+    all_people: dict[str, str] = {}
+    async with aiohttp.ClientSession() as http:
+        for server in servers_map.values():
+            client = ImmichClient(http, server.url, server.api_key)
+            people = await client.get_people()
+            all_people.update(people)
+
+    if not all_people:
+        return "No people detected." if locale == "en" else "Люди не обнаружены."
+
+    names = sorted(all_people.values())
+    header = f"👥 {len(names)} people:" if locale == "en" else f"👥 {len(names)} людей:"
+    return header + "\n" + ", ".join(names)
+
+
+async def _cmd_immich(
+    bot: TelegramBot,
+    cmd: str,
+    args: str,
+    count: int,
+    session: AsyncSession,
+    locale: str,
+) -> str | list[dict[str, Any]]:
+    """Handle commands that need Immich API access and may return media."""
+    trackers, servers_map = await _get_bot_trackers(bot, session)
+
+    if not trackers:
+        return "No trackers configured." if locale == "en" else "Трекеры не настроены."
+
+    # Collect all tracked album IDs
+    all_album_ids: list[str] = []
+    for t in trackers:
+        all_album_ids.extend(t.album_ids)
+
+    # Pick the first server (most commands need one)
+    first_tracker = trackers[0]
+    server = servers_map.get(first_tracker.server_id)
+    if not server:
+        return "Server not found." if locale == "en" else "Сервер не найден."
+
+    config = bot.commands_config or {}
+    response_mode = config.get("response_mode", "media")
+
+    async with aiohttp.ClientSession() as http:
+        client = ImmichClient(http, server.url, server.api_key)
+        await client.get_server_config()
+
+        if cmd == "search":
+            if not args:
+                return "Usage: /search <query>" if locale == "en" else "Использование: /search <запрос>"
+            assets = await client.search_smart(args, album_ids=all_album_ids, limit=count)
+            return _format_assets(assets, cmd, args, locale, response_mode, client, bot.token)
+
+        if cmd == "find":
+            if not args:
+                return "Usage: /find <text>" if locale == "en" else "Использование: /find <текст>"
+            assets = await client.search_metadata(args, album_ids=all_album_ids, limit=count)
+            return _format_assets(assets, cmd, args, locale, response_mode, client, bot.token)
+
+        if cmd == "person":
+            if not args:
+                return "Usage: /person <name>" if locale == "en" else "Использование: /person <имя>"
+            people = await client.get_people()
+            # Find matching person by name (case-insensitive)
+            person_id = None
+            for pid, pname in people.items():
+                if args.lower() in pname.lower():
+                    person_id = pid
+                    break
+            if not person_id:
+                return f"Person '{args}' not found." if locale == "en" else f"Человек '{args}' не найден."
+            assets = await client.search_by_person(person_id, limit=count)
+            return _format_assets(assets, cmd, args, locale, response_mode, client, bot.token)
+
+        if cmd == "place":
+            if not args:
+                return "Usage: /place <location>" if locale == "en" else "Использование: /place <место>"
+            # Use smart search scoped to location context
+            assets = await client.search_smart(
+                f"photos taken in {args}", album_ids=all_album_ids, limit=count
+            )
+            return _format_assets(assets, cmd, args, locale, response_mode, client, bot.token)
+
+        if cmd == "favorites":
+            # Get assets from tracked albums and filter favorites
+            fav_assets: list[dict[str, Any]] = []
+            for album_id in all_album_ids[:10]:
+                try:
+                    album = await client.get_album(album_id)
+                    if album:
+                        for asset in album.assets[:50]:
+                            if asset.is_favorite and len(fav_assets) < count:
+                                fav_assets.append({
+                                    "id": asset.id,
+                                    "originalFileName": asset.filename,
+                                    "type": asset.type,
+                                })
+                except Exception:
+                    pass
+                if len(fav_assets) >= count:
+                    break
+            return _format_assets(fav_assets, cmd, "", locale, response_mode, client, bot.token)
+
+        if cmd == "latest":
+            # Get latest assets from tracked albums
+            latest_assets: list[dict[str, Any]] = []
+            for album_id in all_album_ids[:10]:
+                try:
+                    album = await client.get_album(album_id)
+                    if album and album.assets:
+                        for asset in album.assets[:count]:
+                            latest_assets.append({
+                                "id": asset.id,
+                                "originalFileName": asset.filename,
+                                "type": asset.type,
+                                "createdAt": asset.created_at,
+                            })
+                except Exception:
+                    pass
+            # Sort by date descending, take top N
+            latest_assets.sort(key=lambda a: a.get("createdAt", ""), reverse=True)
+            latest_assets = latest_assets[:count]
+            return _format_assets(latest_assets, cmd, "", locale, response_mode, client, bot.token)
+
+        if cmd == "random":
+            # Get random assets scoped to tracked albums
+            random_assets: list[dict[str, Any]] = []
+            import random as rng
+            for album_id in all_album_ids[:10]:
+                try:
+                    album = await client.get_album(album_id)
+                    if album and album.assets:
+                        sampled = rng.sample(album.assets, min(count, len(album.assets)))
+                        for asset in sampled:
+                            random_assets.append({
+                                "id": asset.id,
+                                "originalFileName": asset.filename,
+                                "type": asset.type,
+                            })
+                except Exception:
+                    pass
+            rng.shuffle(random_assets)
+            random_assets = random_assets[:count]
+            return _format_assets(random_assets, cmd, "", locale, response_mode, client, bot.token)
+
+        if cmd == "summary":
+            lines = []
+            for album_id in all_album_ids:
+                try:
+                    album = await client.get_album(album_id)
+                    if album:
+                        lines.append(f"  • {album.name}: {album.asset_count} assets")
+                except Exception:
+                    pass
+            header = f"📋 Album summary ({len(lines)}):" if locale == "en" else f"📋 Сводка альбомов ({len(lines)}):"
+            return header + "\n" + "\n".join(lines) if lines else header
+
+        if cmd == "memory":
+            today = datetime.now(timezone.utc)
+            month_day = (today.month, today.day)
+            memory_assets: list[dict[str, Any]] = []
+            for album_id in all_album_ids[:10]:
+                try:
+                    album = await client.get_album(album_id)
+                    if album:
+                        for asset in album.assets:
+                            try:
+                                dt = datetime.fromisoformat(asset.created_at.replace("Z", "+00:00"))
+                                if (dt.month, dt.day) == month_day and dt.year != today.year:
+                                    memory_assets.append({
+                                        "id": asset.id,
+                                        "originalFileName": asset.filename,
+                                        "type": asset.type,
+                                        "createdAt": asset.created_at,
+                                        "year": dt.year,
+                                    })
+                            except (ValueError, AttributeError):
+                                pass
+                except Exception:
+                    pass
+            memory_assets = memory_assets[:count]
+            if not memory_assets:
+                return "No memories for today." if locale == "en" else "Нет воспоминаний за сегодня."
+            return _format_assets(memory_assets, cmd, "", locale, response_mode, client, bot.token)
+
+    return "Unknown command." if locale == "en" else "Неизвестная команда."
+
+
+def _format_assets(
+    assets: list[dict[str, Any]],
+    cmd: str,
+    query: str,
+    locale: str,
+    response_mode: str,
+    client: ImmichClient,
+    bot_token: str,
+) -> str | list[dict[str, Any]]:
+    """Format asset results as text or media payload."""
+    if not assets:
+        msgs = {"en": "No results found.", "ru": "Ничего не найдено."}
+        return msgs.get(locale, msgs["en"])
+
+    if response_mode == "media":
+        # Return media list for the webhook handler to send as photos
+        media_items = []
+        for asset in assets:
+            asset_id = asset.get("id", "")
+            filename = asset.get("originalFileName", "")
+            year = asset.get("year", "")
+            caption = filename
+            if year:
+                caption = f"{filename} ({year})"
+            media_items.append({
+                "type": "photo",
+                "asset_id": asset_id,
+                "caption": caption,
+                "thumbnail_url": f"{client.url}/api/assets/{asset_id}/thumbnail?size=preview",
+                "api_key": client.api_key,
+            })
+        return media_items
+
+    # Text mode
+    header_map = {
+        "search": {"en": f"🔍 Results for \"{query}\":", "ru": f"🔍 Результаты для \"{query}\":"},
+        "find": {"en": f"📄 Files matching \"{query}\":", "ru": f"📄 Файлы по запросу \"{query}\":"},
+        "person": {"en": f"👤 Photos of {query}:", "ru": f"👤 Фото {query}:"},
+        "place": {"en": f"📍 Photos from {query}:", "ru": f"📍 Фото из {query}:"},
+        "favorites": {"en": "⭐ Favorites:", "ru": "⭐ Избранное:"},
+        "latest": {"en": "📸 Latest:", "ru": "📸 Последние:"},
+        "random": {"en": "🎲 Random:", "ru": "🎲 Случайные:"},
+        "memory": {"en": "📅 On this day:", "ru": "📅 В этот день:"},
+    }
+    header = header_map.get(cmd, {}).get(locale, f"Results ({len(assets)}):")
+    lines = []
+    for a in assets:
+        name = a.get("originalFileName", a.get("id", "?")[:8])
+        year = a.get("year", "")
+        if year:
+            lines.append(f"  • {name} ({year})")
+        else:
+            lines.append(f"  • {name}")
+    return header + "\n" + "\n".join(lines)
+
+
+async def _get_bot_trackers(
+    bot: TelegramBot, session: AsyncSession
+) -> tuple[list[AlbumTracker], dict[int, ImmichServer]]:
+    """Get trackers and servers associated with a bot via its targets."""
+    # Find targets that use this bot's token
+    result = await session.exec(
+        select(NotificationTarget).where(NotificationTarget.type == "telegram")
+    )
+    targets = result.all()
+
+    bot_target_ids = set()
+    for target in targets:
+        if target.config.get("bot_token") == bot.token:
+            bot_target_ids.add(target.id)
+
+    if not bot_target_ids:
+        return [], {}
+
+    # Find trackers that include any of these target IDs
+    result = await session.exec(select(AlbumTracker))
+    all_trackers = result.all()
+
+    trackers = []
+    server_ids = set()
+    for tracker in all_trackers:
+        if any(tid in bot_target_ids for tid in (tracker.target_ids or [])):
+            trackers.append(tracker)
+            server_ids.add(tracker.server_id)
+
+    # Load servers
+    servers_map: dict[int, ImmichServer] = {}
+    for sid in server_ids:
+        server = await session.get(ImmichServer, sid)
+        if server:
+            servers_map[sid] = server
+
+    return trackers, servers_map
+
+
+async def send_media_group(
+    bot_token: str,
+    chat_id: str,
+    media_items: list[dict[str, Any]],
+) -> None:
+    """Send media items as photos to a Telegram chat."""
+    async with aiohttp.ClientSession() as http:
+        for item in media_items:
+            asset_id = item.get("asset_id", "")
+            caption = item.get("caption", "")
+            thumb_url = item.get("thumbnail_url", "")
+            api_key = item.get("api_key", "")
+
+            # Download thumbnail from Immich
+            try:
+                async with http.get(
+                    thumb_url,
+                    headers={"x-api-key": api_key},
+                ) as resp:
+                    if resp.status != 200:
+                        _LOGGER.warning("Failed to download thumbnail for %s", asset_id)
+                        continue
+                    photo_bytes = await resp.read()
+            except aiohttp.ClientError:
+                continue
+
+            # Send to Telegram
+            url = f"{TELEGRAM_API_BASE_URL}{bot_token}/sendPhoto"
+            data = aiohttp.FormData()
+            data.add_field("chat_id", chat_id)
+            data.add_field("photo", photo_bytes, filename=f"{asset_id}.jpg", content_type="image/jpeg")
+            if caption:
+                data.add_field("caption", caption)
+
+            try:
+                async with http.post(url, data=data) as resp:
+                    if resp.status != 200:
+                        result = await resp.json()
+                        _LOGGER.warning("Failed to send photo: %s", result.get("description"))
+            except aiohttp.ClientError as err:
+                _LOGGER.warning("Failed to send photo: %s", err)
+
+
+async def register_commands_with_telegram(bot: TelegramBot) -> bool:
+    """Register enabled commands with Telegram BotFather API."""
+    config = bot.commands_config or {}
+    enabled = config.get("enabled", [])
+    locale = config.get("locale", "en")
+
+    commands = []
+    for cmd in enabled:
+        desc = COMMAND_DESCRIPTIONS.get(cmd, {})
+        commands.append({
+            "command": cmd,
+            "description": desc.get(locale, desc.get("en", cmd)),
+        })
+
+    async with aiohttp.ClientSession() as http:
+        # Set commands for the bot's locale
+        url = f"{TELEGRAM_API_BASE_URL}{bot.token}/setMyCommands"
+        payload: dict[str, Any] = {"commands": commands}
+
+        try:
+            async with http.post(url, json=payload) as resp:
+                result = await resp.json()
+                if result.get("ok"):
+                    _LOGGER.info("Registered %d commands for bot @%s", len(commands), bot.bot_username)
+
+                    # Also register for the other locale
+                    other_locale = "ru" if locale == "en" else "en"
+                    other_commands = []
+                    for cmd in enabled:
+                        desc = COMMAND_DESCRIPTIONS.get(cmd, {})
+                        other_commands.append({
+                            "command": cmd,
+                            "description": desc.get(other_locale, desc.get("en", cmd)),
+                        })
+                    other_payload: dict[str, Any] = {
+                        "commands": other_commands,
+                        "language_code": other_locale,
+                    }
+                    async with http.post(url, json=other_payload) as resp2:
+                        r2 = await resp2.json()
+                        if not r2.get("ok"):
+                            _LOGGER.warning("Failed to register %s commands: %s", other_locale, r2.get("description"))
+
+                    return True
+                _LOGGER.warning("Failed to register commands: %s", result.get("description"))
+                return False
+        except aiohttp.ClientError as err:
+            _LOGGER.error("Failed to register commands: %s", err)
+            return False

packages/server/src/immich_watcher_server/ai/telegram_webhook.py

@@ -1,4 +1,4 @@
-"""Telegram webhook handler for AI bot interactions."""
+"""Telegram webhook handler for AI bot interactions and commands."""
 
 from __future__ import annotations
 
@@ -15,7 +15,8 @@ from immich_watcher_core.telegram.media import TELEGRAM_API_BASE_URL
 from ..auth.dependencies import get_current_user
 from ..config import settings
 from ..database.engine import get_session
-from ..database.models import AlbumTracker, EventLog, ImmichServer, NotificationTarget, User
+from ..database.models import AlbumTracker, EventLog, ImmichServer, NotificationTarget, TelegramBot, User
+from .commands import handle_command, send_media_group
 from .service import chat, is_ai_enabled, summarize_albums
 
 _LOGGER = logging.getLogger(__name__)
@@ -42,13 +43,14 @@ async def telegram_webhook(
         if x_telegram_bot_api_secret_token != settings.telegram_webhook_secret:
             raise HTTPException(status_code=403, detail="Invalid webhook secret")
 
-    # Validate bot_token against stored targets
+    # Find bot by token
+    bot_result = await session.exec(select(TelegramBot).where(TelegramBot.token == bot_token))
+    bot = bot_result.first()
+
+    if not bot:
+        # Fallback: check targets for legacy setups
         result = await session.exec(select(NotificationTarget).where(NotificationTarget.type == "telegram"))
-    valid_token = False
+        valid_token = any(t.config.get("bot_token") == bot_token for t in result.all())
-    for target in result.all():
-        if target.config.get("bot_token") == bot_token:
-            valid_token = True
-            break
         if not valid_token:
             raise HTTPException(status_code=403, detail="Unknown bot token")
 
@@ -68,14 +70,23 @@ async def telegram_webhook(
     if not chat_id or not text:
         return {"ok": True, "skipped": "empty"}
 
-    if text.startswith("/start"):
+    # Try bot commands first (if bot is registered)
-        await _send_reply(
+    if bot and text.startswith("/"):
-            bot_token, chat_id,
+        cmd_response = await handle_command(bot, chat_id, text, session)
-            "Hi! I'm your Immich Watcher AI assistant. Ask me about your photo albums, "
+        if cmd_response is not None:
-            "recent changes, or say 'summary' to get an overview."
+            if isinstance(cmd_response, list):
-        )
+                # Media response — send photos
+                await send_media_group(bot_token, chat_id, cmd_response)
+            else:
+                await _send_reply(bot_token, chat_id, cmd_response)
             return {"ok": True}
 
+    # Fall through to AI chat if enabled
+    if not is_ai_enabled():
+        if text.startswith("/"):
+            return {"ok": True, "skipped": "command_not_handled"}
+        return {"ok": True, "skipped": "ai_disabled"}
+
     # Build context from database
     context = await _build_context(session, chat_id)
 

packages/server/src/immich_watcher_server/api/telegram_bots.py

@@ -9,6 +9,7 @@ import aiohttp
 
 from immich_watcher_core.telegram.media import TELEGRAM_API_BASE_URL
 
+from ..ai.commands import register_commands_with_telegram
 from ..auth.dependencies import get_current_user
 from ..database.engine import get_session
 from ..database.models import TelegramBot, User
@@ -23,6 +24,7 @@ class BotCreate(BaseModel):
 
 class BotUpdate(BaseModel):
     name: str | None = None
+    commands_config: dict | None = None
 
 
 @router.get("")
@@ -69,10 +71,12 @@ async def update_bot(
     user: User = Depends(get_current_user),
     session: AsyncSession = Depends(get_session),
 ):
-    """Update a bot's display name."""
+    """Update a bot's display name and/or commands config."""
     bot = await _get_user_bot(session, bot_id, user.id)
     if body.name is not None:
         bot.name = body.name
+    if body.commands_config is not None:
+        bot.commands_config = body.commands_config
     session.add(bot)
     await session.commit()
     await session.refresh(bot)
@@ -121,6 +125,20 @@ async def list_bot_chats(
     return chats
 
 
+@router.post("/{bot_id}/sync-commands")
+async def sync_commands(
+    bot_id: int,
+    user: User = Depends(get_current_user),
+    session: AsyncSession = Depends(get_session),
+):
+    """Register bot commands with Telegram BotFather API."""
+    bot = await _get_user_bot(session, bot_id, user.id)
+    success = await register_commands_with_telegram(bot)
+    if not success:
+        raise HTTPException(status_code=500, detail="Failed to register commands with Telegram")
+    return {"success": True}
+
+
 # --- Helpers ---
 
 async def _get_me(token: str) -> dict | None:
@@ -171,6 +189,7 @@ def _bot_response(b: TelegramBot) -> dict:
         "bot_username": b.bot_username,
         "bot_id": b.bot_id,
         "token_preview": f"{b.token[:8]}...{b.token[-4:]}" if len(b.token) > 12 else "***",
+        "commands_config": b.commands_config,
         "created_at": b.created_at.isoformat(),
     }
 

packages/server/src/immich_watcher_server/database/models.py

@@ -49,6 +49,20 @@ class TelegramBot(SQLModel, table=True):
     icon: str = Field(default="")  # MDI icon name
     bot_username: str = Field(default="")  # @username from getMe
     bot_id: int = Field(default=0)  # Numeric bot ID from getMe
+    commands_config: dict[str, Any] = Field(
+        default_factory=lambda: {
+            "enabled": [
+                "status", "albums", "events", "summary", "latest",
+                "memory", "random", "search", "find", "person",
+                "place", "favorites", "people", "help",
+            ],
+            "default_count": 5,
+            "response_mode": "media",
+            "rate_limits": {"search": 30, "find": 30, "default": 10},
+            "locale": "en",
+        },
+        sa_column=Column(JSON),
+    )
     created_at: datetime = Field(default_factory=_utcnow)
 
 

plans/phase-10-telegram-commands.md

@@ -1,6 +1,6 @@
 # Phase 10: Telegram Bot Commands
 
-**Status**: Pending
+**Status**: Done
 **Parent**: [primary-plan.md](primary-plan.md)
 
 ---

plans/phase-11-snackbar-notifications.md

@@ -1,6 +1,6 @@
 # Phase 11: Snackbar Notifications
 
-**Status**: Pending
+**Status**: Done
 **Parent**: [primary-plan.md](primary-plan.md)
 
 ---

plans/primary-plan.md

@@ -222,7 +222,14 @@ async def _execute_telegram_notification(self, ...):
 - Natural language tracker configuration via Telegram chat
 - **Subplan**: `plans/phase-6-claude-ai-bot.md`
 
-### Phase 11: Snackbar Notifications `[ ]`
+### Phase 10: Telegram Bot Commands `[x]`
+- Bot command handler for /status, /albums, /events, /search, /find, etc.
+- Commands config per bot (enabled commands, count, locale, rate limits)
+- Auto-register commands with Telegram BotFather API
+- Frontend UI for command configuration
+- **Subplan**: `plans/phase-10-telegram-commands.md`
+
+### Phase 11: Snackbar Notifications `[x]`
 - Unified toast/snackbar system for action feedback (success, error, info, warning)
 - Replace all `alert()` calls with typed snackbars
 - Auto-dismiss, stacking, accessible, animated