@iola_adm/iola-cli 0.2.5 → 0.2.7

package/src/cli.js

@@ -39,6 +39,7 @@ const PROJECT_CONFIG_FILE = path.join(PROJECT_IOLA_DIR, "config.json");
 const LOCAL_CONFIG_FILE = path.join(PROJECT_IOLA_DIR, "local.json");
 const BROWSER_RUNTIME_DIR = path.join(CONFIG_DIR, "browser-runtime");
 const BROWSER_RUNTIME_PACKAGE = path.join(BROWSER_RUNTIME_DIR, "node_modules", "playwright", "package.json");
+const CLOUD_DEFAULT_REMOTE_DIR = "/IOLA";
 const INDEXABLE_EXTENSIONS = /\.(md|txt|csv|json|html|docx|xlsx|pptx|pdf)$/i;
 const LOCAL_TOOLS = ["search_data", "search_entities", "resolve_entity_field", "get_card", "export_report", "file_read", "browser_open", "get_current_date"];
 const LEGACY_LOCAL_TOOLS = ["search_local", "export_data", "run_report", "save_view"];
@@ -228,7 +229,14 @@ const DEFAULT_AI_CONFIG = {
     suggestions: true,
   },
   skills: {
-    enabled: ["education", "open-data", "reports", "local-model", "local-files", "browser-agent"],
+    enabled: ["education", "open-data", "geo", "personal-docs", "reports", "local-model", "local-files", "browser-agent"],
+  },
+  cloud: {
+    activeProvider: "",
+    providers: {
+      "yandex-disk": { root: CLOUD_DEFAULT_REMOTE_DIR },
+      "mailru-cloud": { root: CLOUD_DEFAULT_REMOTE_DIR },
+    },
   },
   daemon: {
     host: "127.0.0.1",
@@ -314,6 +322,7 @@ const SLASH_COMMANDS = [
   { command: "/permissions", description: "разрешения" },
   { command: "/tools", description: "tools и toolsets" },
   { command: "/files status", description: "локальные файловые операции" },
+  { command: "/cloud status", description: "облачные диски" },
   { command: "/archive doctor", description: "архиватор" },
   { command: "/changes list", description: "подготовленные изменения" },
   { command: "/index status", description: "индекс документов" },
@@ -389,6 +398,7 @@ const COMMANDS = new Map([
   ["skills", handleSkills],
   ["tools", handleTools],
   ["files", handleFiles],
+  ["cloud", handleCloud],
   ["archive", handleArchive],
   ["changes", handleChanges],
   ["import", handleImport],
@@ -537,6 +547,7 @@ async function showHelp() {
   iola agent                   интерактивный режим
   iola ai setup                настройка AI-профиля
   iola browser status          браузерный runtime
+  iola cloud status            облачные диски
   iola mcp status              MCP-подключение
   iola doctor                  диагностика
   iola wiki                    документация
@@ -576,6 +587,7 @@ Usage:
   iola skills list|show|paths|enable|disable|bundles|bundle|doctor
   iola tools list|toolsets|enable|disable|profile
   iola files status|mode|approvals|tree|read|search|write|patch
+  iola cloud setup|status|ls|find|upload|download|share|save|backup
   iola archive doctor|list|test|extract|create|index
   iola changes list|show|apply|discard
   iola import file|folder
@@ -2879,6 +2891,467 @@ async function handleFiles(args) {
   throw new Error("Команды files: status, mode MODE, approvals POLICY, tree [PATH], read FILE, search TEXT, write FILE --text TEXT, patch FILE --search OLD --replace NEW.");
 }
 
+async function handleCloud(args) {
+  const [action = "status", target, maybeRemote, ...rest] = args;
+  const options = parseOptions(rest);
+
+  if (action === "setup") {
+    await setupCloudProvider(target, options);
+    return;
+  }
+
+  if (action === "use") {
+    const provider = normalizeCloudProvider(target);
+    await requireCloudCredentials(provider);
+    const config = await loadConfig();
+    await saveConfig({ cloud: { ...(config.cloud || {}), activeProvider: provider } });
+    console.log(`Активный облачный диск: ${provider}`);
+    return;
+  }
+
+  if (action === "status") {
+    await printCloudStatus({ check: Boolean(options.check) });
+    return;
+  }
+
+  if (action === "doctor") {
+    await printCloudStatus({ check: true });
+    return;
+  }
+
+  if (action === "delete") {
+    const provider = normalizeCloudProvider(target);
+    const secrets = await loadSecrets();
+    delete secrets.cloud?.[provider];
+    if (secrets.cloud && Object.keys(secrets.cloud).length === 0) delete secrets.cloud;
+    await saveSecrets(secrets);
+    const config = await loadConfig();
+    if (config.cloud?.activeProvider === provider) {
+      await saveConfig({ cloud: { ...(config.cloud || {}), activeProvider: "" } });
+    }
+    console.log(`Локальные секреты облака удалены: ${provider}`);
+    return;
+  }
+
+  if (action === "ls" || action === "list") {
+    const provider = await getCloudProvider(options.provider);
+    const rows = await cloudList(provider, target || cloudRootForProvider(provider));
+    printTable(rows, [["type", "Тип"], ["name", "Имя"], ["path", "Путь"], ["size", "Размер"]]);
+    return;
+  }
+
+  if (action === "find" || action === "search") {
+    if (!target) throw new Error('Пример: iola cloud find "справка" --path /IOLA');
+    const provider = await getCloudProvider(options.provider);
+    const rows = await cloudFind(provider, target, { path: options.path || cloudRootForProvider(provider), limit: Number(options.limit || 50) });
+    printTable(rows, [["type", "Тип"], ["name", "Имя"], ["path", "Путь"], ["size", "Размер"]]);
+    return;
+  }
+
+  if (action === "upload") {
+    if (!target) throw new Error('Пример: iola cloud upload report.md /IOLA/reports/report.md');
+    const provider = await getCloudProvider(options.provider);
+    const remotePath = maybeRemote || `${cloudRootForProvider(provider)}/${path.basename(target)}`;
+    const result = await cloudUpload(provider, target, remotePath, { overwrite: options.overwrite !== false });
+    printKeyValue(result);
+    return;
+  }
+
+  if (action === "download") {
+    if (!target) throw new Error('Пример: iola cloud download /IOLA/report.md ./report.md');
+    const provider = await getCloudProvider(options.provider);
+    const outputPath = maybeRemote || path.basename(target);
+    const result = await cloudDownload(provider, target, outputPath);
+    printKeyValue(result);
+    return;
+  }
+
+  if (action === "share") {
+    if (!target) throw new Error('Пример: iola cloud share /IOLA/report.md');
+    const provider = await getCloudProvider(options.provider);
+    const result = await cloudShare(provider, target);
+    printKeyValue(result);
+    return;
+  }
+
+  if (action === "save") {
+    const provider = await getCloudProvider(options.provider);
+    const text = options.text ?? [target, maybeRemote, ...rest].filter(Boolean).join(" ");
+    if (!text) throw new Error('Пример: iola cloud save --text "Текст" --path /IOLA/notes/note.txt');
+    const remotePath = options.path || `${cloudRootForProvider(provider)}/notes/iola-${timestampForFile()}.txt`;
+    const tempPath = path.join(CONFIG_DIR, `cloud-save-${Date.now()}.txt`);
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(tempPath, text, "utf8");
+    try {
+      const result = await cloudUpload(provider, tempPath, remotePath, { overwrite: true });
+      printKeyValue(result);
+    } finally {
+      await rm(tempPath, { force: true }).catch(() => {});
+    }
+    return;
+  }
+
+  if (action === "backup") {
+    const provider = await getCloudProvider(options.provider);
+    const result = await cloudBackup(provider);
+    printKeyValue(result);
+    return;
+  }
+
+  throw new Error(`Команды cloud:
+  iola cloud setup yandex-disk
+  iola cloud setup mailru-cloud
+  iola cloud status|doctor
+  iola cloud use yandex-disk
+  iola cloud ls /IOLA
+  iola cloud find "справка" --path /IOLA
+  iola cloud upload local.txt /IOLA/local.txt
+  iola cloud download /IOLA/local.txt ./local.txt
+  iola cloud share /IOLA/local.txt
+  iola cloud save --text "Текст" --path /IOLA/notes/note.txt
+  iola cloud backup`);
+}
+
+async function setupCloudProvider(providerValue, options = {}) {
+  const provider = normalizeCloudProvider(providerValue);
+  if (!process.stdin.isTTY) throw new Error("Для настройки облака запустите команду в интерактивном терминале.");
+  const secrets = await loadSecrets();
+  secrets.cloud = secrets.cloud || {};
+
+  if (provider === "yandex-disk") {
+    console.log("Яндекс Диск использует OAuth-токен пользователя с доступом к Диску.");
+    console.log("Инструкция: https://github.com/adm-iola/iola-cli/wiki/Облачные-диски");
+    const token = (await askText("Введите OAuth-токен Яндекс Диска: ")).trim();
+    if (!token) throw new Error("Токен пустой, сохранение отменено.");
+    secrets.cloud[provider] = { token };
+  } else if (provider === "mailru-cloud") {
+    console.log("Облако Mail.ru подключается через WebDAV и пароль внешнего приложения.");
+    console.log("Инструкция: https://github.com/adm-iola/iola-cli/wiki/Облачные-диски");
+    const username = (await askText("Введите email Mail.ru: ")).trim();
+    const password = (await askText("Введите пароль внешнего приложения/WebDAV: ")).trim();
+    if (!username || !password) throw new Error("Email или пароль пустой, сохранение отменено.");
+    secrets.cloud[provider] = { username, password, baseUrl: options.baseUrl || "https://webdav.cloud.mail.ru" };
+  }
+
+  await saveSecrets(secrets);
+  const config = await loadConfig();
+  await saveConfig({ cloud: { ...(config.cloud || {}), activeProvider: provider } });
+  console.log(`Облачный диск сохранен и выбран: ${provider}`);
+  await printCloudStatus({ check: true });
+}
+
+async function printCloudStatus(options = {}) {
+  const config = await loadConfig();
+  const secrets = await loadSecrets();
+  const rows = ["yandex-disk", "mailru-cloud"].map((provider) => ({
+    provider,
+    active: config.cloud?.activeProvider === provider ? "yes" : "no",
+    configured: secrets.cloud?.[provider] ? "yes" : "no",
+    root: cloudRootForProvider(provider, config),
+  }));
+  printTable(rows, [["provider", "Провайдер"], ["active", "Активен"], ["configured", "Настроен"], ["root", "Папка"]]);
+  if (options.check) {
+    for (const row of rows.filter((item) => item.configured === "yes")) {
+      try {
+        const listed = await cloudList(row.provider, cloudRootForProvider(row.provider), { allowMissingRoot: true });
+        console.log(`${row.provider}: ok (${listed.length} объектов в корневой папке IOLA или папка доступна)`);
+      } catch (error) {
+        console.log(`${row.provider}: error - ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+}
+
+function normalizeCloudProvider(value) {
+  const text = String(value || "").toLocaleLowerCase("ru-RU").trim();
+  if (!text || text === "yandex" || text === "yandex-disk" || text === "яндекс" || text === "яндекс-диск") return "yandex-disk";
+  if (text === "mailru" || text === "mailru-cloud" || text === "mail" || text === "mail.ru" || text === "облако-mail") return "mailru-cloud";
+  throw new Error("Поддерживаются облака: yandex-disk, mailru-cloud.");
+}
+
+async function getCloudProvider(value) {
+  if (value) return normalizeCloudProvider(value);
+  const config = await loadConfig();
+  const provider = normalizeCloudProvider(config.cloud?.activeProvider || "yandex-disk");
+  await requireCloudCredentials(provider);
+  return provider;
+}
+
+async function requireCloudCredentials(provider) {
+  const secrets = await loadSecrets();
+  const credentials = secrets.cloud?.[provider];
+  if (!credentials) throw new Error(`Облачный диск не настроен: ${provider}. Запустите: iola cloud setup ${provider}`);
+  return credentials;
+}
+
+function cloudRootForProvider(provider, config = null) {
+  const loaded = config || readConfigLayerSync(CONFIG_FILE) || {};
+  return loaded.cloud?.providers?.[provider]?.root || DEFAULT_AI_CONFIG.cloud.providers[provider]?.root || CLOUD_DEFAULT_REMOTE_DIR;
+}
+
+async function cloudList(provider, remotePath, options = {}) {
+  if (provider === "yandex-disk") return yandexDiskList(remotePath, options);
+  if (provider === "mailru-cloud") return mailruCloudList(remotePath, options);
+  throw new Error(`Провайдер не поддерживается: ${provider}`);
+}
+
+async function cloudUpload(provider, localPath, remotePath, options = {}) {
+  if (provider === "yandex-disk") return yandexDiskUpload(localPath, remotePath, options);
+  if (provider === "mailru-cloud") return mailruCloudUpload(localPath, remotePath, options);
+  throw new Error(`Провайдер не поддерживается: ${provider}`);
+}
+
+async function cloudDownload(provider, remotePath, outputPath) {
+  if (provider === "yandex-disk") return yandexDiskDownload(remotePath, outputPath);
+  if (provider === "mailru-cloud") return mailruCloudDownload(remotePath, outputPath);
+  throw new Error(`Провайдер не поддерживается: ${provider}`);
+}
+
+async function cloudFind(provider, query, options = {}) {
+  if (provider === "yandex-disk") return yandexDiskFind(query, options);
+  if (provider === "mailru-cloud") {
+    const rows = await mailruCloudList(options.path || CLOUD_DEFAULT_REMOTE_DIR);
+    return rows.filter((row) => normalizeGeoText(`${row.name} ${row.path}`).includes(normalizeGeoText(query))).slice(0, Number(options.limit || 50));
+  }
+  throw new Error(`Провайдер не поддерживается: ${provider}`);
+}
+
+async function cloudShare(provider, remotePath) {
+  if (provider === "yandex-disk") return yandexDiskShare(remotePath);
+  throw new Error("Публичные ссылки через CLI сейчас поддерживаются только для Яндекс Диска.");
+}
+
+async function yandexDiskRequest(method, apiPath, options = {}) {
+  const credentials = await requireCloudCredentials("yandex-disk");
+  const url = new URL(`https://cloud-api.yandex.net/v1/disk${apiPath}`);
+  for (const [key, value] of Object.entries(options.query || {})) {
+    if (value !== undefined && value !== "") url.searchParams.set(key, String(value));
+  }
+  const response = await fetch(url, {
+    method,
+    headers: {
+      Authorization: `OAuth ${credentials.token}`,
+      ...(options.headers || {}),
+    },
+    body: options.body,
+    signal: AbortSignal.timeout(Number(options.timeout || 30000)),
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Yandex Disk request failed: ${response.status} ${response.statusText}\n${sanitizeSecretFromText(text, credentials.token)}`);
+  }
+  if (response.status === 204) return {};
+  const text = await response.text();
+  if (!text.trim()) return {};
+  return JSON.parse(text);
+}
+
+async function yandexDiskList(remotePath, options = {}) {
+  await ensureYandexDiskDir(remotePath, { allowExisting: true, allowMissingRoot: Boolean(options.allowMissingRoot) });
+  const payload = await yandexDiskRequest("GET", "/resources", { query: { path: normalizeYandexDiskPath(remotePath), limit: 100 } });
+  const items = payload._embedded?.items || [];
+  return items.map((item) => ({
+    type: item.type === "dir" ? "dir" : "file",
+    name: item.name || path.basename(item.path || ""),
+    path: denormalizeYandexDiskPath(item.path || ""),
+    size: item.size || "-",
+  }));
+}
+
+async function yandexDiskFind(query, options = {}) {
+  const payload = await yandexDiskRequest("GET", "/resources/files", { query: { limit: Math.max(100, Number(options.limit || 50) * 5), fields: "items.name,items.path,items.size,items.type" } });
+  const needle = normalizeGeoText(query);
+  return (payload.items || [])
+    .map((item) => ({
+      type: item.type === "dir" ? "dir" : "file",
+      name: item.name || path.basename(item.path || ""),
+      path: denormalizeYandexDiskPath(item.path || ""),
+      size: item.size || "-",
+    }))
+    .filter((item) => normalizeGeoText(`${item.name} ${item.path}`).includes(needle))
+    .slice(0, Number(options.limit || 50));
+}
+
+async function yandexDiskUpload(localPath, remotePath, options = {}) {
+  const resolved = path.resolve(localPath);
+  const info = await stat(resolved);
+  if (!info.isFile()) throw new Error(`Это не файл: ${localPath}`);
+  await ensureYandexDiskDir(path.dirname(remotePath), { allowExisting: true });
+  const upload = await yandexDiskRequest("GET", "/resources/upload", { query: { path: normalizeYandexDiskPath(remotePath), overwrite: options.overwrite !== false } });
+  const bytes = await readFile(resolved);
+  const response = await fetch(upload.href, { method: upload.method || "PUT", body: bytes, signal: AbortSignal.timeout(120000) });
+  if (!response.ok) throw new Error(`Yandex Disk upload failed: ${response.status} ${response.statusText}`);
+  return { provider: "yandex-disk", local: resolved, remote: remotePath, size: info.size };
+}
+
+async function yandexDiskDownload(remotePath, outputPath) {
+  const download = await yandexDiskRequest("GET", "/resources/download", { query: { path: normalizeYandexDiskPath(remotePath) } });
+  const response = await fetch(download.href, { signal: AbortSignal.timeout(120000) });
+  if (!response.ok) throw new Error(`Yandex Disk download failed: ${response.status} ${response.statusText}`);
+  const buffer = Buffer.from(await response.arrayBuffer());
+  const resolved = path.resolve(outputPath);
+  await mkdir(path.dirname(resolved), { recursive: true });
+  await writeFile(resolved, buffer);
+  return { provider: "yandex-disk", remote: remotePath, local: resolved, size: buffer.length };
+}
+
+async function yandexDiskShare(remotePath) {
+  await yandexDiskRequest("PUT", "/resources/publish", { query: { path: normalizeYandexDiskPath(remotePath) } });
+  const payload = await yandexDiskRequest("GET", "/resources", { query: { path: normalizeYandexDiskPath(remotePath), fields: "name,path,public_url" } });
+  return { provider: "yandex-disk", remote: remotePath, publicUrl: payload.public_url || "-" };
+}
+
+async function ensureYandexDiskDir(remotePath, options = {}) {
+  const normalized = normalizeYandexDiskPath(remotePath || CLOUD_DEFAULT_REMOTE_DIR);
+  const plain = denormalizeYandexDiskPath(normalized);
+  const parts = plain.split("/").filter(Boolean);
+  let current = "";
+  for (const part of parts) {
+    current += `/${part}`;
+    try {
+      await yandexDiskRequest("PUT", "/resources", { query: { path: current } });
+    } catch (error) {
+      const message = String(error?.message || "");
+      if (/409|DiskPathPointsToExistentDirectoryError|уже существует/iu.test(message)) continue;
+      if (options.allowMissingRoot && /404/iu.test(message)) continue;
+      throw error;
+    }
+  }
+}
+
+function normalizeYandexDiskPath(remotePath) {
+  const text = String(remotePath || CLOUD_DEFAULT_REMOTE_DIR).trim().replace(/\\/g, "/");
+  if (text.startsWith("disk:") || text.startsWith("app:")) return text;
+  return text.startsWith("/") ? text : `/${text}`;
+}
+
+function denormalizeYandexDiskPath(remotePath) {
+  return String(remotePath || "").replace(/^disk:/u, "").replace(/^app:/u, "") || "/";
+}
+
+async function mailruCloudRequest(method, remotePath, options = {}) {
+  const credentials = await requireCloudCredentials("mailru-cloud");
+  const baseUrl = String(credentials.baseUrl || "https://webdav.cloud.mail.ru").replace(/\/+$/u, "");
+  const url = `${baseUrl}${encodeWebDavPath(remotePath)}`;
+  const response = await fetch(url, {
+    method,
+    headers: {
+      Authorization: `Basic ${Buffer.from(`${credentials.username}:${credentials.password}`).toString("base64")}`,
+      ...(options.headers || {}),
+    },
+    body: options.body,
+    signal: AbortSignal.timeout(Number(options.timeout || 30000)),
+  });
+  if (!response.ok && !(method === "MKCOL" && response.status === 405)) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Mail.ru Cloud WebDAV request failed: ${response.status} ${response.statusText}\n${sanitizeSecretFromText(text, credentials.password)}`);
+  }
+  return response;
+}
+
+async function mailruCloudList(remotePath, options = {}) {
+  await ensureMailruCloudDir(remotePath, { allowMissingRoot: Boolean(options.allowMissingRoot) });
+  const response = await mailruCloudRequest("PROPFIND", remotePath, { headers: { Depth: "1" } });
+  const text = await response.text();
+  return parseWebDavList(text, remotePath);
+}
+
+async function mailruCloudUpload(localPath, remotePath) {
+  const resolved = path.resolve(localPath);
+  const info = await stat(resolved);
+  if (!info.isFile()) throw new Error(`Это не файл: ${localPath}`);
+  await ensureMailruCloudDir(path.dirname(remotePath));
+  const bytes = await readFile(resolved);
+  await mailruCloudRequest("PUT", remotePath, { body: bytes, timeout: 120000 });
+  return { provider: "mailru-cloud", local: resolved, remote: remotePath, size: info.size };
+}
+
+async function mailruCloudDownload(remotePath, outputPath) {
+  const response = await mailruCloudRequest("GET", remotePath, { timeout: 120000 });
+  const buffer = Buffer.from(await response.arrayBuffer());
+  const resolved = path.resolve(outputPath);
+  await mkdir(path.dirname(resolved), { recursive: true });
+  await writeFile(resolved, buffer);
+  return { provider: "mailru-cloud", remote: remotePath, local: resolved, size: buffer.length };
+}
+
+async function ensureMailruCloudDir(remotePath, options = {}) {
+  const parts = String(remotePath || CLOUD_DEFAULT_REMOTE_DIR).replace(/\\/g, "/").split("/").filter(Boolean);
+  let current = "";
+  for (const part of parts) {
+    current += `/${part}`;
+    try {
+      await mailruCloudRequest("MKCOL", current);
+    } catch (error) {
+      const message = String(error?.message || "");
+      if (/405|409/iu.test(message)) continue;
+      if (options.allowMissingRoot && /404/iu.test(message)) continue;
+      throw error;
+    }
+  }
+}
+
+function encodeWebDavPath(remotePath) {
+  const normalized = String(remotePath || "/").replace(/\\/g, "/");
+  const segments = normalized.split("/").filter(Boolean).map(encodeURIComponent);
+  return `/${segments.join("/")}${normalized.endsWith("/") ? "/" : ""}`;
+}
+
+function parseWebDavList(xml, basePath) {
+  const responses = String(xml || "").split(/<[^:>]*:?response[^>]*>/iu).slice(1);
+  const rows = [];
+  for (const response of responses) {
+    const href = decodeXml(stripXmlTags(response.match(/<[^:>]*:?href[^>]*>([\s\S]*?)<\/[^:>]*:?href>/iu)?.[1] || ""));
+    const name = decodeXml(stripXmlTags(response.match(/<[^:>]*:?displayname[^>]*>([\s\S]*?)<\/[^:>]*:?displayname>/iu)?.[1] || "")) || path.basename(href);
+    const size = decodeXml(stripXmlTags(response.match(/<[^:>]*:?getcontentlength[^>]*>([\s\S]*?)<\/[^:>]*:?getcontentlength>/iu)?.[1] || ""));
+    const isDir = /<[^:>]*:?collection\s*\/?>/iu.test(response);
+    const normalizedPath = decodeURIComponent(href || "");
+    if (normalizeGeoText(normalizedPath).replace(/\s+/g, "") === normalizeGeoText(basePath).replace(/\s+/g, "")) continue;
+    rows.push({ type: isDir ? "dir" : "file", name, path: normalizedPath, size: size || "-" });
+  }
+  return rows;
+}
+
+function stripXmlTags(value) {
+  return String(value || "").replace(/<[^>]+>/g, "").trim();
+}
+
+function decodeXml(value) {
+  return String(value || "")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, "\"")
+    .replace(/&#39;/g, "'");
+}
+
+async function cloudBackup(provider) {
+  const config = await loadConfig();
+  const payload = {
+    createdAt: new Date().toISOString(),
+    version: getPackageVersion(),
+    note: "Секреты, API-ключи и токены не включены в резервную копию.",
+    config: {
+      api: config.api,
+      ai: { activeProfile: config.ai?.activeProfile, provider: config.ai?.provider, model: config.ai?.model, profiles: config.ai?.profiles },
+      files: config.files,
+      skills: config.skills,
+      cloud: config.cloud,
+    },
+  };
+  const tempPath = path.join(CONFIG_DIR, `iola-backup-${timestampForFile()}.json`);
+  await writeFile(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  try {
+    return cloudUpload(provider, tempPath, `${cloudRootForProvider(provider)}/backup/${path.basename(tempPath)}`, { overwrite: true });
+  } finally {
+    await rm(tempPath, { force: true }).catch(() => {});
+  }
+}
+
+function timestampForFile() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
 async function handleArchive(args) {
   const [action = "doctor", target, ...rest] = args;
   const options = parseOptions(rest);
@@ -5343,6 +5816,36 @@ async function handleGeo(args) {
     return;
   }
 
+  if (command === "nearby") {
+    await geoNearby([subcommand, ...rest].filter(Boolean));
+    return;
+  }
+
+  if (command === "distance") {
+    await geoDistance([subcommand, ...rest].filter(Boolean));
+    return;
+  }
+
+  if (command === "map-link") {
+    await geoMapLink([subcommand, ...rest].filter(Boolean));
+    return;
+  }
+
+  if (command === "resolve") {
+    await geoResolve([subcommand, ...rest].filter(Boolean));
+    return;
+  }
+
+  if (command === "route-context") {
+    await geoRouteContext([subcommand, ...rest].filter(Boolean));
+    return;
+  }
+
+  if (command === "services") {
+    await geoServices([subcommand, ...rest].filter(Boolean));
+    return;
+  }
+
   if (command === "doctor" || command === "status") {
     await printGeoKeyStatus({ check: command === "doctor" });
     return;
@@ -5353,7 +5856,13 @@ async function handleGeo(args) {
   iola geo key status
   iola geo key doctor
   iola geo key delete yandex
-  iola geo geocode "Йошкар-Ола, ул. Петрова, 15"`);
+  iola geo geocode "Йошкар-Ола, ул. Петрова, 15"
+  iola geo nearby "Йошкар-Ола, ул. Петрова, 15" --dataset all --limit 5
+  iola geo distance --from "Йошкар-Ола, ул. Петрова, 15" --to "школа 7"
+  iola geo map-link "школа 7"
+  iola geo resolve "садик золотой петушок"
+  iola geo route-context "школа 7"
+  iola geo services "Йошкар-Ола, ул. Петрова, 15"`);
 }
 
 async function handleGeoKey(args) {
@@ -5433,6 +5942,56 @@ async function geoGeocode(args) {
   printKeyValue(result);
 }
 
+async function geoNearby(args) {
+  const options = parseOptions(args);
+  const query = options._.join(" ").trim();
+  if (!query) throw new Error('Адрес обязателен. Пример: iola geo nearby "Йошкар-Ола, ул. Петрова, 15" --dataset schools');
+  const answer = await buildNearbyAnswer(query, {
+    dataset: normalizeGeoDataset(options.dataset || inferGeoDataset(query)),
+    limit: Number(options.limit || 5),
+    radius: Number(options.radius || 0),
+  });
+  console.log(answer);
+}
+
+async function geoDistance(args) {
+  const options = parseOptions(args);
+  const from = options.from || options.address || options._.join(" ").split(/\s+(?:до|и|->)\s+/iu)[0]?.trim();
+  const to = options.to || options._.join(" ").split(/\s+(?:до|и|->)\s+/iu)[1]?.trim();
+  if (!from || !to) throw new Error('Нужны две точки. Пример: iola geo distance --from "Петрова 15" --to "школа 7"');
+  const answer = await buildDistanceAnswer(from, to);
+  console.log(answer);
+}
+
+async function geoMapLink(args) {
+  const query = args.join(" ").trim();
+  if (!query) throw new Error('Объект или адрес обязателен. Пример: iola geo map-link "школа 7"');
+  const answer = await buildMapLinkAnswer(query);
+  console.log(answer);
+}
+
+async function geoResolve(args) {
+  const query = args.join(" ").trim();
+  if (!query) throw new Error('Место или объект обязателен. Пример: iola geo resolve "садик золотой петушок"');
+  const answer = await buildPlaceResolverAnswer(query);
+  console.log(answer);
+}
+
+async function geoRouteContext(args) {
+  const query = args.join(" ").trim();
+  if (!query) throw new Error('Объект или адрес обязателен. Пример: iola geo route-context "школа 7"');
+  const answer = await buildRouteContextAnswer(query);
+  console.log(answer);
+}
+
+async function geoServices(args) {
+  const options = parseOptions(args);
+  const query = options._.join(" ").trim();
+  if (!query) throw new Error('Адрес обязателен. Пример: iola geo services "Йошкар-Ола, ул. Петрова, 15"');
+  const answer = await buildAddressToServicesAnswer(query, { limit: Number(options.limit || 3) });
+  console.log(answer);
+}
+
 async function checkYandexGeocoderKey(options = {}) {
   try {
     const result = await callYandexGeocoder("Йошкар-Ола");
@@ -5462,12 +6021,7 @@ async function callYandexGeocoder(query) {
   url.searchParams.set("lang", "ru_RU");
   url.searchParams.set("results", "1");
 
-  let response;
-  try {
-    response = await fetch(url, { signal: AbortSignal.timeout(15000) });
-  } catch (error) {
-    throw new Error(formatProviderFetchError("Yandex Geocoder", error));
-  }
+  const response = await fetchYandexGeocoderWithRetry(url);
 
   if (!response.ok) {
     const text = await response.text();
@@ -5492,6 +6046,401 @@ async function callYandexGeocoder(query) {
   };
 }
 
+async function fetchYandexGeocoderWithRetry(url) {
+  let lastError = null;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      const response = await fetch(url, { signal: AbortSignal.timeout(15000) });
+      if (response.status !== 429 || attempt === 2) return response;
+      await sleep(700 * (attempt + 1));
+    } catch (error) {
+      lastError = error;
+      if (attempt === 2) break;
+      await sleep(500 * (attempt + 1));
+    }
+  }
+  throw new Error(formatProviderFetchError("Yandex Geocoder", lastError));
+}
+
+const geoMemoryCache = new Map();
+
+async function buildGeoDirectAnswer(question) {
+  const normalized = String(question || "").toLocaleLowerCase("ru-RU");
+  if (!isGeoQuestion(normalized)) return "";
+  const place = detectEducationPlace(question);
+  if (place && !place.supported && /(школ|сош|лице|гимнази|сад|детсад|детск\w*\s+сад|садик)/iu.test(normalized)) {
+    return formatUnsupportedEducationGeoPlace(place);
+  }
+
+  try {
+    if (/(расстояни|как далеко|далеко ли|ближе)/iu.test(normalized)) {
+      const pair = extractDistancePair(question);
+      if (pair.from && pair.to) return buildDistanceAnswer(pair.from, pair.to);
+    }
+
+    if (/(карт[аеу]|ссылк.*карт|открыть.*карт)/iu.test(normalized)) {
+      const query = cleanupGeoObjectQuery(question);
+      if (query) return buildMapLinkAnswer(query);
+    }
+
+    if (/(где находится|как пройти|как добраться|что рядом|ориентир)/iu.test(normalized)) {
+      const query = cleanupGeoObjectQuery(question);
+      if (query) return buildRouteContextAnswer(query);
+    }
+
+    if (/(мой адрес|живу|по адресу)/iu.test(normalized)) {
+      const address = extractAddressForNearby(question);
+      if (address) return buildAddressToServicesAnswer(address, { limit: 3 });
+    }
+
+    if (/(рядом|поблизости|ближайш|ближе|около|возле)/iu.test(normalized)) {
+      const address = extractAddressForNearby(question);
+      if (address) return buildNearbyAnswer(address, { dataset: normalizeGeoDataset(inferGeoDataset(question)), limit: 5 });
+    }
+
+    if (/(уточни место|какой населенный пункт|какой район|фильтр.*район|фильтр.*населен|не путай.*населен)/iu.test(normalized)) {
+      const query = cleanupGeoObjectQuery(question);
+      if (query) return buildPlaceResolverAnswer(query);
+    }
+  } catch (error) {
+    if (/Yandex Geocoder API key не найден/iu.test(String(error?.message || ""))) return "";
+    return `Не смог выполнить geo-запрос: ${error instanceof Error ? error.message : String(error)}`;
+  }
+
+  return "";
+}
+
+function formatUnsupportedEducationGeoPlace(place) {
+  return `В текущих открытых данных iola-cli есть данные городского округа Йошкар-Ола. Данных по ${place.locative || place.label} в подключенных слоях нет, поэтому не могу надежно ответить по этому объекту.`;
+}
+
+function isGeoQuestion(normalized) {
+  return /(рядом|поблизости|ближайш|ближе|расстояни|как далеко|карт[аеу]|где находится|как пройти|как добраться|мой адрес|живу|по адресу|ориентир|уточни место|какой населенный пункт|какой район|фильтр.*район|фильтр.*населен)/iu.test(normalized);
+}
+
+async function buildNearbyAnswer(address, options = {}) {
+  const origin = await resolveGeoPoint(address);
+  const dataset = normalizeGeoDataset(options.dataset || "all");
+  const limit = Math.max(1, Number(options.limit || 5));
+  const radius = Number(options.radius || 0);
+  const candidates = await getGeoCandidates(dataset);
+  const ranked = (await asyncMapLimit(candidates, 6, async (item) => {
+    const point = item.address
+      ? await geocodeCached(normalizeAddressForGeocoder(item.address)).catch(() => null)
+      : await resolveGeoPoint(item.name).catch(() => null);
+    if (!point?.lat || !point?.lon) return null;
+    const distanceMeters = haversineMeters(origin, point);
+    return { ...item, point, distanceMeters };
+  })).filter(Boolean)
+    .filter((item) => !radius || item.distanceMeters <= radius)
+    .sort((a, b) => a.distanceMeters - b.distanceMeters)
+    .slice(0, limit);
+
+  if (ranked.length === 0) return `Рядом с адресом "${address}" не нашел объектов в подключенных слоях.`;
+
+  return [
+    `Ближайшие объекты к адресу: ${origin.address || address}`,
+    ...ranked.map((item, index) => `${index + 1}. ${item.name} — ${formatDistance(item.distanceMeters)}${item.address ? `\n   Адрес: ${item.address}` : ""}${item.inn ? `\n   ИНН: ${item.inn}` : ""}${item.point.map ? `\n   Карта: ${item.point.map}` : ""}`),
+    `Источник: Yandex Geocoder + слои ${dataset === "all" ? "schools, kindergartens" : dataset}.`,
+  ].join("\n");
+}
+
+async function buildDistanceAnswer(fromQuery, toQuery) {
+  const from = await resolveGeoPoint(fromQuery);
+  const to = await resolveGeoPoint(toQuery);
+  const distance = haversineMeters(from, to);
+  return [
+    `Расстояние по прямой: ${formatDistance(distance)}.`,
+    `От: ${from.name || from.address || fromQuery}${from.address && from.address !== from.name ? ` (${from.address})` : ""}`,
+    `До: ${to.name || to.address || toQuery}${to.address && to.address !== to.name ? ` (${to.address})` : ""}`,
+    to.map ? `Карта точки назначения: ${to.map}` : "",
+    "Это расстояние по координатам, не маршрут по дорогам.",
+  ].filter(Boolean).join("\n");
+}
+
+async function buildMapLinkAnswer(query) {
+  const point = await resolveGeoPoint(query);
+  return [
+    point.name || query,
+    point.address ? `Адрес: ${point.address}` : "",
+    point.coordinates ? `Координаты: ${point.coordinates}` : "",
+    point.map ? `Карта: ${point.map}` : "",
+  ].filter(Boolean).join("\n");
+}
+
+async function buildPlaceResolverAnswer(query) {
+  const match = await resolveGeoEntity(query).catch(() => null);
+  if (match) {
+    return [
+      `Нашел объект: ${match.name}`,
+      match.address ? `Адрес: ${match.address}` : "",
+      match.inn ? `ИНН: ${match.inn}` : "",
+      match.layer ? `Слой: ${match.layer}` : "",
+      match.map ? `Карта: ${match.map}` : "",
+    ].filter(Boolean).join("\n");
+  }
+  const point = await callYandexGeocoder(query);
+  if (!point) return `Не смог уточнить место: ${query}`;
+  return [
+    `Уточнил место через геокодер: ${point.name || query}`,
+    point.address ? `Адрес: ${point.address}` : "",
+    point.precision ? `Точность: ${point.precision}` : "",
+    point.coordinates ? `Координаты: ${point.coordinates}` : "",
+    point.map ? `Карта: ${point.map}` : "",
+  ].filter(Boolean).join("\n");
+}
+
+async function buildRouteContextAnswer(query) {
+  const point = await resolveGeoPoint(query);
+  const nearby = await buildNearbyAnswer(point.address || query, { dataset: "all", limit: 3 });
+  return [
+    `${point.name || query}`,
+    point.address ? `Адрес: ${point.address}` : "",
+    point.coordinates ? `Координаты: ${point.coordinates}` : "",
+    point.map ? `Карта: ${point.map}` : "",
+    "",
+    nearby,
+  ].filter(Boolean).join("\n");
+}
+
+async function buildAddressToServicesAnswer(address, options = {}) {
+  const limit = Math.max(1, Number(options.limit || 3));
+  const schools = await buildNearbyAnswer(address, { dataset: "schools", limit });
+  const kindergartens = await buildNearbyAnswer(address, { dataset: "kindergartens", limit });
+  return [
+    `По адресу "${address}" ближайшие подключенные городские объекты:`,
+    "",
+    "Школы:",
+    stripNearbyHeader(schools),
+    "",
+    "Детские сады:",
+    stripNearbyHeader(kindergartens),
+  ].join("\n");
+}
+
+function stripNearbyHeader(text) {
+  return String(text || "").split("\n").filter((line) => !line.startsWith("Ближайшие объекты к адресу:")).join("\n");
+}
+
+async function resolveGeoPoint(query) {
+  const entity = await resolveGeoEntity(query).catch(() => null);
+  if (entity?.address) {
+    const point = await geocodeCached(normalizeAddressForGeocoder(entity.address));
+    return mergeGeoEntityPoint(entity, point);
+  }
+  return geocodeCached(query);
+}
+
+async function resolveGeoEntity(query) {
+  const dataset = normalizeGeoDataset(inferGeoDataset(query));
+  let candidates = await getGeoCandidates(dataset);
+  const normalized = normalizeGeoText(query);
+  const number = extractEntityNumberFromQuestion(query, dataset === "kindergartens" ? "kindergartens" : "schools");
+  const place = detectEducationPlace(query);
+  if (place && !place.supported) return null;
+  if (place?.supported) {
+    const placeMatches = candidates.filter((item) => geoItemMatchesPlace(item, place));
+    if (placeMatches.length > 0) candidates = placeMatches;
+  }
+  if (number) {
+    const exactNumberMatches = candidates.filter((item) => itemNameHasNumber(item, number));
+    if (exactNumberMatches.length === 1) {
+      const point = exactNumberMatches[0].address ? await geocodeCached(normalizeAddressForGeocoder(exactNumberMatches[0].address)).catch(() => null) : null;
+      return mergeGeoEntityPoint(exactNumberMatches[0], point);
+    }
+    if (exactNumberMatches.length > 1) {
+      const scoped = place?.supported
+        ? exactNumberMatches.filter((item) => geoItemMatchesPlace(item, place))
+        : exactNumberMatches;
+      const bestExact = scoped[0] || exactNumberMatches[0];
+      const point = bestExact.address ? await geocodeCached(normalizeAddressForGeocoder(bestExact.address)).catch(() => null) : null;
+      return mergeGeoEntityPoint(bestExact, point);
+    }
+  }
+  const scored = candidates.map((item) => ({ ...item, score: scoreGeoCandidate(item, normalized, number, place) }))
+    .filter((item) => item.score > 0)
+    .sort((a, b) => b.score - a.score);
+  const best = scored[0];
+  if (!best) return null;
+  const point = best.address ? await geocodeCached(normalizeAddressForGeocoder(best.address)).catch(() => null) : null;
+  return mergeGeoEntityPoint(best, point);
+}
+
+function mergeGeoEntityPoint(entity, point) {
+  if (!point) return entity;
+  return {
+    ...entity,
+    geoName: point.name || "",
+    geocodedAddress: point.address || "",
+    precision: point.precision || "",
+    coordinates: point.coordinates || "",
+    map: point.map || "",
+    lat: point.lat,
+    lon: point.lon,
+  };
+}
+
+function scoreGeoCandidate(item, normalizedQuery, number, place) {
+  const name = normalizeGeoText(item.name);
+  const address = normalizeGeoText(item.address);
+  let score = 0;
+  if (number && itemNameHasNumber(item, number)) score += 20;
+  for (const token of normalizeGeoText(normalizedQuery).split(/\s+/).filter((part) => part.length >= 3)) {
+    if (name.includes(token)) score += 3;
+    if (address.includes(token)) score += 1;
+  }
+  if (place?.supported && geoItemMatchesPlace(item, place)) score += 8;
+  if (/(сад|детсад|садик)/iu.test(normalizedQuery) && item.layer === "kindergartens") score += 5;
+  if (/(школ|лице|гимнази)/iu.test(normalizedQuery) && item.layer === "schools") score += 5;
+  return score;
+}
+
+function geoItemMatchesPlace(item, place) {
+  if (!place?.supported) return false;
+  const haystack = normalizeGeoText(`${item.name || ""} ${item.address || ""}`);
+  const aliases = [place.label, ...(place.aliases || [])].map(normalizeGeoText).filter(Boolean);
+  return aliases.some((alias) => haystack.includes(alias));
+}
+
+async function getGeoCandidates(dataset = "all") {
+  const layers = dataset === "all" ? ["schools", "kindergartens"] : [dataset];
+  const result = [];
+  for (const layer of layers) {
+    const items = normalizeItems(await fetchAllApiItems(`${await getApiBaseUrl()}/${DATASETS[layer].endpoint}`))
+      .map(selectPublicSummary)
+      .filter((item) => item.name || item.address)
+      .map((item) => ({ ...item, layer }));
+    result.push(...items);
+  }
+  return result;
+}
+
+async function geocodeCached(query) {
+  const key = normalizeGeoText(query);
+  if (geoMemoryCache.has(key)) return geoMemoryCache.get(key);
+  const value = await callYandexGeocoder(query);
+  if (!value) throw new Error(`Yandex Geocoder не вернул результат для: ${query}`);
+  const parsed = parseCoordinates(value.coordinates);
+  const point = { ...value, ...parsed };
+  geoMemoryCache.set(key, point);
+  return point;
+}
+
+function parseCoordinates(coordinates) {
+  const [lat, lon] = String(coordinates || "").split(",").map((part) => Number(part.trim()));
+  return { lat, lon };
+}
+
+async function asyncMapLimit(items, limit, mapper) {
+  const source = Array.from(items || []);
+  if (source.length === 0) return [];
+  const results = new Array(source.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, source.length)) }, async () => {
+    while (next < source.length) {
+      const index = next;
+      next += 1;
+      results[index] = await mapper(source[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+function haversineMeters(a, b) {
+  const radius = 6371000;
+  const lat1 = toRadians(Number(a.lat));
+  const lat2 = toRadians(Number(b.lat));
+  const deltaLat = toRadians(Number(b.lat) - Number(a.lat));
+  const deltaLon = toRadians(Number(b.lon) - Number(a.lon));
+  const x = Math.sin(deltaLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(deltaLon / 2) ** 2;
+  return 2 * radius * Math.atan2(Math.sqrt(x), Math.sqrt(1 - x));
+}
+
+function toRadians(value) {
+  return value * Math.PI / 180;
+}
+
+function formatDistance(meters) {
+  if (!Number.isFinite(meters)) return "-";
+  if (meters < 1000) return `${Math.round(meters)} м`;
+  return `${(meters / 1000).toFixed(meters < 10000 ? 1 : 0)} км`;
+}
+
+function normalizeGeoDataset(value) {
+  const text = String(value || "").toLocaleLowerCase("ru-RU");
+  if (text === "schools" || /школ|лице|гимнази/.test(text)) return "schools";
+  if (text === "kindergartens" || /сад|детсад|садик/.test(text)) return "kindergartens";
+  return "all";
+}
+
+function inferGeoDataset(text) {
+  const normalized = String(text || "").toLocaleLowerCase("ru-RU");
+  if (/(сад|детсад|садик)/iu.test(normalized)) return "kindergartens";
+  if (/(школ|лице|гимнази)/iu.test(normalized)) return "schools";
+  return "all";
+}
+
+function extractAddressForNearby(question) {
+  const text = String(question || "").trim();
+  const match = text.match(/(?:рядом с|рядом|около|возле|поблизости от|живу на|мой адрес|по адресу)\s+(.+)/iu);
+  if (match?.[1]) return cleanupGeoAddress(match[1].split(/[,;]\s*(?:какие|что|где|кто|дай|покажи)/iu)[0]);
+  return cleanupGeoAddress(text);
+}
+
+function extractDistancePair(question) {
+  const text = String(question || "").trim();
+  const explicit = {
+    from: text.match(/(?:от|from)\s+(.+?)\s+(?:до|к|to)\s+(.+)/iu)?.[1],
+    to: text.match(/(?:от|from)\s+(.+?)\s+(?:до|к|to)\s+(.+)/iu)?.[2],
+  };
+  if (explicit.from && explicit.to) return { from: cleanupGeoAddress(explicit.from), to: cleanupGeoAddress(explicit.to) };
+  const parts = text.split(/\s+(?:и|до|->)\s+/iu).map(cleanupGeoAddress).filter(Boolean);
+  return { from: parts[0] || "", to: parts[1] || "" };
+}
+
+function cleanupGeoObjectQuery(text) {
+  return cleanupGeoAddress(String(text || "")
+    .replace(/^(?:где находится|как пройти|как добраться|покажи|дай|открой|найди|ссылку на карту|ссылка на карту)\s+/iu, "")
+    .replace(/\b(?:на карте|карту|карта|рядом|что рядом|ориентиры?)\b/giu, ""));
+}
+
+function cleanupGeoAddress(text) {
+  return String(text || "")
+    .replace(/[?.!]+$/u, "")
+    .replace(/(^|\s)улице(?=\s|$)/giu, "$1улица")
+    .replace(/\b(?:какие|какой|какая|есть|ближайшие|ближайший|школы|школа|детские сады|детский сад|садики|садик|объекты|городские|учреждения|рядом|поблизости)\b/giu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function normalizeAddressForGeocoder(address) {
+  const source = String(address || "").trim();
+  if (!source) return source;
+  let text = source
+    .replace(/^\s*\d{6},?\s*/u, "")
+    .replace(/\bРоссия,\s*/iu, "")
+    .replace(/\bРоссийская Федерация,\s*/iu, "")
+    .replace(/\bРеспублика Марий Эл,\s*/iu, "")
+    .replace(/\bгородской округ\s+город\s+Йошкар-Ола,\s*/iu, "")
+    .replace(/\bГОРОД ЙОШКАР-ОЛА,\s*/iu, "")
+    .replace(/\bЙошкар-Ола\s+г,\s*/iu, "")
+    .replace(/\bгород\s+Йошкар-Ола,\s*/iu, "Йошкар-Ола, ")
+    .replace(/\bсело\s+Сем[её]новка,\s*/iu, "Йошкар-Ола, Семёновка, ")
+    .replace(/\bдом\s+/giu, "д. ")
+    .replace(/\bулица\s+/giu, "ул. ")
+    .replace(/([А-ЯЁ])\.(?=[А-ЯЁ])/gu, "$1. ")
+    .replace(/\s+/g, " ")
+    .replace(/,\s*,/g, ",")
+    .trim();
+  if (!/(йошкар|сем[её]новк)/iu.test(text)) text = `Йошкар-Ола, ${text}`;
+  return text;
+}
+
+function normalizeGeoText(text) {
+  return String(text || "").toLocaleLowerCase("ru-RU").replace(/ё/g, "е").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+
 async function getYandexGeocoderKey() {
   if (process.env.YANDEX_GEOCODER_API_KEY || process.env.YANDEX_MAPS_API_KEY) {
     return process.env.YANDEX_GEOCODER_API_KEY || process.env.YANDEX_MAPS_API_KEY;
@@ -6912,6 +7861,20 @@ async function aiAsk(args, context = {}) {
   const historyEnabled = !options.bare && !options["no-history"] && isFeatureEnabled("sqlite-history");
   const sessionId = historyEnabled && isFeatureEnabled("sessions") ? ensureSessionForAsk(options, providerConfig, question) : null;
   const history = context.history || (sessionId ? getSessionAiHistory(sessionId) : []);
+  const geoAnswer = await buildGeoDirectAnswer(question);
+  if (geoAnswer) {
+    if (historyEnabled) {
+      recordAskHistory({ question, answer: geoAnswer, providerConfig, dataContext, error: "", sessionId });
+      appendSessionExchange(sessionId, question, geoAnswer, dataContext, "");
+    }
+    emitEvent(options, "answer", { length: geoAnswer.length, sessionId, direct: true, geo: true });
+    if (options.output) {
+      await assertPermission("writeFiles");
+      await writeFile(options.output, geoAnswer, "utf8");
+    }
+    if (!options.quiet) console.log(geoAnswer);
+    return geoAnswer;
+  }
   const directAnswer = await buildDirectDataAnswer(question, dataContext);
   if (directAnswer) {
     if (historyEnabled) {
@@ -7281,6 +8244,11 @@ async function localToolAsk(question, providerConfig, options) {
     if (!options.quiet) console.log(casualAnswer);
     return casualAnswer;
   }
+  const geoAnswer = await buildGeoDirectAnswer(question);
+  if (geoAnswer) {
+    if (!options.quiet) console.log(geoAnswer);
+    return geoAnswer;
+  }
   await ensureLocalData();
   const personRoleAnswer = buildPersonRoleDirectAnswer(question);
   if (personRoleAnswer) {
@@ -7754,9 +8722,9 @@ function extractEntityNumberFromQuestion(question, layer) {
   const isKindergarten = layer === "kindergartens";
   const isSchool = layer === "schools";
   const patterns = isKindergarten
-    ? [/(?:детск\w*\s+сад\w*|детсад\w*|сад\w*)\s*(?:№|номер|n)?\s*(\d{1,4})/iu, /№\s*(\d{1,4})/iu]
+    ? [/(?:детск[\p{L}\p{N}_-]*\s+сад[\p{L}\p{N}_-]*|детсад[\p{L}\p{N}_-]*|сад[\p{L}\p{N}_-]*)\s*(?:№|номер|n)?\s*(\d{1,4})/iu, /№\s*(\d{1,4})/iu]
     : isSchool
-      ? [/(?:школ\w*|сош|гимнази\w*|лице\w*)\s*(?:№|номер|n)?\s*(\d{1,4})/iu, /№\s*(\d{1,4})/iu]
+      ? [/(?:школ[\p{L}\p{N}_-]*|сош|гимнази[\p{L}\p{N}_-]*|лице[\p{L}\p{N}_-]*)\s*(?:№|номер|n)?\s*(\d{1,4})/iu, /№\s*(\d{1,4})/iu]
       : [/№\s*(\d{1,4})/iu];
   for (const pattern of patterns) {
     const match = text.match(pattern);
@@ -9433,6 +10401,14 @@ async function onboard(args = []) {
       await setYandexGeocoderKey();
     }
   }
+  if (components.includes("cloud")) {
+    if (process.stdin.isTTY) {
+      const providerAnswer = (await askText("Облачный диск: 1 - Яндекс Диск, 2 - Облако Mail.ru, 0 - пропустить: ")).trim();
+      if (providerAnswer === "1") await setupCloudProvider("yandex-disk");
+      else if (providerAnswer === "2") await setupCloudProvider("mailru-cloud");
+      else console.log("Настройка облачного диска пропущена.");
+    }
+  }
   if (components.includes("codex")) {
     await installCodexIfMissing();
     await aiSetup(["codex"]);
@@ -9482,6 +10458,7 @@ async function chooseOnboardComponents(status = null) {
       12: "browser",
       13: "ollama",
       14: "yandex-geocoder",
+      15: "cloud",
     };
     return [...selected].map((item) => map[item] || item).filter(Boolean);
   } finally {
@@ -9494,7 +10471,7 @@ function isOnboardExitAnswer(answer) {
 }
 
 async function getOnboardComponentStatus() {
-  const [config, readiness, browser, archive, codexVersion, ollamaVersion, yandexGeocoderKey] = await Promise.all([
+  const [config, readiness, browser, archive, codexVersion, ollamaVersion, yandexGeocoderKey, cloudSecrets] = await Promise.all([
     loadConfig(),
     getAiReadiness(),
     getBrowserStatus(),
@@ -9502,6 +10479,7 @@ async function getOnboardComponentStatus() {
     getCommandVersion("codex", ["--version"]),
     getOllamaVersion(),
     getYandexGeocoderKey(),
+    loadSecrets().then((secrets) => secrets.cloud || {}),
   ]);
   const workspaceReady = existsSync(PROJECT_CONTEXT_FILE) || existsSync(PROJECT_CONTEXT_DIR_FILE) || existsSync(PROJECT_IOLA_DIR);
   const policyReady = (config.toolsets?.enabled || []).includes("analyst");
@@ -9520,6 +10498,7 @@ async function getOnboardComponentStatus() {
     index: false,
     browser: browser.installed === "yes",
     "yandex-geocoder": Boolean(yandexGeocoderKey),
+    cloud: Object.keys(cloudSecrets).length > 0,
   };
 }
 
@@ -9539,6 +10518,7 @@ function onboardComponentRows(status) {
     ["12", "browser", "Browser runtime", "Playwright/Chromium установлен"],
     ["13", "ollama", "Ollama", "опциональный локальный runtime"],
     ["14", "yandex-geocoder", "Yandex Geocoder API", "ключ геокодера сохранен или есть в env"],
+    ["15", "cloud", "Облачный диск", "Яндекс Диск или Облако Mail.ru"],
   ];
   return rows.map(([number, key, title, hint]) => ({ number, key, title, hint, status: status[key] ? "готово" : "не настроено" }));
 }
@@ -9553,7 +10533,7 @@ function defaultOnboardSelection(status) {
 }
 
 function defaultOnboardComponents(status) {
-  const map = { 1: "workspace", 2: "policy", 3: "iola", 4: "yandexgpt", 5: "gigachat", 6: "openai", 7: "openrouter", 8: "codex", 9: "codex-mcp", 10: "archive", 11: "index", 12: "browser", 13: "ollama", 14: "yandex-geocoder" };
+  const map = { 1: "workspace", 2: "policy", 3: "iola", 4: "yandexgpt", 5: "gigachat", 6: "openai", 7: "openrouter", 8: "codex", 9: "codex-mcp", 10: "archive", 11: "index", 12: "browser", 13: "ollama", 14: "yandex-geocoder", 15: "cloud" };
   return defaultOnboardSelection(status).map((item) => map[item]).filter(Boolean);
 }
 
@@ -9567,7 +10547,7 @@ function parseOptions(args) {
     } else if (arg === "--check" || arg === "--upgrade-node") {
       result.check = true;
       result[arg.slice(2)] = true;
-    } else if (arg === "--limit" || arg === "--offset" || arg === "--search" || arg === "--replace" || arg === "--text" || arg === "--path" || arg === "--depth" || arg === "--max-bytes" || arg === "--query" || arg === "--where" || arg === "--columns" || arg === "--inn" || arg === "--model" || arg === "--provider" || arg === "--profile" || arg === "--name" || arg === "--source" || arg === "--command" || arg === "--prompt" || arg === "--description" || arg === "--base-url" || arg === "--repo" || arg === "--model-dir" || arg === "--sandbox" || arg === "--approval" || arg === "--cwd" || arg === "--codex-profile" || arg === "--format" || arg === "--output" || arg === "--schema" || arg === "--session" || arg === "--temperature" || arg === "--config" || arg === "--dataset" || arg === "--save" || arg === "--reasoning" || arg === "--agent" || arg === "--scope" || arg === "--selector" || arg === "--url" || arg === "--timeout" || arg === "--wait" || arg === "--viewport" || arg === "--press" || arg === "--script" || arg === "--auth-url" || arg === "--token-url" || arg === "--userinfo-url" || arg === "--client-id" || arg === "--client-secret" || arg === "--redirect-host" || arg === "--redirect-port" || arg === "--redirect-path" || arg === "--debug-file") {
+    } else if (arg === "--limit" || arg === "--offset" || arg === "--search" || arg === "--replace" || arg === "--text" || arg === "--path" || arg === "--depth" || arg === "--max-bytes" || arg === "--query" || arg === "--where" || arg === "--columns" || arg === "--inn" || arg === "--model" || arg === "--provider" || arg === "--profile" || arg === "--name" || arg === "--source" || arg === "--command" || arg === "--prompt" || arg === "--description" || arg === "--base-url" || arg === "--repo" || arg === "--model-dir" || arg === "--sandbox" || arg === "--approval" || arg === "--cwd" || arg === "--codex-profile" || arg === "--format" || arg === "--output" || arg === "--schema" || arg === "--session" || arg === "--temperature" || arg === "--config" || arg === "--dataset" || arg === "--save" || arg === "--reasoning" || arg === "--agent" || arg === "--scope" || arg === "--selector" || arg === "--url" || arg === "--timeout" || arg === "--wait" || arg === "--viewport" || arg === "--press" || arg === "--script" || arg === "--auth-url" || arg === "--token-url" || arg === "--userinfo-url" || arg === "--client-id" || arg === "--client-secret" || arg === "--redirect-host" || arg === "--redirect-port" || arg === "--redirect-path" || arg === "--debug-file" || arg === "--from" || arg === "--to" || arg === "--radius" || arg === "--address") {
       result[arg.slice(2)] = args[index + 1];
       index += 1;
     } else {
@@ -9816,6 +10796,7 @@ function selectSkillsForPrompt(config, question = "", options = {}) {
   const normalized = String(question || "").toLocaleLowerCase("ru-RU");
   if (enabled.has("local-model")) selected.add("local-model");
   if (enabled.has("open-data") && shouldUseDataContext(question, options)) selected.add("open-data");
+  if (enabled.has("geo") && isGeoQuestion(normalized)) selected.add("geo");
   if (enabled.has("reports") && /(отчет|отчёт|выгруз|csv|xlsx|качество|провер)/iu.test(normalized)) selected.add("reports");
   if (enabled.has("local-files") && (options.files || /(файл|папк|readme|документ|архив)/iu.test(normalized))) selected.add("local-files");
   if (enabled.has("browser-agent") && /(браузер|сайт|страниц|url|https?:\/\/)/iu.test(normalized)) selected.add("browser-agent");
@@ -11451,6 +12432,14 @@ function mergeConfig(base, override) {
       ...base.files,
       ...(override.files || {}),
     },
+    cloud: {
+      ...base.cloud,
+      ...(override.cloud || {}),
+      providers: {
+        ...(base.cloud?.providers || {}),
+        ...(override.cloud?.providers || {}),
+      },
+    },
     memory: {
       ...base.memory,
       ...(override.memory || {}),
@@ -11510,6 +12499,9 @@ function sanitizeConfig(config) {
   if (Array.isArray(next.skills?.enabled) && next.skills.enabled.includes("open-data") && !next.skills.enabled.includes("education")) {
     next.skills.enabled = ["education", ...next.skills.enabled];
   }
+  if (Array.isArray(next.skills?.enabled) && next.skills.enabled.includes("local-files") && !next.skills.enabled.includes("personal-docs")) {
+    next.skills.enabled = [...next.skills.enabled, "personal-docs"];
+  }
   const localProfile = next.ai?.profiles?.local;
   if (localProfile?.provider === "iola") {
     if (!localProfile.runtime || localProfile.model === "iola-router-1b") {
@@ -11554,6 +12546,9 @@ function validateConfig(config) {
   for (const toolset of config.toolsets?.enabled || []) {
     if (!TOOLSETS[toolset]) errors.push(`toolsets.enabled содержит неизвестный toolset: ${toolset}`);
   }
+  if (config.cloud?.activeProvider && !["yandex-disk", "mailru-cloud"].includes(config.cloud.activeProvider)) {
+    errors.push(`cloud.activeProvider неизвестен: ${config.cloud.activeProvider}`);
+  }
   return errors;
 }
 
@@ -11567,6 +12562,7 @@ function configSchema() {
       permissions: { localTools: ALL_LOCAL_TOOLS, runtime: ["readFiles", "writeFiles", "editFiles", "deleteFiles", "sync", "externalApi", "externalAi", "codex"] },
       toolsets: { available: Object.keys(TOOLSETS) },
       files: { modes: ["locked", "read-only", "workspace-write", "full-access"], approvals: ["never", "on-write", "on-danger", "always"] },
+      cloud: { providers: ["yandex-disk", "mailru-cloud"], root: CLOUD_DEFAULT_REMOTE_DIR },
       skills: { enabled: "array of skill names" },
       daemon: { host: "127.0.0.1", port: DAEMON_PORT },
     },