@iola_adm/iola-cli 0.2.34 → 0.2.36

package/src/cli.js

@@ -151,7 +151,7 @@ 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"];
 const FILE_TOOLS = ["files_tree", "files_read", "files_search", "files_write", "files_patch"];
-const USER_SKILL_TOOLS = ["user_skill_create", "user_skill_enable", "user_skill_disable", "user_skill_delete", "user_skill_list"];
+const USER_SKILL_TOOLS = ["user_skill_create", "user_skill_update", "user_skill_enable", "user_skill_disable", "user_skill_delete", "user_skill_list", "user_skill_templates", "user_skill_validate", "user_skill_preview"];
 const YANDEX_TOOLS = [
   "yandex_identity_me",
   "yandex_disk_info",
@@ -192,9 +192,27 @@ const YANDEX_TOOLS = [
   "yandex_mail_city_context",
   "yandex_mail_map_addresses",
   "yandex_mail_create_task",
+  "yandex_mail_meeting_pack",
   "yandex_calendar_status",
+  "yandex_calendar_calendars",
   "yandex_calendar_create_event",
   "yandex_calendar_list",
+  "yandex_calendar_get",
+  "yandex_calendar_search",
+  "yandex_calendar_update",
+  "yandex_calendar_move",
+  "yandex_calendar_delete",
+  "yandex_calendar_create_recurring_event",
+  "yandex_calendar_add_reminder",
+  "yandex_docs_status",
+  "yandex_docs_list",
+  "yandex_docs_find",
+  "yandex_docs_create_text",
+  "yandex_docs_read",
+  "yandex_docs_share",
+  "yandex_docs_rename",
+  "yandex_docs_delete",
+  "yandex_docs_save_answer",
   "yandex_contacts_status",
   "yandex_contacts_list",
   "yandex_contacts_search",
@@ -224,7 +242,12 @@ const YANDEX_TOOLS = [
   "yandex_contact_create_calendar_event",
   "yandex_contact_create_telemost_event",
   "yandex_contact_from_public_entity",
+  "yandex_telemost_status",
   "yandex_telemost_create_event",
+  "yandex_contact_full_pack",
+  "yandex_daily_digest",
+  "yandex_calendar_reminders_tick",
+  "yandex_disk_maintenance_tick",
 ];
 const ALL_LOCAL_TOOLS = [...LOCAL_TOOLS, ...FILE_TOOLS, ...YANDEX_TOOLS, ...USER_SKILL_TOOLS];
 const ALL_TOOL_ALIASES = [...ALL_LOCAL_TOOLS, ...LEGACY_LOCAL_TOOLS];
@@ -3047,6 +3070,29 @@ async function handleSkills(args) {
     return;
   }
 
+  if (action === "templates") {
+    printTable(userSkillTemplates().map((row) => ({ name: row.name, description: row.description, tools: row.tools.join(", ") })), [["name", "Шаблон"], ["description", "Описание"], ["tools", "Tools"]]);
+    return;
+  }
+
+  if (action === "preview") {
+    const options = parseOptions(args.slice(2));
+    console.log(buildUserSkillPreview({
+      name,
+      description: options.description || "",
+      instructions: options.instructions || options.text || options.prompt || options._.join(" "),
+      tools: parseCommaList(options["allowed-tools"] || options.tool || options.uses || ""),
+      template: options.template,
+    }));
+    return;
+  }
+
+  if (action === "validate") {
+    const result = await userSkillValidate(name);
+    printTable(result.checks, [["check", "Проверка"], ["status", "Статус"], ["message", "Сообщение"]]);
+    return;
+  }
+
   if (action === "create" || action === "new") {
     const options = parseOptions(args.slice(2));
     const result = await userSkillCreate({
@@ -3054,6 +3100,7 @@ async function handleSkills(args) {
       description: options.description || "",
       instructions: options.instructions || options.text || options.prompt || options._.join(" "),
       tools: parseCommaList(options["allowed-tools"] || options.tool || options.uses || ""),
+      template: options.template,
       enable: Boolean(options.enable),
       overwrite: Boolean(options.force),
       confirm: true,
@@ -3064,6 +3111,20 @@ async function handleSkills(args) {
     return;
   }
 
+  if (action === "update" || action === "edit") {
+    const options = parseOptions(args.slice(2));
+    const result = await userSkillUpdate(name, {
+      description: options.description,
+      instructions: options.instructions || options.text || options.prompt || options._.join(" "),
+      tools: parseCommaList(options["allowed-tools"] || options.tool || options.uses || ""),
+      enable: options.enable,
+      confirm: true,
+    });
+    console.log(`Skill обновлен: ${result.name}`);
+    console.log(`Файл: ${result.file}`);
+    return;
+  }
+
   if (action === "delete" || action === "remove" || action === "rm") {
     const options = parseOptions(args.slice(2));
     const result = await userSkillDelete(name, { confirm: Boolean(options.yes || options.force) });
@@ -3081,7 +3142,7 @@ async function handleSkills(args) {
     return;
   }
 
-  throw new Error("Команды skills: list, paths, show NAME, create NAME --description TEXT --instructions TEXT [--enable], enable NAME, disable NAME, delete NAME --yes, bundles, bundle enable NAME, doctor.");
+  throw new Error("Команды skills: list, paths, show NAME, templates, preview NAME --template T, create NAME --description TEXT --instructions TEXT [--enable], update NAME --instructions TEXT, validate NAME, enable NAME, disable NAME, delete NAME --yes, bundles, bundle enable NAME, doctor.");
 }
 
 async function handleTools(args) {
@@ -3377,6 +3438,21 @@ async function handleYandex(args) {
     return;
   }
 
+  if (action === "daily-digest" || action === "digest") {
+    await handleYandexDailyDigest([target, ...rest].filter(Boolean));
+    return;
+  }
+
+  if (action === "calendar-reminders" || action === "calendar-watch" || action === "reminders") {
+    await handleYandexCalendarReminders([target, ...rest].filter(Boolean));
+    return;
+  }
+
+  if (action === "disk-maintenance" || action === "disk-watch" || action === "disk-doctor") {
+    await handleYandexDiskMaintenance([target, ...rest].filter(Boolean));
+    return;
+  }
+
   if (action === "contacts-maintenance" || action === "contacts-watch" || action === "contacts-doctor") {
     await handleYandexContactsMaintenance([target, ...rest].filter(Boolean));
     return;
@@ -3418,6 +3494,9 @@ async function handleYandex(args) {
   iola yandex status|doctor
   iola yandex services
   iola yandex mail-watch on|off|status|tick [--minutes 5]
+  iola yandex daily-digest on|off|status|tick [--time 09:00] [--email]
+  iola yandex calendar-reminders on|off|status|tick [--minutes 15]
+  iola yandex disk-maintenance on|off|status|tick [--days 7]
   iola yandex contacts-maintenance on|off|status|tick [--days 7] [--backup]
   iola yandex enable disk mail calendar
   iola yandex disable mail
@@ -3489,6 +3568,107 @@ async function handleYandexMailWatch(args = []) {
   throw new Error("Команды: iola yandex mail-watch on --minutes 5 | off | status | tick");
 }
 
+async function handleYandexDailyDigest(args = []) {
+  const [action = "status", ...rest] = args;
+  const options = parseOptions(rest);
+  if (action === "on" || action === "enable" || action === "start" || action === "вкл") {
+    const time = options.time || rest.find((item) => /^\d{1,2}:\d{2}$/u.test(String(item))) || "09:00";
+    const result = await yandexDailyDigestEnable({ time, email: Boolean(options.email), save: options.save !== false });
+    console.log(`Ежедневный дайджест включен: каждый день ${result.time}. Email: ${result.email ? "yes" : "no"}.`);
+    return;
+  }
+  if (action === "off" || action === "disable" || action === "stop" || action === "выкл") {
+    await yandexDailyDigestDisable();
+    console.log("Ежедневный дайджест выключен.");
+    return;
+  }
+  if (action === "tick" || action === "run" || action === "check") {
+    const result = await yandexDailyDigestTick({ force: true, email: Boolean(options.email), save: options.save !== false });
+    console.log(result.text || "Дайджест пуст.");
+    if (result.remote) console.log(`Сохранено на Диск: ${result.remote}`);
+    return;
+  }
+  const config = await loadConfig();
+  const digest = config.yandex?.dailyDigest || {};
+  printKeyValue({
+    enabled: digest.enabled ? "yes" : "no",
+    time: digest.time || "-",
+    email: digest.email ? "yes" : "no",
+    lastRunAt: digest.lastRunAt || "-",
+    lastRemote: digest.lastRemote || "-",
+    cron: listCronJobs().some((job) => job.command === "yandex daily-digest tick") ? "yes" : "no",
+  });
+}
+
+async function handleYandexCalendarReminders(args = []) {
+  const [action = "status", ...rest] = args;
+  const options = parseOptions(rest);
+  if (action === "on" || action === "enable" || action === "start" || action === "вкл") {
+    const minutes = Math.max(1, Number(options.minutes || rest.find((item) => /^\d+$/u.test(String(item))) || 15));
+    const result = await yandexCalendarRemindersEnable(minutes);
+    console.log(`Проверка календарных напоминаний включена: каждые ${result.minutes} минут.`);
+    return;
+  }
+  if (action === "off" || action === "disable" || action === "stop" || action === "выкл") {
+    await yandexCalendarRemindersDisable();
+    console.log("Проверка календарных напоминаний выключена.");
+    return;
+  }
+  if (action === "tick" || action === "run" || action === "check") {
+    const result = await yandexCalendarRemindersTick({ force: true, horizonMinutes: Number(options.horizon || options.minutes || 60) });
+    if (!result.events.length) console.log("Ближайших событий для напоминания нет.");
+    else console.log(["Ближайшие события:", ...result.events.map((row, index) => `${index + 1}. ${row.title || row.uid} — ${row.startIso || row.start || "-"}`)].join("\n"));
+    return;
+  }
+  const config = await loadConfig();
+  const reminders = config.yandex?.calendarReminders || {};
+  printKeyValue({
+    enabled: reminders.enabled ? "yes" : "no",
+    minutes: reminders.minutes || "-",
+    horizonMinutes: reminders.horizonMinutes || 60,
+    lastRunAt: reminders.lastRunAt || "-",
+    lastCount: reminders.lastCount ?? "-",
+    cron: listCronJobs().some((job) => job.command === "yandex calendar-reminders tick") ? "yes" : "no",
+  });
+}
+
+async function handleYandexDiskMaintenance(args = []) {
+  const [action = "status", ...rest] = args;
+  const options = parseOptions(rest);
+  if (action === "on" || action === "enable" || action === "start" || action === "вкл") {
+    const days = Math.max(1, Number(options.days || rest.find((item) => /^\d+$/u.test(String(item))) || 7));
+    const result = await yandexDiskMaintenanceEnable(days);
+    console.log(`Проверка Яндекс Диска включена: каждые ${result.days} дней.`);
+    return;
+  }
+  if (action === "off" || action === "disable" || action === "stop" || action === "выкл") {
+    await yandexDiskMaintenanceDisable();
+    console.log("Проверка Яндекс Диска выключена.");
+    return;
+  }
+  if (action === "tick" || action === "run" || action === "check") {
+    const result = await yandexDiskMaintenanceTick({ force: true });
+    printKeyValue({
+      used: formatBytes(result.usedSpace),
+      total: formatBytes(result.totalSpace),
+      trash: formatBytes(result.trashSize),
+      docs: result.docs,
+      publicLinks: result.publicLinks,
+      remote: result.remote || "-",
+    });
+    return;
+  }
+  const config = await loadConfig();
+  const disk = config.yandex?.diskMaintenance || {};
+  printKeyValue({
+    enabled: disk.enabled ? "yes" : "no",
+    days: disk.days || "-",
+    lastRunAt: disk.lastRunAt || "-",
+    lastRemote: disk.lastRemote || "-",
+    cron: listCronJobs().some((job) => job.command === "yandex disk-maintenance tick") ? "yes" : "no",
+  });
+}
+
 async function handleYandexContactsMaintenance(args = []) {
   const [action = "status", ...rest] = args;
   const options = parseOptions(rest);
@@ -4146,9 +4326,27 @@ async function executeYandexTool(tool, args = {}) {
   if (tool === "yandex_mail_city_context") return yandexMailCityContext(args.uid || args.id, args);
   if (tool === "yandex_mail_map_addresses") return yandexMailMapAddresses(args.uid || args.id, args);
   if (tool === "yandex_mail_create_task") return yandexMailCreateTask(args.uid || args.id, args);
+  if (tool === "yandex_mail_meeting_pack") return yandexMailMeetingPack(args.uid || args.id, args);
   if (tool === "yandex_calendar_status") return yandexCalendarStatus();
+  if (tool === "yandex_calendar_calendars") return yandexCalendarCalendars(args);
   if (tool === "yandex_calendar_create_event") return yandexCalendarCreateEvent(args);
   if (tool === "yandex_calendar_list") return yandexCalendarList(args);
+  if (tool === "yandex_calendar_get") return yandexCalendarGet(args.query || args.uid || args.title || "", args);
+  if (tool === "yandex_calendar_search") return yandexCalendarSearch(args.query || args.title || "", args);
+  if (tool === "yandex_calendar_update") return yandexCalendarUpdate(args.query || args.uid || args.title || "", args);
+  if (tool === "yandex_calendar_move") return yandexCalendarMove(args.query || args.uid || args.title || "", args);
+  if (tool === "yandex_calendar_delete") return yandexCalendarDelete(args.query || args.uid || args.title || "", args);
+  if (tool === "yandex_calendar_create_recurring_event") return yandexCalendarCreateRecurringEvent(args);
+  if (tool === "yandex_calendar_add_reminder") return yandexCalendarAddReminder(args.query || args.uid || args.title || "", args);
+  if (tool === "yandex_docs_status") return yandexDocsStatus();
+  if (tool === "yandex_docs_list") return yandexDocsList(args);
+  if (tool === "yandex_docs_find") return yandexDocsFind(args.query || args.name || "", args);
+  if (tool === "yandex_docs_create_text") return yandexDocsCreateText(args);
+  if (tool === "yandex_docs_read") return yandexDocsRead(args.path || args.remotePath || args.query || args.name, args);
+  if (tool === "yandex_docs_share") return yandexDocsShare(args.path || args.remotePath || args.query || args.name, args);
+  if (tool === "yandex_docs_rename") return yandexDocsRename(args.path || args.remotePath || args.query || args.name, args.name || args.newName || args.to, args);
+  if (tool === "yandex_docs_delete") return yandexDocsDelete(args.path || args.remotePath || args.query || args.name, args);
+  if (tool === "yandex_docs_save_answer") return yandexDocsCreateText({ ...args, text: args.text || args.answer || args.content });
   if (tool === "yandex_contacts_status") return yandexContactsStatus();
   if (tool === "yandex_contacts_list") return yandexContactsList(args);
   if (tool === "yandex_contacts_search") return yandexContactsSearch(args.query || "", args);
@@ -4178,7 +4376,12 @@ async function executeYandexTool(tool, args = {}) {
   if (tool === "yandex_contact_create_calendar_event") return yandexContactCreateCalendarEvent(args);
   if (tool === "yandex_contact_create_telemost_event") return yandexContactCreateTelemostEvent(args);
   if (tool === "yandex_contact_from_public_entity") return yandexContactFromPublicEntity(args);
+  if (tool === "yandex_telemost_status") return yandexTelemostStatus();
   if (tool === "yandex_telemost_create_event") return yandexTelemostCreateEvent(args);
+  if (tool === "yandex_contact_full_pack") return yandexContactFullPack(args);
+  if (tool === "yandex_daily_digest") return yandexDailyDigestTick({ ...args, force: true });
+  if (tool === "yandex_calendar_reminders_tick") return yandexCalendarRemindersTick({ ...args, force: true });
+  if (tool === "yandex_disk_maintenance_tick") return yandexDiskMaintenanceTick({ ...args, force: true });
   throw new Error(`Yandex tool неизвестен: ${tool}`);
 }
 
@@ -4349,6 +4552,142 @@ async function yandexMailWatchDisable() {
   return { enabled: false };
 }
 
+async function yandexDailyDigestEnable(options = {}) {
+  const config = await loadConfig();
+  const time = normalizeDigestTime(options.time || "09:00");
+  await saveConfig({
+    yandex: {
+      ...(config.yandex || {}),
+      dailyDigest: { ...(config.yandex?.dailyDigest || {}), enabled: true, time, email: Boolean(options.email), save: options.save !== false, updatedAt: new Date().toISOString() },
+    },
+  });
+  await upsertCronJob(`каждый день ${time}`, "yandex daily-digest tick", { replaceCommand: true });
+  return { enabled: true, time, email: Boolean(options.email), save: options.save !== false };
+}
+
+async function yandexDailyDigestDisable() {
+  const config = await loadConfig();
+  const current = config.yandex?.dailyDigest || {};
+  await saveConfig({ yandex: { ...(config.yandex || {}), dailyDigest: { ...current, enabled: false, lastRemote: "", updatedAt: new Date().toISOString() } } });
+  deleteCronJobsByCommand("yandex daily-digest tick");
+  return { enabled: false };
+}
+
+async function yandexDailyDigestTick(options = {}) {
+  const config = await loadConfig();
+  const digest = config.yandex?.dailyDigest || {};
+  if (!digest.enabled && !options.force) return { enabled: false, text: "" };
+  const unread = await yandexMailList({ mailbox: "INBOX", limit: 10, unread: true }).catch(() => []);
+  const events = await yandexCalendarList({ start: new Date().toISOString(), end: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(), limit: 20 }).catch(() => []);
+  const incomplete = await yandexContactsFindIncomplete({ limit: 10 }).catch(() => []);
+  const text = [
+    `# Дайджест IOLA за ${new Intl.DateTimeFormat("ru-RU", { dateStyle: "long" }).format(new Date())}`,
+    "",
+    `Непрочитанных писем: ${unread.length}`,
+    ...unread.slice(0, 5).map((row, index) => `${index + 1}. ${formatYandexMailSummary(row)}`),
+    "",
+    `Событий на 24 часа: ${events.length}`,
+    ...events.slice(0, 10).map((row, index) => `${index + 1}. ${row.title || "(без названия)"} — ${row.startIso || row.start || "-"}`),
+    "",
+    `Неполных контактов: ${incomplete.length}`,
+    ...incomplete.slice(0, 5).map((row, index) => `${index + 1}. ${formatYandexContact(row)}`),
+  ].join("\n").trim();
+  let remote = "";
+  if (options.save !== false && digest.save !== false) {
+    const saved = await yandexDocsCreateText({ title: `daily-digest-${timestampForFile()}`, text, format: "md", confirm: true });
+    remote = saved.remote || "";
+  }
+  if (options.email || digest.email) {
+    const profile = await getYandexIdentityProfile();
+    const to = profile.defaultEmail || profile.emails?.[0];
+    if (to) await yandexMailSend({ to: [to], subject: "Ежедневный дайджест IOLA", text, confirm: true });
+  }
+  await saveConfig({ yandex: { ...(config.yandex || {}), dailyDigest: { ...digest, enabled: digest.enabled !== false, lastRunAt: new Date().toISOString(), lastRemote: remote || digest.lastRemote || "" } } });
+  return { enabled: true, text, remote, unread: unread.length, events: events.length, incomplete: incomplete.length };
+}
+
+async function yandexCalendarRemindersEnable(minutes = 15) {
+  const config = await loadConfig();
+  const safeMinutes = Math.max(1, Number(minutes || 15));
+  await saveConfig({ yandex: { ...(config.yandex || {}), calendarReminders: { ...(config.yandex?.calendarReminders || {}), enabled: true, minutes: safeMinutes, horizonMinutes: 60, updatedAt: new Date().toISOString() } } });
+  await upsertCronJob(`каждые ${safeMinutes} минут`, "yandex calendar-reminders tick", { replaceCommand: true });
+  return { enabled: true, minutes: safeMinutes };
+}
+
+async function yandexCalendarRemindersDisable() {
+  const config = await loadConfig();
+  const current = config.yandex?.calendarReminders || {};
+  await saveConfig({ yandex: { ...(config.yandex || {}), calendarReminders: { ...current, enabled: false, seen: [], updatedAt: new Date().toISOString() } } });
+  deleteCronJobsByCommand("yandex calendar-reminders tick");
+  return { enabled: false };
+}
+
+async function yandexCalendarRemindersTick(options = {}) {
+  const config = await loadConfig();
+  const reminders = config.yandex?.calendarReminders || {};
+  if (!reminders.enabled && !options.force) return { enabled: false, events: [] };
+  const horizon = Math.max(5, Number(options.horizonMinutes || reminders.horizonMinutes || 60));
+  const now = new Date();
+  const rows = await yandexCalendarList({ start: now.toISOString(), end: new Date(now.getTime() + horizon * 60 * 1000).toISOString(), limit: 30 });
+  const seen = new Set(reminders.seen || []);
+  const fresh = rows.filter((row) => {
+    const key = `${row.uid}:${row.start}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  await saveConfig({ yandex: { ...(config.yandex || {}), calendarReminders: { ...reminders, enabled: reminders.enabled !== false, lastRunAt: new Date().toISOString(), lastCount: fresh.length, seen: [...seen].slice(-500) } } });
+  return { enabled: true, events: fresh };
+}
+
+async function yandexDiskMaintenanceEnable(days = 7) {
+  const config = await loadConfig();
+  const safeDays = Math.max(1, Number(days || 7));
+  await saveConfig({ yandex: { ...(config.yandex || {}), diskMaintenance: { ...(config.yandex?.diskMaintenance || {}), enabled: true, days: safeDays, updatedAt: new Date().toISOString() } } });
+  await upsertCronJob(`каждые ${safeDays} дней`, "yandex disk-maintenance tick", { replaceCommand: true });
+  return { enabled: true, days: safeDays };
+}
+
+async function yandexDiskMaintenanceDisable() {
+  const config = await loadConfig();
+  const current = config.yandex?.diskMaintenance || {};
+  await saveConfig({ yandex: { ...(config.yandex || {}), diskMaintenance: { ...current, enabled: false, lastRemote: "", updatedAt: new Date().toISOString() } } });
+  deleteCronJobsByCommand("yandex disk-maintenance tick");
+  return { enabled: false };
+}
+
+async function yandexDiskMaintenanceTick(options = {}) {
+  const config = await loadConfig();
+  const disk = config.yandex?.diskMaintenance || {};
+  if (!disk.enabled && !options.force) return { enabled: false };
+  const info = await yandexDiskInfo();
+  const docs = await yandexDocsList({ limit: 500 }).catch(() => []);
+  const all = await yandexDiskListRecursive(CLOUD_DEFAULT_REMOTE_DIR, { depth: 4, limit: 500 }).catch(() => []);
+  const publicLinks = [];
+  for (const row of all.slice(0, 100)) {
+    const statRow = await yandexDiskStat(row.path).catch(() => null);
+    if (statRow?.publicUrl) publicLinks.push(statRow);
+  }
+  const text = [
+    `# Проверка Яндекс Диска ${new Date().toISOString()}`,
+    "",
+    `Занято: ${formatBytes(info.usedSpace)} из ${formatBytes(info.totalSpace)}`,
+    `Корзина: ${formatBytes(info.trashSize)}`,
+    `Документов: ${docs.length}`,
+    `Публичных ссылок в /IOLA: ${publicLinks.length}`,
+    ...publicLinks.slice(0, 20).map((row, index) => `${index + 1}. ${row.path} — ${row.publicUrl}`),
+  ].join("\n");
+  const saved = await yandexDocsCreateText({ title: `disk-maintenance-${timestampForFile()}`, text, format: "md", confirm: true });
+  await saveConfig({ yandex: { ...(config.yandex || {}), diskMaintenance: { ...disk, enabled: disk.enabled !== false, lastRunAt: new Date().toISOString(), lastRemote: saved.remote || "", lastDocs: docs.length, lastPublicLinks: publicLinks.length } } });
+  return { enabled: true, ...info, docs: docs.length, publicLinks: publicLinks.length, remote: saved.remote || "" };
+}
+
+function normalizeDigestTime(value) {
+  const match = String(value || "").match(/^(\d{1,2})(?::(\d{2}))?$/u);
+  if (!match) return "09:00";
+  return `${String(Math.min(23, Number(match[1]))).padStart(2, "0")}:${String(Math.min(59, Number(match[2] || 0))).padStart(2, "0")}`;
+}
+
 async function yandexContactsMaintenanceEnable(days = 7, options = {}) {
   const config = await loadConfig();
   const safeDays = Math.max(1, Number(days || 7));
@@ -4552,6 +4891,47 @@ async function yandexMailCreateCalendarEvent(uid, args = {}) {
   });
 }
 
+async function yandexMailMeetingPack(uid, args = {}) {
+  if (!args.confirm) throw new Error("Для пакетного сценария по письму нужен аргумент confirm=true.");
+  if (!uid) throw new Error("UID письма обязателен.");
+  const mailbox = await resolveYandexMailbox(args.mailbox || args.folder || "INBOX");
+  const row = await yandexMailRead(uid, { mailbox, markSeen: true });
+  if (!row || row.status === "not-found") throw new Error(`Письмо #${uid} не найдено.`);
+  const senderEmail = extractEmailAddress(row.from);
+  const saved = await yandexMailSaveToDisk(uid, { mailbox });
+  const shared = await yandexDiskShareWithQr(saved.remote, { confirm: true });
+  const detected = extractDateTimeFromText(`${args.text || ""}\n${row.subject}\n${row.snippet}`);
+  const start = args.start || detected.start || new Date(Date.now() + 3600000).toISOString();
+  const end = args.end || detected.end || new Date(new Date(start).getTime() + 3600000).toISOString();
+  const event = await yandexCalendarCreateEvent({
+    title: args.title || `Встреча по письму: ${row.subject || `#${uid}`}`,
+    description: [
+      `Создано из письма #${uid}.`,
+      `От: ${row.from || "-"}`,
+      `Письмо сохранено: ${saved.remote}`,
+      `Ссылка: ${shared.publicUrl}`,
+      `QR-код: ${shared.qrPublicUrl}`,
+      "",
+      row.snippet || "",
+    ].join("\n"),
+    location: args.location || detected.location || "",
+    start,
+    end,
+    attendees: senderEmail ? [senderEmail] : [],
+    confirm: true,
+  });
+  let sent = null;
+  if ((args.send || args.email) && senderEmail) {
+    sent = await yandexMailSend({
+      to: [senderEmail],
+      subject: args.subject || `Материалы к встрече: ${row.subject || `письмо #${uid}`}`,
+      text: [`Создал встречу и сохранил письмо на Яндекс Диск.`, `Ссылка: ${shared.publicUrl}`, `QR-код: ${shared.qrPublicUrl}`].join("\n"),
+      confirm: true,
+    });
+  }
+  return { status: "mail-meeting-pack-created", uid: Number(uid), from: row.from, saved: saved.remote, publicUrl: shared.publicUrl, qrPublicUrl: shared.qrPublicUrl, event: event.uid, sentTo: sent?.to || [] };
+}
+
 async function yandexMailSenderToContact(uid, args = {}) {
   if (!args.confirm) throw new Error("Для добавления отправителя в контакты нужен аргумент confirm=true.");
   if (!uid) throw new Error("UID письма обязателен.");
@@ -4980,29 +5360,53 @@ async function yandexDavRequest(url, token, options = {}) {
 
 async function yandexCalendarStatus() {
   const token = await requireYandexOAuthToken("organizer", "Яндекс Календарь");
-  const url = await yandexCalendarBaseUrl(token);
+  const calendars = await yandexCalendarCollections(token);
+  const selected = pickYandexCalendar(calendars, {});
+  const url = selected.url;
   const text = await yandexDavRequest(url, token, { method: "PROPFIND", headers: { Depth: "0" }, xml: true, body: "<?xml version=\"1.0\"?><d:propfind xmlns:d=\"DAV:\"><d:prop><d:displayname/></d:prop></d:propfind>" });
-  return { status: "ok", url, displayName: stripXmlTags(text.match(/<[^:>]*:?displayname[^>]*>([\s\S]*?)<\/[^:>]*:?displayname>/iu)?.[1] || "") || "calendar" };
+  return { status: "ok", url, displayName: stripXmlTags(text.match(/<[^:>]*:?displayname[^>]*>([\s\S]*?)<\/[^:>]*:?displayname>/iu)?.[1] || "") || selected.name || "calendar", calendars: calendars.length };
+}
+
+async function yandexCalendarCalendars(args = {}) {
+  const token = await requireYandexOAuthToken("organizer", "Яндекс Календарь");
+  const calendars = await yandexCalendarCollections(token);
+  return calendars.slice(0, Number(args.limit || 50));
 }
 
 async function yandexCalendarCreateEvent(args = {}) {
   if (!args.confirm) throw new Error("Для создания события в календаре нужен аргумент confirm=true.");
   const token = await requireYandexOAuthToken("organizer", "Яндекс Календарь");
-  const baseUrl = await yandexCalendarBaseUrl(token);
+  const baseUrl = await yandexCalendarBaseUrl(token, args);
   const uid = `${randomUUID()}@iola-cli`;
   const start = toIcsDate(args.start || args.date || new Date(Date.now() + 3600000).toISOString());
   const end = toIcsDate(args.end || new Date(Date.now() + 7200000).toISOString());
   const summary = args.title || args.summary || "Событие IOLA";
   const description = args.description || "";
-  const ics = buildIcsEvent({ uid, start, end, summary, description, location: args.location || "", attendees: args.attendees || args.to || [] });
+  const ics = buildIcsEvent({
+    uid,
+    start,
+    end,
+    summary,
+    description,
+    location: args.location || "",
+    attendees: args.attendees || args.to || [],
+    rrule: args.rrule || buildIcsRrule(args),
+    reminders: normalizeCalendarReminders(args.reminders || args.reminder || args.alarm),
+  });
   const url = `${baseUrl}${encodeURIComponent(uid)}.ics`;
   await yandexDavRequest(url, token, { method: "PUT", ics: true, body: ics, timeout: 45000 });
-  return { status: "created", uid, title: summary, start: args.start || args.date || "", url };
+  return { status: "calendar-event-created", uid, title: summary, start: args.start || args.date || "", end: args.end || "", url };
+}
+
+async function yandexCalendarCreateRecurringEvent(args = {}) {
+  if (!args.confirm) throw new Error("Для создания повторяющегося события нужен аргумент confirm=true.");
+  const rrule = args.rrule || buildIcsRrule({ ...args, repeat: args.repeat || args.frequency || "weekly" });
+  return yandexCalendarCreateEvent({ ...args, rrule, confirm: true });
 }
 
 async function yandexCalendarList(args = {}) {
   const token = await requireYandexOAuthToken("organizer", "Яндекс Календарь");
-  const baseUrl = await yandexCalendarBaseUrl(token);
+  const baseUrl = await yandexCalendarBaseUrl(token, args);
   const start = toIcsDate(args.start || new Date().toISOString());
   const end = toIcsDate(args.end || new Date(Date.now() + 14 * 86400000).toISOString());
   const body = `<?xml version="1.0"?>
@@ -5011,10 +5415,113 @@ async function yandexCalendarList(args = {}) {
   <c:filter><c:comp-filter name="VCALENDAR"><c:comp-filter name="VEVENT"><c:time-range start="${start}" end="${end}"/></c:comp-filter></c:comp-filter></c:filter>
 </c:calendar-query>`;
   const text = await yandexDavRequest(baseUrl, token, { method: "REPORT", headers: { Depth: "1" }, xml: true, body, timeout: 45000 });
-  return parseIcsEvents(text).slice(0, Number(args.limit || 20));
+  return parseIcsEvents(text, { baseUrl }).slice(0, Number(args.limit || 20));
+}
+
+async function yandexCalendarSearch(query, args = {}) {
+  const needle = normalizeGeoText(query || args.query || args.title || "");
+  const rows = await yandexCalendarList({
+    ...args,
+    start: args.start || new Date(Date.now() - 90 * 86400000).toISOString(),
+    end: args.end || new Date(Date.now() + 365 * 86400000).toISOString(),
+    limit: Math.max(200, Number(args.limit || 20) * 10),
+  });
+  if (!needle) return rows.slice(0, Number(args.limit || 20));
+  return rows.filter((row) => normalizeGeoText([
+    row.title,
+    row.description,
+    row.location,
+    row.uid,
+  ].filter(Boolean).join(" ")).includes(needle)).slice(0, Number(args.limit || 20));
+}
+
+async function yandexCalendarGet(query, args = {}) {
+  const resolved = await resolveYandexCalendarEvent(query, args);
+  if (resolved.status !== "ok") return resolved;
+  return stripCalendarPrivateFields(resolved.event);
 }
 
-async function yandexCalendarBaseUrl(token) {
+async function yandexCalendarUpdate(query, args = {}) {
+  if (!args.confirm) throw new Error("Для изменения события нужен аргумент confirm=true.");
+  const resolved = await resolveYandexCalendarEvent(query, args);
+  if (resolved.status !== "ok") return resolved;
+  const event = resolved.event;
+  const start = toIcsDate(args.start || args.date || event.startIso || event.start);
+  const end = toIcsDate(args.end || event.endIso || event.end || new Date(new Date(args.start || event.startIso || Date.now()).getTime() + 3600000).toISOString());
+  const next = buildIcsEvent({
+    uid: event.uid || `${randomUUID()}@iola-cli`,
+    start,
+    end,
+    summary: args.title || args.summary || event.title || "Событие IOLA",
+    description: args.description ?? event.description ?? "",
+    location: args.location ?? event.location ?? "",
+    attendees: args.attendees || args.to || event.attendees || [],
+    rrule: args.rrule === null ? "" : (args.rrule || event.rrule || buildIcsRrule(args)),
+    reminders: args.reminders || args.reminder || args.alarm ? normalizeCalendarReminders(args.reminders || args.reminder || args.alarm) : event.reminders || [],
+  });
+  await yandexDavRequest(event.url, await requireYandexOAuthToken("organizer", "Яндекс Календарь"), { method: "PUT", ics: true, body: next, timeout: 45000 });
+  return { status: "calendar-event-updated", uid: event.uid, title: args.title || event.title, href: event.href };
+}
+
+async function yandexCalendarMove(query, args = {}) {
+  if (!args.confirm) throw new Error("Для переноса события нужен аргумент confirm=true.");
+  const dateTime = args.start || args.date ? {} : extractDateTimeFromText(args.text || args.source_question || "");
+  const start = args.start || args.date || dateTime.start;
+  if (!start) throw new Error("Укажите новую дату/время события.");
+  const end = args.end || dateTime.end || new Date(new Date(start).getTime() + 3600000).toISOString();
+  return yandexCalendarUpdate(query, { ...args, start, end, confirm: true });
+}
+
+async function yandexCalendarAddReminder(query, args = {}) {
+  if (!args.confirm) throw new Error("Для добавления напоминания нужен аргумент confirm=true.");
+  const minutes = Number(args.minutes || args.beforeMinutes || String(args.reminder || "").match(/\d+/u)?.[0] || 15);
+  return yandexCalendarUpdate(query, { ...args, reminders: [`-${minutes}`], confirm: true });
+}
+
+async function yandexCalendarDelete(query, args = {}) {
+  if (!args.confirm) throw new Error("Для удаления события нужен аргумент confirm=true.");
+  const resolved = await resolveYandexCalendarEvent(query, args);
+  if (resolved.status !== "ok") return resolved;
+  const token = await requireYandexOAuthToken("organizer", "Яндекс Календарь");
+  await yandexDavRequest(resolved.event.url, token, { method: "DELETE", timeout: 45000 });
+  return { status: "calendar-event-deleted", uid: resolved.event.uid, title: resolved.event.title, href: resolved.event.href };
+}
+
+async function resolveYandexCalendarEvent(query, args = {}) {
+  const uid = String(args.uid || "").trim();
+  const href = String(args.href || "").trim();
+  if (href) {
+    const token = await requireYandexOAuthToken("organizer", "Яндекс Календарь");
+    const url = new URL(href, "https://caldav.yandex.ru/").toString();
+    const ics = await yandexDavRequest(url, token, { method: "GET", timeout: 45000 });
+    const event = parseIcsEvents(ics, { baseUrl: url.replace(/[^/]+$/u, "") })[0];
+    return event ? { status: "ok", event: { ...event, href, url, ics } } : { status: "not-found", query: href };
+  }
+  const needle = normalizeGeoText(uid || query || args.query || args.title || "");
+  const rows = await yandexCalendarSearch("", {
+    ...args,
+    start: args.startRange || args.start || new Date(Date.now() - 365 * 86400000).toISOString(),
+    end: args.endRange || args.end || new Date(Date.now() + 365 * 86400000).toISOString(),
+    limit: 500,
+  });
+  const matches = rows.filter((row) => {
+    if (uid && row.uid === uid) return true;
+    const haystack = normalizeGeoText([row.title, row.description, row.location, row.start, row.startIso, row.end, row.endIso, row.uid, row.href].filter(Boolean).join(" "));
+    return needle && haystack.includes(needle);
+  });
+  if (!matches.length) return { status: "not-found", kind: "calendar-event", query: query || uid };
+  if (matches.length > 1 && !args.selectFirst) return { status: "ambiguous", kind: "calendar-event", query: query || uid, events: matches.slice(0, 10).map(stripCalendarPrivateFields) };
+  return { status: "ok", event: matches[0] };
+}
+
+async function yandexCalendarBaseUrl(token, args = {}) {
+  const calendars = await yandexCalendarCollections(token);
+  const selected = pickYandexCalendar(calendars, args);
+  if (!selected) throw new Error("В Яндекс Календаре не найдена календарная коллекция.");
+  return selected.url;
+}
+
+async function yandexCalendarCollections(token) {
   const root = "https://caldav.yandex.ru/";
   const principalXml = await yandexDavRequest(root, token, {
     method: "PROPFIND",
@@ -5038,9 +5545,99 @@ async function yandexCalendarBaseUrl(token) {
     xml: true,
     body: "<?xml version=\"1.0\"?><d:propfind xmlns:d=\"DAV:\"><d:prop><d:displayname/><d:resourcetype/></d:prop></d:propfind>",
   });
-  const calendarHref = extractCalendarCollectionHref(listXml);
-  if (!calendarHref) throw new Error("В Яндекс Календаре не найдена календарная коллекция.");
-  return new URL(calendarHref, root).toString();
+  return extractCalendarCollections(listXml).map((row) => ({ ...row, url: new URL(row.href, root).toString() }));
+}
+
+function pickYandexCalendar(calendars, args = {}) {
+  const query = normalizeGeoText(args.calendar || args.calendarName || args.name || "");
+  if (query) {
+    const found = calendars.find((row) => normalizeGeoText(`${row.name} ${row.href}`).includes(query));
+    if (found) return found;
+  }
+  return calendars.find((row) => !/\/(?:inbox|outbox)\//iu.test(row.href)) || calendars[0] || null;
+}
+
+async function yandexDocsStatus() {
+  const info = await yandexDiskInfo();
+  await ensureYandexDiskDir(`${CLOUD_DEFAULT_REMOTE_DIR}/docs`, { allowExisting: true });
+  return { status: "ok", provider: "yandex-disk", folder: `${CLOUD_DEFAULT_REMOTE_DIR}/docs`, totalSpace: info.totalSpace, usedSpace: info.usedSpace };
+}
+
+async function yandexDocsList(args = {}) {
+  const folder = normalizeCloudUserPath(args.path || args.folder || `${CLOUD_DEFAULT_REMOTE_DIR}/docs`, "yandex-disk");
+  const rows = await yandexDiskListRecursive(folder, { depth: Number(args.depth || 3), limit: Number(args.limit || 100) }).catch(() => []);
+  return rows.filter(isYandexDocumentResource).slice(0, Number(args.limit || 50));
+}
+
+async function yandexDocsFind(query, args = {}) {
+  const needle = normalizeGeoText(query || args.query || "");
+  const rows = await yandexDocsList({ ...args, limit: Math.max(200, Number(args.limit || 20) * 10) });
+  if (!needle) return rows.slice(0, Number(args.limit || 20));
+  return rows.filter((row) => normalizeGeoText(`${row.name} ${row.path}`).includes(needle)).slice(0, Number(args.limit || 20));
+}
+
+async function yandexDocsCreateText(args = {}) {
+  if (!args.confirm) throw new Error("Для создания документа нужен аргумент confirm=true.");
+  const text = String(args.text || args.content || "").trim();
+  if (!text) throw new Error("Текст документа пустой.");
+  const ext = normalizeYandexDocExtension(args.format || args.ext || path.extname(args.path || args.remotePath || ""));
+  const title = slugYandexDiskName(args.title || args.name || `document-${timestampForFile()}`);
+  const remotePath = normalizeCloudUserPath(args.path || args.remotePath || `${CLOUD_DEFAULT_REMOTE_DIR}/docs/${title}${title.endsWith(ext) ? "" : ext}`, "yandex-disk");
+  const saved = await yandexDiskSaveText(text, remotePath);
+  return { ...saved, status: "document-created", title: path.posix.basename(remotePath), remote: remotePath };
+}
+
+async function yandexDocsRead(target, args = {}) {
+  const doc = await resolveYandexDoc(target, args);
+  if (doc.status !== "ok") return doc;
+  if (!/\.(txt|md|csv|json|html)$/iu.test(doc.path)) {
+    return { status: "binary-document", remote: doc.path, name: doc.name, message: "Этот документ не текстовый. Его можно скачать, переименовать, удалить или опубликовать ссылкой." };
+  }
+  return yandexDiskReadText(doc.path, args);
+}
+
+async function yandexDocsShare(target, args = {}) {
+  if (!args.confirm) throw new Error("Для публикации документа нужен аргумент confirm=true.");
+  const doc = await resolveYandexDoc(target, args);
+  if (doc.status !== "ok") return doc;
+  return yandexDiskShareWithQr(doc.path, { ...args, confirm: true });
+}
+
+async function yandexDocsRename(target, newName, args = {}) {
+  if (!args.confirm) throw new Error("Для переименования документа нужен аргумент confirm=true.");
+  const doc = await resolveYandexDoc(target, args);
+  if (doc.status !== "ok") return doc;
+  if (!newName) throw new Error("Укажите новое имя документа.");
+  return yandexDiskRename(doc.path, newName, { ...args, confirm: true, overwrite: args.overwrite !== false });
+}
+
+async function yandexDocsDelete(target, args = {}) {
+  if (!args.confirm) throw new Error("Для удаления документа нужен аргумент confirm=true.");
+  const doc = await resolveYandexDoc(target, args);
+  if (doc.status !== "ok") return doc;
+  return yandexDiskDelete(doc.path, args);
+}
+
+async function resolveYandexDoc(target, args = {}) {
+  const value = String(target || "").trim();
+  if (value.startsWith("/")) {
+    const statRow = await yandexDiskStat(value);
+    return isYandexDocumentResource(statRow) ? { status: "ok", ...statRow } : { status: "not-document", path: value };
+  }
+  const rows = await yandexDocsFind(value, { ...args, limit: 10 });
+  if (!rows.length) return { status: "not-found", query: value };
+  if (rows.length > 1 && !args.selectFirst) return { status: "ambiguous", query: value, docs: rows.slice(0, 10) };
+  return { status: "ok", ...rows[0] };
+}
+
+function isYandexDocumentResource(row = {}) {
+  return row.type !== "dir" && /\.(docx|xlsx|pptx|pdf|txt|md|html|csv|json)$/iu.test(row.name || row.path || "");
+}
+
+function normalizeYandexDocExtension(value) {
+  const ext = String(value || "").replace(/^\./u, "").toLocaleLowerCase("en-US");
+  if (["txt", "md", "html", "csv", "json"].includes(ext)) return `.${ext}`;
+  return ".md";
 }
 
 async function yandexContactsStatus() {
@@ -5392,6 +5989,47 @@ async function yandexContactFromPublicEntity(args = {}) {
   });
 }
 
+async function yandexContactFullPack(args = {}) {
+  if (!args.confirm) throw new Error("Для полного сценария по контакту нужен аргумент confirm=true.");
+  const resolved = await resolveYandexContact(args.query || args.contact || args.name || "", args);
+  if (resolved.status !== "ok") return resolved;
+  const contact = resolved.contact;
+  const folder = await yandexContactCreateDiskFolder({ query: contact.email || contact.name || contact.phone, confirm: true, selectFirst: true });
+  const noteText = [
+    `# ${contact.name || contact.email || contact.phone}`,
+    "",
+    `Email: ${contact.email || "-"}`,
+    `Телефон: ${contact.phone || "-"}`,
+    `Адрес: ${contact.address || "-"}`,
+    `Организация: ${contact.org || "-"}`,
+    "",
+    args.note || args.text || "Пакет контакта создан IOLA CLI.",
+  ].join("\n");
+  const doc = await yandexDocsCreateText({ path: path.posix.join(folder.remote, "meeting-note.md"), text: noteText, confirm: true });
+  const shared = await yandexDiskShareWithQr(folder.remote, { confirm: true });
+  const dateTime = args.start || args.date ? { start: args.start || args.date, end: args.end } : extractDateTimeFromText(args.text || args.source_question || "");
+  let event = null;
+  if (args.createEvent !== false && contact.email) {
+    event = await yandexCalendarCreateEvent({
+      ...dateTime,
+      title: args.title || `Встреча: ${contact.name || contact.email}`,
+      description: [`Папка контакта: ${folder.remote}`, `Ссылка: ${shared.publicUrl}`, args.note || ""].filter(Boolean).join("\n"),
+      attendees: [contact.email],
+      confirm: true,
+    });
+  }
+  let sent = null;
+  if ((args.send || args.email) && contact.email) {
+    sent = await yandexMailSend({
+      to: [contact.email],
+      subject: args.subject || `Материалы IOLA: ${contact.name || contact.email}`,
+      text: [args.message || "Подготовил материалы.", `Ссылка: ${shared.publicUrl}`, `QR-код: ${shared.qrPublicUrl}`].join("\n"),
+      confirm: true,
+    });
+  }
+  return { status: "contact-full-pack-created", contact: contact.name || contact.email, folder: folder.remote, doc: doc.remote, publicUrl: shared.publicUrl, qrPublicUrl: shared.qrPublicUrl, event: event?.uid || "", sentTo: sent?.to || [] };
+}
+
 async function resolveYandexContact(query, args = {}) {
   const rows = await yandexContactsList({ limit: Math.max(500, Number(args.limit || 100)), full: true });
   const normalized = normalizeContactLookupText(query || args.query || args.name || args.email || args.phone || "");
@@ -5639,25 +6277,92 @@ async function yandexContactsBaseUrl(token) {
   return new URL(addressBookHref, root).toString();
 }
 
+async function yandexTelemostStatus() {
+  const calendar = await yandexCalendarStatus();
+  return {
+    status: "calendar-fallback",
+    provider: "yandex-telemost",
+    calendar: calendar.displayName,
+    message: "Для обычного OAuth-подключения CLI использует календарное событие. Прямой Telemost API проверяется отдельно и может быть доступен только аккаунтам/организациям Яндекс 360.",
+  };
+}
+
 async function yandexTelemostCreateEvent(args = {}) {
+  if (!args.confirm) throw new Error("Для создания встречи нужен аргумент confirm=true.");
+  const telemost = await tryCreateYandexTelemostMeeting(args).catch((error) => ({
+    status: "telemost-api-unavailable",
+    error: error instanceof Error ? error.message : String(error),
+  }));
   const description = [
     args.description || "",
     "",
-    "Телемост: создайте ссылку в Яндекс Календаре, если интерфейс календаря предложит видеовстречу.",
+    telemost.joinUrl ? `Ссылка Телемоста: ${telemost.joinUrl}` : "Телемост: прямое создание ссылки через API недоступно для текущего OAuth-подключения. Событие создано в календаре как встреча; ссылку можно добавить вручную в Яндекс Календаре.",
   ].join("\n").trim();
-  return yandexCalendarCreateEvent({ ...args, description });
+  const event = await yandexCalendarCreateEvent({
+    ...args,
+    title: args.title || args.summary || "Телемост IOLA",
+    description,
+    location: telemost.joinUrl || args.location || "Яндекс Телемост",
+    confirm: true,
+  });
+  return { ...event, status: telemost.joinUrl ? "telemost-event-created" : "telemost-calendar-fallback-created", telemost };
 }
 
-function buildIcsEvent({ uid, start, end, summary, description, location, attendees = [] }) {
+async function tryCreateYandexTelemostMeeting(args = {}) {
+  const token = await requireYandexOAuthToken("organizer", "Яндекс Телемост");
+  const endpoints = [
+    "https://cloud-api.yandex.net/v1/telemost/meetings",
+    "https://api360.yandex.net/v1/telemost/meetings",
+  ];
+  let lastError = "";
+  for (const endpoint of endpoints) {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `OAuth ${token}`,
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        title: args.title || args.summary || "Телемост IOLA",
+        description: args.description || "",
+      }),
+      signal: AbortSignal.timeout(15000),
+    }).catch((error) => ({ ok: false, status: 0, statusText: error.message, text: async () => error.message }));
+    const text = await response.text().catch(() => "");
+    if (response.ok) {
+      const payload = text ? JSON.parse(text) : {};
+      return {
+        status: "telemost-api-created",
+        endpoint,
+        id: payload.id || payload.meeting_id || "",
+        joinUrl: payload.join_url || payload.url || payload.link || payload.meeting_url || "",
+        raw: payload,
+      };
+    }
+    lastError = `${endpoint}: ${response.status} ${response.statusText} ${sanitizeSecretFromText(text.slice(0, 500), token)}`;
+    if (![404, 405].includes(Number(response.status))) break;
+  }
+  throw new Error(lastError || "Telemost API недоступен.");
+}
+
+function buildIcsEvent({ uid, start, end, summary, description, location, attendees = [], rrule = "", reminders = [] }) {
   const escape = (value) => String(value || "").replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/,/g, "\\,").replace(/;/g, "\\;");
   const attendeeLines = (Array.isArray(attendees) ? attendees : [attendees])
     .map((email) => String(email || "").trim())
     .filter((email) => /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/iu.test(email))
     .map((email) => `ATTENDEE;CN=${escape(email)};ROLE=REQ-PARTICIPANT:mailto:${email}`);
+  const reminderBlocks = normalizeCalendarReminders(reminders).map((minutes) => [
+    "BEGIN:VALARM",
+    `TRIGGER:-PT${Math.max(1, Math.abs(Number(minutes) || 15))}M`,
+    "ACTION:DISPLAY",
+    `DESCRIPTION:${escape(summary || "Напоминание")}`,
+    "END:VALARM",
+  ].join("\r\n"));
   return [
     "BEGIN:VCALENDAR",
     "VERSION:2.0",
     "PRODID:-//IOLA CLI//Yandex Calendar//RU",
+    "CALSCALE:GREGORIAN",
     "BEGIN:VEVENT",
     `UID:${uid}`,
     `DTSTAMP:${toIcsDate(new Date().toISOString())}`,
@@ -5666,7 +6371,9 @@ function buildIcsEvent({ uid, start, end, summary, description, location, attend
     `SUMMARY:${escape(summary)}`,
     description ? `DESCRIPTION:${escape(description)}` : "",
     location ? `LOCATION:${escape(location)}` : "",
+    rrule ? `RRULE:${rrule}` : "",
     ...attendeeLines,
+    ...reminderBlocks,
     "END:VEVENT",
     "END:VCALENDAR",
     "",
@@ -5679,15 +6386,105 @@ function toIcsDate(value) {
   return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/u, "Z");
 }
 
-function parseIcsEvents(xmlOrIcs) {
-  const decoded = decodeXml(stripXmlTags(xmlOrIcs));
-  return decoded.split("BEGIN:VEVENT").slice(1).map((chunk) => ({
-    uid: chunk.match(/\nUID:([^\n\r]+)/u)?.[1] || "",
-    title: chunk.match(/\nSUMMARY:([^\n\r]+)/u)?.[1] || "",
-    start: chunk.match(/\nDTSTART[^:]*:([^\n\r]+)/u)?.[1] || "",
-    end: chunk.match(/\nDTEND[^:]*:([^\n\r]+)/u)?.[1] || "",
-    location: chunk.match(/\nLOCATION:([^\n\r]+)/u)?.[1] || "",
-  })).filter((item) => item.uid || item.title);
+function parseIcsEvents(xmlOrIcs, options = {}) {
+  const text = String(xmlOrIcs || "");
+  const responses = text.split(/<[^:>]*:?response[^>]*>/iu).slice(1);
+  if (responses.length) {
+    return responses.flatMap((response) => {
+      const href = decodeXml(stripXmlTags(response.match(/<[^:>]*:?href[^>]*>([\s\S]*?)<\/[^:>]*:?href>/iu)?.[1] || "")).trim();
+      const calendarData = response.match(/<[^:>]*:?calendar-data[^>]*>([\s\S]*?)<\/[^:>]*:?calendar-data>/iu)?.[1] || response;
+      return parseIcsEvents(calendarData, options).map((row) => ({
+        ...row,
+        href: row.href || href,
+        url: row.url || (href ? new URL(href, options.baseUrl || "https://caldav.yandex.ru/").toString() : ""),
+      }));
+    });
+  }
+  const decoded = decodeXml(stripXmlTags(text));
+  return decoded.split("BEGIN:VEVENT").slice(1).map((chunk) => {
+    const lines = unfoldIcsLines(`BEGIN:VEVENT${chunk}`);
+    const uid = icsValue(lines, "UID");
+    const start = icsValue(lines, "DTSTART");
+    const end = icsValue(lines, "DTEND");
+    return {
+      uid,
+      title: unescapeIcsValue(icsValue(lines, "SUMMARY")),
+      start,
+      end,
+      startIso: icsDateToIso(start),
+      endIso: icsDateToIso(end),
+      location: unescapeIcsValue(icsValue(lines, "LOCATION")),
+      description: unescapeIcsValue(icsValue(lines, "DESCRIPTION")),
+      rrule: icsValue(lines, "RRULE"),
+      attendees: icsValues(lines, "ATTENDEE").map((value) => value.replace(/^mailto:/iu, "")),
+      reminders: parseIcsReminderMinutes(lines),
+      ics: decoded.includes("BEGIN:VCALENDAR") ? decoded : "",
+    };
+  }).filter((item) => item.uid || item.title);
+}
+
+function unfoldIcsLines(value) {
+  return String(value || "")
+    .replace(/\r/g, "")
+    .replace(/\n[ \t]/g, "")
+    .split(/\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function icsValues(lines, property) {
+  const prop = String(property || "").toLocaleUpperCase("en-US");
+  return lines
+    .filter((line) => line.toLocaleUpperCase("en-US").startsWith(`${prop};`) || line.toLocaleUpperCase("en-US").startsWith(`${prop}:`))
+    .map((line) => line.slice(line.indexOf(":") + 1).trim())
+    .filter(Boolean);
+}
+
+function icsValue(lines, property) {
+  return icsValues(lines, property)[0] || "";
+}
+
+function unescapeIcsValue(value) {
+  return String(value || "")
+    .replace(/\\n/giu, "\n")
+    .replace(/\\,/gu, ",")
+    .replace(/\\;/gu, ";")
+    .replace(/\\\\/gu, "\\")
+    .trim();
+}
+
+function icsDateToIso(value) {
+  const text = String(value || "").trim();
+  const match = text.match(/^(\d{4})(\d{2})(\d{2})T?(\d{2})?(\d{2})?(\d{2})?Z?$/u);
+  if (!match) return "";
+  const iso = `${match[1]}-${match[2]}-${match[3]}T${match[4] || "00"}:${match[5] || "00"}:${match[6] || "00"}${text.endsWith("Z") ? "Z" : ""}`;
+  const date = new Date(iso);
+  return Number.isNaN(date.getTime()) ? "" : date.toISOString();
+}
+
+function parseIcsReminderMinutes(lines) {
+  return lines
+    .filter((line) => /^TRIGGER:/iu.test(line))
+    .map((line) => Number(line.match(/PT(\d+)M/iu)?.[1] || 0))
+    .filter(Boolean);
+}
+
+function normalizeCalendarReminders(value) {
+  const rows = Array.isArray(value) ? value : String(value || "").split(/[;,]/u);
+  return rows.map((item) => Number(String(item).match(/\d+/u)?.[0] || 0)).filter(Boolean);
+}
+
+function buildIcsRrule(args = {}) {
+  const repeat = String(args.repeat || args.frequency || "").toLocaleLowerCase("ru-RU");
+  if (!repeat && !args.count && !args.until) return "";
+  const freq = /день|daily|day/iu.test(repeat) ? "DAILY"
+    : /месяц|monthly|month/iu.test(repeat) ? "MONTHLY"
+      : /год|year|yearly|annual/iu.test(repeat) ? "YEARLY"
+        : "WEEKLY";
+  const parts = [`FREQ=${freq}`];
+  if (args.count) parts.push(`COUNT=${Number(args.count)}`);
+  if (args.until) parts.push(`UNTIL=${toIcsDate(args.until)}`);
+  return parts.join(";");
 }
 
 function extractDavHref(xml, propertyName) {
@@ -5706,6 +6503,24 @@ function extractCalendarCollectionHref(xml) {
   return "";
 }
 
+function extractCalendarCollections(xml) {
+  const responses = String(xml || "").split(/<[^:>]*:?response[^>]*>/iu).slice(1);
+  const rows = [];
+  for (const response of responses) {
+    if (!/<[^:>]*:?calendar(?:\s|>|\/)/iu.test(response)) continue;
+    const href = decodeXml(stripXmlTags(response.match(/<[^:>]*:?href[^>]*>([\s\S]*?)<\/[^:>]*:?href>/iu)?.[1] || "")).trim();
+    if (!href || /\/(?:inbox|outbox)\//iu.test(href)) continue;
+    const name = stripXmlTags(response.match(/<[^:>]*:?displayname[^>]*>([\s\S]*?)<\/[^:>]*:?displayname>/iu)?.[1] || "").trim() || path.posix.basename(href.replace(/\/$/u, ""));
+    rows.push({ provider: "yandex-calendar", href, name, type: "calendar" });
+  }
+  return rows;
+}
+
+function stripCalendarPrivateFields(row = {}) {
+  const { ics: _ics, url: _url, ...rest } = row;
+  return rest;
+}
+
 function extractAddressBookCollectionHref(xml) {
   const responses = String(xml || "").split(/<[^:>]*:?response[^>]*>/iu).slice(1);
   for (const response of responses) {
@@ -10654,6 +11469,13 @@ function isCronDue(job) {
     return !lastRun || now.getTime() - lastRun.getTime() >= Number(everyDays[1]) * 24 * 60 * 60 * 1000;
   }
   if (normalized.includes("каждый день") || normalized.includes("daily")) {
+    const time = normalized.match(/(\d{1,2}):(\d{2})/u);
+    if (time) {
+      const dueAt = new Date(now);
+      dueAt.setHours(Number(time[1]), Number(time[2]), 0, 0);
+      const ranToday = lastRun && lastRun.toISOString().slice(0, 10) === now.toISOString().slice(0, 10);
+      return now >= dueAt && !ranToday;
+    }
     return !lastRun || now.toISOString().slice(0, 10) !== lastRun.toISOString().slice(0, 10);
   }
   if (normalized.includes("каждую неделю") || normalized.includes("weekly")) {
@@ -11205,6 +12027,49 @@ async function buildYandexDirectAnswer(question, history = []) {
       ].join("\n");
     }
 
+    if (/(дайджест|сводк)/iu.test(normalized) && /(яндекс|почт|календар|контакт|диск)/iu.test(normalized)) {
+      if (/(включ|запусти|начни|поставь|создай)/iu.test(normalized) && /(кажд|ежеднев|авто|регуляр)/iu.test(normalized)) {
+        const time = question.match(/(\d{1,2}:\d{2})/u)?.[1] || "09:00";
+        const result = await yandexDailyDigestEnable({ time, email: /email|почт[уы]|письм/iu.test(normalized), save: true });
+        return `Ежедневный дайджест включен: каждый день ${result.time}.`;
+      }
+      if (/(выключ|отключ|останов|убери)/iu.test(normalized)) {
+        await yandexDailyDigestDisable();
+        return "Ежедневный дайджест выключен.";
+      }
+      const result = await yandexDailyDigestTick({ force: true, save: true, email: /отправь|email|почт[уы]/iu.test(normalized) });
+      return [result.text, result.remote ? `\nСохранено: ${result.remote}` : ""].join("").trim();
+    }
+
+    if (/(календар|событи|встреч)/iu.test(normalized) && /(напомин|уведом|следи|монитор|авто|регуляр)/iu.test(normalized)) {
+      if (/(включ|запусти|начни|поставь|создай)/iu.test(normalized)) {
+        const minutes = Number(question.match(/(\d+)\s*(?:мин|минут)/iu)?.[1] || 15);
+        await yandexCalendarRemindersEnable(minutes);
+        return `Проверка календарных напоминаний включена: каждые ${minutes} минут.`;
+      }
+      if (/(выключ|отключ|останов|убери)/iu.test(normalized)) {
+        await yandexCalendarRemindersDisable();
+        return "Проверка календарных напоминаний выключена.";
+      }
+      const result = await yandexCalendarRemindersTick({ force: true });
+      if (!result.events.length) return "Ближайших событий для напоминания нет.";
+      return ["Ближайшие события:", ...result.events.map((row, index) => `${index + 1}. ${row.title || row.uid} — ${row.startIso || row.start || "-"}`)].join("\n");
+    }
+
+    if (/(диск|яндекс.?диск|документ)/iu.test(normalized) && /(провер|обслуж|maintenance|аудит|регуляр|авто)/iu.test(normalized)) {
+      if (/(включ|запусти|начни|поставь|создай)/iu.test(normalized)) {
+        const days = Number(question.match(/(\d+)\s*(?:дн|день|дня|дней)/iu)?.[1] || 7);
+        await yandexDiskMaintenanceEnable(days);
+        return `Проверка Яндекс Диска включена: каждые ${days} дней.`;
+      }
+      if (/(выключ|отключ|останов|убери)/iu.test(normalized)) {
+        await yandexDiskMaintenanceDisable();
+        return "Проверка Яндекс Диска выключена.";
+      }
+      const result = await yandexDiskMaintenanceTick({ force: true });
+      return `Проверка Яндекс Диска выполнена. Документов: ${result.docs}, публичных ссылок: ${result.publicLinks}. Отчет: ${result.remote}.`;
+    }
+
     if (/(контакт|адресн)/iu.test(normalized) && !mailFollowup && !isExplicitYandexDiskPathDelete(question)) {
       return await buildYandexContactsDirectAnswer(question, normalized);
     }
@@ -11252,6 +12117,12 @@ async function buildYandexDirectAnswer(question, history = []) {
         const result = await yandexMailSaveToDisk(uid, { mailbox: extractYandexMailboxName(question) || "INBOX" });
         return `Письмо #${uid} сохранено на Яндекс Диск: ${result.remote || result.path}.`;
       }
+      if (/(пакет|комплект|встреч).{0,80}(письм|письма)|(?:письм|письма).{0,80}(пакет|комплект|встреч)/iu.test(normalized) && /(диск|ссылк|qr|календар|встреч)/iu.test(normalized)) {
+        const uid = resolveYandexMailUidFromQuestion(question, previousAssistantText);
+        if (!uid) return "Из какого письма создать пакет? Укажите номер из списка или UID.";
+        const result = await yandexMailMeetingPack(uid, { mailbox: extractYandexMailboxName(question) || "INBOX", ...extractDateTimeFromText(question), confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
       if (/(создай|добавь).{0,40}(событи|встреч|календар)/iu.test(normalized)) {
         const uid = resolveYandexMailUidFromQuestion(question, previousAssistantText);
         if (!uid) return "Из какого письма создать событие? Укажите номер из списка или UID.";
@@ -11356,10 +12227,93 @@ async function buildYandexDirectAnswer(question, history = []) {
       return ["Яндекс Почта:", ...rows.map((row, index) => `${index + 1}. ${formatYandexMailSummary(row)}`)].join("\n");
     }
 
-    if (/(календар|событи)/iu.test(normalized) && !/(создай|добавь|запланируй)/iu.test(normalized)) {
+    if (/(документ|документы|docs|360)/iu.test(normalized) && /(яндекс|диск|облак|360|docs)/iu.test(normalized)) {
+      if (/(статус|проверь|работает|доступ)/iu.test(normalized)) {
+        const result = await yandexDocsStatus();
+        return `Яндекс Документы через Диск подключены. Папка: ${result.folder}.`;
+      }
+      if (/(создай|сделай|запиши|сохрани)/iu.test(normalized)) {
+        const text = extractShareMessage(question) || cleanupCloudSaveText(question);
+        if (!text) return "Укажите текст документа. Пример: создай документ на Яндекс Диске текст: ...";
+        const result = await yandexDocsCreateText({
+          title: extractYandexDocTitle(question),
+          text,
+          format: /html/iu.test(normalized) ? "html" : /txt|текстов/iu.test(normalized) ? "txt" : "md",
+          confirm: true,
+        });
+        return `Документ создан на Яндекс Диске: ${result.remote}.`;
+      }
+      if (/(прочитай|открой|покажи\s+текст)/iu.test(normalized)) {
+        const result = await yandexDocsRead(extractCloudPath(question) || cleanupYandexQuery(question), {});
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(ссылк|поделись|опубликуй|qr|qr-код)/iu.test(normalized)) {
+        const result = await yandexDocsShare(extractCloudPath(question) || cleanupYandexQuery(question), { confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(переимен|rename)/iu.test(normalized)) {
+        const result = await yandexDocsRename(extractCloudPath(question) || cleanupYandexQuery(question), extractCloudNewName(question), { confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(удали|удалить)/iu.test(normalized)) {
+        const result = await yandexDocsDelete(extractCloudPath(question) || cleanupYandexQuery(question), { confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      const rows = /(найди|поиск)/iu.test(normalized)
+        ? await yandexDocsFind(cleanupYandexQuery(question), { limit: 20 })
+        : await yandexDocsList({ limit: 20 });
+      if (!rows.length) return "Документы на Яндекс Диске не найдены.";
+      return ["Документы на Яндекс Диске:", ...rows.map((row, index) => `${index + 1}. ${row.name} — ${row.path}`)].join("\n");
+    }
+
+    if (/(календар|событи|встреч|телемост)/iu.test(normalized)) {
+      if (/(статус|проверь|работает|доступ)/iu.test(normalized) && /(календар|телемост)/iu.test(normalized)) {
+        const result = /телемост/iu.test(normalized) ? await yandexTelemostStatus() : await yandexCalendarStatus();
+        return /телемост/iu.test(normalized)
+          ? `${result.message} Календарь: ${result.calendar || "-"}.`
+          : `Яндекс Календарь подключен: ${result.displayName || result.url}. Календарей: ${result.calendars || 1}.`;
+      }
+      if (/(какие|список).{0,30}(календар|календари)|календари/iu.test(normalized)) {
+        const rows = await yandexCalendarCalendars({ limit: 20 });
+        if (!rows.length) return "Календари Яндекса не найдены.";
+        return ["Яндекс Календари:", ...rows.map((row, index) => `${index + 1}. ${row.name} — ${row.href}`)].join("\n");
+      }
+      if (/(напомин|уведом)/iu.test(normalized) && /(добав|постав|создай)/iu.test(normalized)) {
+        const minutes = Number(question.match(/(\d+)\s*(?:мин|минут)/iu)?.[1] || 15);
+        const result = await yandexCalendarAddReminder(cleanupCalendarEventQuery(question), { minutes, confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(создай|добавь|запланируй|назначь)/iu.test(normalized)) {
+        const dateTime = extractDateTimeFromText(question);
+        const title = extractCalendarTitle(question) || (/телемост/iu.test(normalized) ? "Телемост IOLA" : "Событие IOLA");
+        const args = { ...dateTime, title, description: extractShareMessage(question) || "", confirm: true };
+        const result = /телемост/iu.test(normalized)
+          ? await yandexTelemostCreateEvent(args)
+          : /кажд|еженед|ежеднев|ежемесяч|повтор/iu.test(normalized)
+            ? await yandexCalendarCreateRecurringEvent({ ...args, ...extractCalendarRepeat(question), confirm: true })
+            : await yandexCalendarCreateEvent(args);
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(перенеси|перемести|измени\s+время|смени\s+время)/iu.test(normalized)) {
+        const result = await yandexCalendarMove(cleanupCalendarEventQuery(question), { ...extractDateTimeFromText(question), confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(переимен|измени\s+назв|смени\s+назв)/iu.test(normalized)) {
+        const result = await yandexCalendarUpdate(cleanupCalendarEventQuery(question), { title: extractCalendarTitle(question), confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(удали|удалить|отмени|отменить)/iu.test(normalized)) {
+        const result = await yandexCalendarDelete(cleanupCalendarEventQuery(question), { confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(найди|поиск|где|покажи).{0,40}(событи|встреч|телемост)/iu.test(normalized)) {
+        const rows = await yandexCalendarSearch(cleanupCalendarEventQuery(question), { limit: 20 });
+        if (!rows.length) return "События в Яндекс Календаре по запросу не найдены.";
+        return ["Яндекс Календарь:", ...rows.map((row, index) => `${index + 1}. ${row.title || "(без названия)"} — ${row.startIso || row.start || "-"}${row.location ? `, ${row.location}` : ""}`)].join("\n");
+      }
       const rows = await yandexCalendarList({ limit: 10 });
       if (!rows.length) return "В ближайшие дни событий в Яндекс Календаре не найдено.";
-      return ["Яндекс Календарь:", ...rows.map((row, index) => `${index + 1}. ${row.title || "(без названия)"} — ${row.start || "-"}`)].join("\n");
+      return ["Яндекс Календарь:", ...rows.map((row, index) => `${index + 1}. ${row.title || "(без названия)"} — ${row.startIso || row.start || "-"}${row.location ? `, ${row.location}` : ""}`)].join("\n");
     }
 
     if (/(контакт|адресн)/iu.test(normalized)) {
@@ -11609,6 +12563,11 @@ async function buildYandexContactsDirectAnswer(question, normalized = "") {
     const result = await yandexContactCreateDiskFolder({ query, confirm: true });
     return formatToolResult({ rows: [result], outputs: [] }, {});
   }
+  if (/(полный|комплект|пакет|подготовь).{0,80}(контакт|клиент|человек)/iu.test(text) || /(контакт|клиент|человек).{0,80}(полный|комплект|пакет)/iu.test(text)) {
+    const query = cleanupYandexContactActionQuery(question);
+    const result = await yandexContactFullPack({ query, ...extractDateTimeFromText(question), note: extractShareMessage(question), confirm: true });
+    return formatToolResult({ rows: [result], outputs: [] }, {});
+  }
   if (/(отправь|пошли).{0,80}(ссылк|qr|qr-код|диск|яндекс.?диск)/iu.test(text)) {
     const remotePath = extractCloudPath(question);
     const contact = cleanupYandexContactActionQuery(question.replace(remotePath || "", " "));
@@ -11643,6 +12602,27 @@ async function buildYandexContactsDirectAnswer(question, normalized = "") {
 async function buildUserSkillDirectAnswer(question) {
   const normalized = String(question || "").toLocaleLowerCase("ru-RU");
   if (!/(skill|скилл|скил|навык)/iu.test(normalized)) return "";
+  if (/(шаблон|template|вариант)/iu.test(normalized) && /(покажи|список|какие|list)/iu.test(normalized)) {
+    const rows = userSkillTemplates();
+    return ["Шаблоны skills:", ...rows.map((row) => `- ${row.name}: ${row.description}`)].join("\n");
+  }
+  if (/(preview|предпросмотр|покажи\s+как)/iu.test(normalized)) {
+    const name = extractUserSkillNameFromQuestion(question) || "user-skill";
+    const template = normalizeUserSkillName(question.match(/(?:шаблон|template)\s+([a-z0-9а-яё_-]+)/iu)?.[1] || "");
+    return buildUserSkillPreview({ name, template, instructions: question });
+  }
+  if (/(проверь|validate|doctor|валидац)/iu.test(normalized)) {
+    const name = extractUserSkillNameFromQuestion(question);
+    if (!name) return "Какой skill проверить? Укажите имя.";
+    const result = await userSkillValidate(name);
+    return ["Проверка skill:", ...result.checks.map((row) => `${row.status}: ${row.check} - ${row.message}`)].join("\n");
+  }
+  if (/(обнови|измени|update|edit)/iu.test(normalized)) {
+    const name = extractUserSkillNameFromQuestion(question);
+    if (!name) return "Какой skill обновить? Укажите имя.";
+    const result = await userSkillUpdate(name, { instructions: question, tools: inferUserSkillTools(question), confirm: true });
+    return `Skill обновлен: ${result.name}\nФайл: ${result.file}`;
+  }
   if (/(создай|добавь|сделай|create|new)/iu.test(normalized)) {
     const name = extractUserSkillNameFromQuestion(question) || "user-skill";
     const result = await userSkillCreate({
@@ -11650,6 +12630,7 @@ async function buildUserSkillDirectAnswer(question) {
       description: extractUserSkillDescription(question, name),
       instructions: question,
       tools: inferUserSkillTools(question),
+      template: normalizeUserSkillName(question.match(/(?:шаблон|template)\s+([a-z0-9а-яё_-]+)/iu)?.[1] || ""),
       enable: true,
       confirm: true,
     });
@@ -11682,7 +12663,7 @@ async function buildUserSkillDirectAnswer(question) {
 }
 
 function isYandexServiceQuestion(normalized) {
-  return /(яндекс|яндес|язндекс|язндекс|яндкс|yandex|почт|письм|календар|контакт|телемост|спам|чернов|отправлен|исходящ|корзин)/iu.test(String(normalized || ""));
+  return /(яндекс|яндес|язндекс|язндекс|яндкс|yandex|почт|письм|календар|контакт|телемост|документ|docs|360|спам|чернов|отправлен|исходящ|корзин)/iu.test(String(normalized || ""));
 }
 
 function isYandexIdentityQuestion(normalized) {
@@ -11967,6 +12948,38 @@ async function buildCloudDirectAnswer(question) {
   const normalized = String(question || "").toLocaleLowerCase("ru-RU");
   try {
     const provider = await getCloudProvider();
+    if (provider === "yandex-disk" && /(документ|docs|360)/iu.test(normalized)) {
+      if (/(ссылк|поделись|опубликуй|qr|qr-код)/iu.test(normalized)) {
+        const result = await yandexDocsShare(extractCloudPath(question) || cleanupCloudQuery(question), { confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(создай|сделай|запиши|сохрани)/iu.test(normalized)) {
+        const text = extractShareMessage(question) || cleanupCloudSaveText(question);
+        if (!text) return "Укажите текст документа.";
+        const result = await yandexDocsCreateText({ title: extractYandexDocTitle(question), text, confirm: true });
+        return `Документ создан на Яндекс Диске: ${result.remote}.`;
+      }
+      if (/(прочитай|открой|покажи\s+текст)/iu.test(normalized)) {
+        const result = await yandexDocsRead(extractCloudPath(question) || cleanupCloudQuery(question), {});
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(переимен|rename)/iu.test(normalized)) {
+        const result = await yandexDocsRename(extractCloudPath(question) || cleanupCloudQuery(question), extractCloudNewName(question), { confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(удали|удалить)/iu.test(normalized)) {
+        const result = await yandexDocsDelete(extractCloudPath(question) || cleanupCloudQuery(question), { confirm: true });
+        return formatToolResult({ rows: [result], outputs: [] }, {});
+      }
+      if (/(найди|поиск)/iu.test(normalized)) {
+        const rows = await yandexDocsFind(cleanupCloudQuery(question), { limit: 20 });
+        if (!rows.length) return "Документы на Яндекс Диске не найдены.";
+        return ["Документы на Яндекс Диске:", ...rows.map((row, index) => `${index + 1}. ${row.name} — ${row.path}`)].join("\n");
+      }
+      const rows = await yandexDocsList({ limit: 20 });
+      if (!rows.length) return "Документы на Яндекс Диске не найдены.";
+      return ["Документы на Яндекс Диске:", ...rows.map((row, index) => `${index + 1}. ${row.name} — ${row.path}`)].join("\n");
+    }
     if (provider === "yandex-disk" && /(мест[оа]|сколько.*занято|сколько.*свобод|инфо|статус)/iu.test(normalized)) {
       const info = await yandexDiskInfo();
       return [
@@ -12200,6 +13213,7 @@ function extractCloudPath(question) {
 function cleanupCloudPathCandidate(value) {
   return String(value || "")
     .replace(/\s+(?:по\s+почт[еуы]|на\s+почт[уые]|контакту|получател[юя]|кому|с\s+темой|тема\s*:|текст\s*:).*$/iu, "")
+    .replace(/\s+(?:на\s+яндекс.?диск(?:е)?|на\s+диск(?:е)?|в\s+облак(?:е|о)?).*/iu, "")
     .replace(/[.!?]+$/u, "")
     .trim();
 }
@@ -12249,7 +13263,50 @@ function extractMailSubject(question) {
 }
 
 function extractShareMessage(question) {
-  return String(question || "").match(/(?:текст|сообщение|body)\s*:\s*(.*)$/iu)?.[1]?.trim() || "";
+  return String(question || "").match(/(?:текст|text|сообщение|body)\s*:\s*(.*)$/iu)?.[1]?.trim() || "";
+}
+
+function extractYandexDocTitle(question) {
+  const text = String(question || "");
+  const raw = text.match(/(?:названи(?:е|ем)|имя|title)\s*:?\s*["«]?([^"».,:;]+)["»]?/iu)?.[1]?.trim()
+    || text.match(/(?:документ|файл)\s+["«]?([^"».,:;]+)["»]?/iu)?.[1]?.trim()
+    || "";
+  return raw.replace(/\s+(?:текст|text|body|сообщение)\s*:?.*$/iu, "").trim();
+}
+
+function extractCalendarTitle(question) {
+  const text = String(question || "");
+  const raw = text.match(/(?:тема|названи(?:е|ем)|title)\s*:?\s*["«]?([^"».,:;]+)["»]?/iu)?.[1]?.trim()
+    || text.match(/(?:событи[ея]|встреч[ауи]|телемост)\s+["«]?([^"».,:;]+)["»]?/iu)?.[1]?.trim()
+    || "";
+  return raw
+    .replace(/\s+(?:сегодня|завтра|послезавтра)(?:\s|$).*$/iu, "")
+    .replace(/\s+(?:в\s+\d{1,2}(?::\d{2})?|на\s+\d{1,2}[.\-/]\d{1,2}[\d.\-/]*)(?:\s|$).*$/iu, "")
+    .trim();
+}
+
+function extractCalendarRepeat(question) {
+  const text = String(question || "").toLocaleLowerCase("ru-RU");
+  const count = Number(text.match(/(\d+)\s*(?:раз|повтор)/iu)?.[1] || 0);
+  return {
+    repeat: /ежеднев|каждый\s+день/iu.test(text) ? "daily"
+      : /ежемесяч|каждый\s+месяц/iu.test(text) ? "monthly"
+        : /ежегод|каждый\s+год/iu.test(text) ? "yearly"
+          : "weekly",
+    count: count || undefined,
+  };
+}
+
+function cleanupCalendarEventQuery(question) {
+  return String(question || "")
+    .replace(/(?:создай|добавь|запланируй|назначь|перенеси|перемести|измени|смени|удали|удалить|отмени|отменить|найди|поиск|покажи|добавь\s+напоминание|поставь\s+напоминание)/giu, " ")
+    .replace(/(?:^|\s)(?:событи\p{L}*|встреч\p{L}*|телемост\p{L}*|календар\p{L}*|напомин\p{L}*|уведом\p{L}*|яндекс|на|к|ко|в|во|сегодня|завтра|послезавтра|час|часа|часов|минут|минуты)(?=\s|$)/giu, " ")
+    .replace(/\d{1,2}[.\-/]\d{1,2}(?:[.\-/]\d{2,4})?/gu, " ")
+    .replace(/\d{1,2}[:.]\d{2}/gu, " ")
+    .replace(/(?:^|\s)\d{1,3}(?=\s|$)/gu, " ")
+    .replace(/[,:;.!?«»"()]+/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
 }
 
 function parseYandexDiskPackageRequest(question) {
@@ -12826,9 +13883,9 @@ async function buildLocalToolPlan(question, providerConfig, options) {
     `Доступные tools: ${availableToolNames(options).join(", ")}.`,
     "Схема: {\"steps\":[{\"tool\":\"search_data\",\"args\":{\"dataset\":\"schools|kindergartens|all\",\"query\":\"text\",\"limit\":10}}]}",
     "Минимальные tools: search_data {dataset,query,limit}, get_card {query}, export_report {name,format,output}, file_read {path}, browser_open {url}.",
-    "Yandex tools: yandex_identity_me {}, yandex_disk_info {}, yandex_disk_ls {path}, yandex_disk_mkdir {path}, yandex_disk_find {query,path}, yandex_disk_stat {path}, yandex_disk_exists {path}, yandex_disk_read_text {path}, yandex_disk_save_text {path,text}, yandex_disk_upload {localPath,remotePath}, yandex_disk_download {remotePath,outputPath}, yandex_disk_move {from,to,confirm}, yandex_disk_copy {from,to,confirm}, yandex_disk_rename {path,name,confirm}, yandex_disk_share {path,confirm}, yandex_disk_share_qr {path,confirm}, yandex_disk_share_email {path,to,contact,subject,text,confirm}, yandex_disk_package_share_email {sourcePath,targetFolder,to,contact,mode,confirm}, yandex_disk_unshare {path}, yandex_disk_delete {path,confirm}, yandex_disk_trash_list {}, yandex_disk_restore {path,confirm}, yandex_disk_empty_trash {confirm}, yandex_mail_folders {}, yandex_mail_list {mailbox,limit,unread}, yandex_mail_search {mailbox,query}, yandex_mail_read {mailbox,uid}, yandex_mail_mark {mailbox,uid,seen}, yandex_mail_send {to,subject,text,confirm}, yandex_mail_reply {uid,text,confirm}, yandex_mail_forward {uid,to,confirm}, yandex_mail_save_to_disk {uid,path}, yandex_mail_city_context {uid}, yandex_mail_map_addresses {uid}, yandex_mail_create_task {uid,title}, yandex_calendar_list {start,end}, yandex_calendar_create_event {title,start,end,location,attendees,confirm}, yandex_contacts_list {limit}, yandex_contacts_search {query}, yandex_contacts_get {query}, yandex_contacts_create {name,email,phone,address,note,confirm}, yandex_contacts_update {query,email,phone,address,note,birthday,org,title,confirm}, yandex_contacts_delete {query,confirm}, yandex_contacts_export_csv {}, yandex_contacts_find_incomplete {}, yandex_contacts_find_duplicates {}, yandex_contacts_backup_to_disk {format,confirm}, yandex_contact_send_mail {contact,subject,text,confirm}, yandex_contact_send_disk_link_qr {contact,path,confirm}, yandex_contact_create_disk_folder {contact,confirm}, yandex_contact_create_calendar_event {contact,start,end,title,confirm}, yandex_contact_create_telemost_event {contact,start,end,title,confirm}.",
-    "Опасные Yandex tools используй только при явной просьбе пользователя и с confirm=true: yandex_disk_share, yandex_disk_share_qr, yandex_disk_share_email, yandex_disk_package_share_email, yandex_disk_delete, yandex_disk_move, yandex_disk_copy, yandex_disk_rename, yandex_disk_restore, yandex_disk_empty_trash, yandex_mail_send, yandex_mail_reply, yandex_mail_forward, yandex_mail_delete, yandex_mail_create_calendar_event, yandex_mail_sender_to_contact, yandex_contacts_create, yandex_contacts_update, yandex_contacts_delete, yandex_contacts_add_email, yandex_contacts_add_phone, yandex_contacts_add_address, yandex_contacts_backup_to_disk, yandex_contact_send_mail, yandex_contact_send_disk_link_qr, yandex_contact_create_disk_folder, yandex_contact_create_calendar_event, yandex_contact_create_telemost_event, yandex_calendar_create_event, yandex_telemost_create_event.",
-    "User skill tools: user_skill_create {name,description,instructions,tools,enable,confirm}, user_skill_enable {name}, user_skill_disable {name}, user_skill_delete {name,confirm}, user_skill_list {}. Создавай skill только по явной просьбе пользователя и с confirm=true.",
+    "Yandex tools: yandex_identity_me {}, yandex_disk_info {}, yandex_disk_ls {path}, yandex_disk_mkdir {path}, yandex_disk_find {query,path}, yandex_disk_stat {path}, yandex_disk_exists {path}, yandex_disk_read_text {path}, yandex_disk_save_text {path,text}, yandex_disk_upload {localPath,remotePath}, yandex_disk_download {remotePath,outputPath}, yandex_disk_move {from,to,confirm}, yandex_disk_copy {from,to,confirm}, yandex_disk_rename {path,name,confirm}, yandex_disk_share {path,confirm}, yandex_disk_share_qr {path,confirm}, yandex_disk_share_email {path,to,contact,subject,text,confirm}, yandex_disk_package_share_email {sourcePath,targetFolder,to,contact,mode,confirm}, yandex_disk_unshare {path}, yandex_disk_delete {path,confirm}, yandex_disk_trash_list {}, yandex_disk_restore {path,confirm}, yandex_disk_empty_trash {confirm}, yandex_mail_folders {}, yandex_mail_list {mailbox,limit,unread}, yandex_mail_search {mailbox,query}, yandex_mail_read {mailbox,uid}, yandex_mail_mark {mailbox,uid,seen}, yandex_mail_send {to,subject,text,confirm}, yandex_mail_reply {uid,text,confirm}, yandex_mail_forward {uid,to,confirm}, yandex_mail_save_to_disk {uid,path}, yandex_mail_city_context {uid}, yandex_mail_map_addresses {uid}, yandex_mail_create_task {uid,title}, yandex_mail_meeting_pack {uid,start,end,send,confirm}, yandex_calendar_calendars {}, yandex_calendar_list {start,end}, yandex_calendar_search {query,start,end}, yandex_calendar_get {query}, yandex_calendar_create_event {title,start,end,location,attendees,reminders,confirm}, yandex_calendar_update {query,title,start,end,location,description,reminders,confirm}, yandex_calendar_move {query,start,end,confirm}, yandex_calendar_delete {query,confirm}, yandex_docs_list {path}, yandex_docs_find {query}, yandex_docs_create_text {title,text,format,confirm}, yandex_docs_read {path|query}, yandex_docs_share {path|query,confirm}, yandex_docs_rename {path|query,name,confirm}, yandex_docs_delete {path|query,confirm}, yandex_contacts_list {limit}, yandex_contacts_search {query}, yandex_contacts_get {query}, yandex_contacts_create {name,email,phone,address,note,confirm}, yandex_contacts_update {query,email,phone,address,note,birthday,org,title,confirm}, yandex_contacts_delete {query,confirm}, yandex_contacts_export_csv {}, yandex_contacts_find_incomplete {}, yandex_contacts_find_duplicates {}, yandex_contacts_backup_to_disk {format,confirm}, yandex_contact_send_mail {contact,subject,text,confirm}, yandex_contact_send_disk_link_qr {contact,path,confirm}, yandex_contact_create_disk_folder {contact,confirm}, yandex_contact_create_calendar_event {contact,start,end,title,confirm}, yandex_contact_create_telemost_event {contact,start,end,title,confirm}, yandex_contact_full_pack {contact,start,end,send,confirm}, yandex_daily_digest {save,email}, yandex_calendar_reminders_tick {}, yandex_disk_maintenance_tick {}.",
+    "Опасные Yandex tools используй только при явной просьбе пользователя и с confirm=true: yandex_disk_share, yandex_disk_share_qr, yandex_disk_share_email, yandex_disk_package_share_email, yandex_disk_delete, yandex_disk_move, yandex_disk_copy, yandex_disk_rename, yandex_disk_restore, yandex_disk_empty_trash, yandex_mail_send, yandex_mail_reply, yandex_mail_forward, yandex_mail_delete, yandex_mail_create_calendar_event, yandex_mail_sender_to_contact, yandex_mail_meeting_pack, yandex_contacts_create, yandex_contacts_update, yandex_contacts_delete, yandex_contacts_add_email, yandex_contacts_add_phone, yandex_contacts_add_address, yandex_contacts_backup_to_disk, yandex_contact_send_mail, yandex_contact_send_disk_link_qr, yandex_contact_create_disk_folder, yandex_contact_create_calendar_event, yandex_contact_create_telemost_event, yandex_contact_full_pack, yandex_calendar_create_event, yandex_calendar_update, yandex_calendar_move, yandex_calendar_delete, yandex_calendar_add_reminder, yandex_docs_create_text, yandex_docs_share, yandex_docs_rename, yandex_docs_delete, yandex_telemost_create_event.",
+    "User skill tools: user_skill_create {name,description,instructions,tools,template,enable,confirm}, user_skill_update {name,instructions,tools,confirm}, user_skill_templates {}, user_skill_validate {name}, user_skill_preview {name,template,instructions}, user_skill_enable {name}, user_skill_disable {name}, user_skill_delete {name,confirm}, user_skill_list {}. Создавай или меняй skill только по явной просьбе пользователя и с confirm=true.",
     "MCP tools доступны как mcp:SERVER:TOOL, например mcp:iola-local:search.",
     "Для выгрузки CSV добавь export_report с format=csv и output, если пользователь назвал файл.",
     `Вопрос: ${question}`,
@@ -12908,6 +13965,12 @@ function inferToolPlan(question, options = {}) {
       }],
     };
   }
+  if (/(шаблон|template)/iu.test(normalized) && /(skill|скилл|скил|навык)/iu.test(normalized)) {
+    return { steps: [{ tool: "user_skill_templates", args: {} }] };
+  }
+  if (/(проверь|validate|doctor)/iu.test(normalized) && /(skill|скилл|скил|навык)/iu.test(normalized)) {
+    return { steps: [{ tool: "user_skill_validate", args: { name: extractUserSkillNameFromQuestion(question) } }] };
+  }
   if (/(яндекс|yandex)/iu.test(normalized) && /(аккаунт|профил|логин|почт[аы]|email|e-mail|кто подключен)/iu.test(normalized)) {
     return { steps: [{ tool: "yandex_identity_me", args: {} }] };
   }
@@ -12938,12 +14001,31 @@ function inferToolPlan(question, options = {}) {
     if (/(ответь|ответить|напиши\s+ответ)/iu.test(normalized)) return { steps: [{ tool: "yandex_mail_reply", args: { uid, mailbox, text: parseYandexMailReplyRequest(question).text, confirm: true } }] };
     if (/(удали|удалить|перемести\s+в\s+корзин)/iu.test(normalized)) return { steps: [{ tool: "yandex_mail_delete", args: { uid, mailbox, confirm: true } }] };
     if (/(пометь|отметь|сделай)/iu.test(normalized) && /(прочитан|непрочитан)/iu.test(normalized)) return { steps: [{ tool: "yandex_mail_mark", args: { uid, mailbox, seen: !/непрочитан/iu.test(normalized) } }] };
+    if (/(пакет|комплект)/iu.test(normalized) && uid) return { steps: [{ tool: "yandex_mail_meeting_pack", args: { uid, mailbox, ...extractDateTimeFromText(question), confirm: true } }] };
     if (/(прочитай|прочти|открой|раскрой|получи|получить)/iu.test(normalized) && uid) return { steps: [{ tool: "yandex_mail_read", args: { uid, mailbox } }] };
     if (/(найди|поиск)/iu.test(normalized)) return { steps: [{ tool: "yandex_mail_search", args: { mailbox, query: question, limit: 20 } }] };
     return { steps: [{ tool: "yandex_mail_list", args: { mailbox, limit: 10, unread: /непрочитан/iu.test(normalized) } }] };
   }
+  if (/(документ|docs|360)/iu.test(normalized) && /(яндекс|диск|облак|360|docs)/iu.test(normalized)) {
+    const target = extractCloudPath(question) || cleanupYandexQuery(question);
+    if (/(создай|сделай|запиши|сохрани)/iu.test(normalized)) return { steps: [{ tool: "yandex_docs_create_text", args: { title: extractYandexDocTitle(question), text: extractShareMessage(question) || cleanupCloudSaveText(question), confirm: true } }] };
+    if (/(прочитай|открой|текст)/iu.test(normalized)) return { steps: [{ tool: "yandex_docs_read", args: { query: target } }] };
+    if (/(ссылк|поделись|опубликуй|qr|qr-код)/iu.test(normalized)) return { steps: [{ tool: "yandex_docs_share", args: { query: target, confirm: true } }] };
+    if (/(переимен|rename)/iu.test(normalized)) return { steps: [{ tool: "yandex_docs_rename", args: { query: target, name: extractCloudNewName(question), confirm: true } }] };
+    if (/(удали|удалить)/iu.test(normalized)) return { steps: [{ tool: "yandex_docs_delete", args: { query: target, confirm: true } }] };
+    if (/(найди|поиск)/iu.test(normalized)) return { steps: [{ tool: "yandex_docs_find", args: { query: cleanupYandexQuery(question), limit: 20 } }] };
+    return { steps: [{ tool: "yandex_docs_list", args: { limit: 20 } }] };
+  }
   if (/(календар|событи|встреч|телемост)/iu.test(normalized)) {
-    return { steps: [{ tool: normalized.includes("телемост") ? "yandex_telemost_create_event" : "yandex_calendar_list", args: { limit: 20 } }] };
+    if (/(напомин|уведом|следи|монитор)/iu.test(normalized) && /(проверь|tick|сейчас)/iu.test(normalized)) return { steps: [{ tool: "yandex_calendar_reminders_tick", args: { force: true } }] };
+    if (/(создай|добавь|запланируй|назначь)/iu.test(normalized)) {
+      const dateTime = extractDateTimeFromText(question);
+      return { steps: [{ tool: /телемост/iu.test(normalized) ? "yandex_telemost_create_event" : "yandex_calendar_create_event", args: { ...dateTime, title: extractCalendarTitle(question) || (/телемост/iu.test(normalized) ? "Телемост IOLA" : "Событие IOLA"), confirm: true } }] };
+    }
+    if (/(перенеси|перемести|измени\s+время|смени\s+время)/iu.test(normalized)) return { steps: [{ tool: "yandex_calendar_move", args: { query: cleanupCalendarEventQuery(question), ...extractDateTimeFromText(question), confirm: true } }] };
+    if (/(удали|удалить|отмени|отменить)/iu.test(normalized)) return { steps: [{ tool: "yandex_calendar_delete", args: { query: cleanupCalendarEventQuery(question), confirm: true } }] };
+    if (/(найди|поиск)/iu.test(normalized)) return { steps: [{ tool: "yandex_calendar_search", args: { query: cleanupCalendarEventQuery(question), limit: 20 } }] };
+    return { steps: [{ tool: "yandex_calendar_list", args: { limit: 20 } }] };
   }
   if (/(контакт|адресн)/iu.test(normalized)) {
     if (/(дубликат|повтор)/iu.test(normalized)) return { steps: [{ tool: "yandex_contacts_find_duplicates", args: { limit: 20 } }] };
@@ -12951,6 +14033,7 @@ function inferToolPlan(question, options = {}) {
     if (/(экспорт|выгруз)/iu.test(normalized)) return { steps: [{ tool: /csv/iu.test(normalized) ? "yandex_contacts_export_csv" : "yandex_contacts_export_vcard", args: {} }] };
     if (/(резерв|backup|бэкап|диск|яндекс.?диск)/iu.test(normalized) && /(контакт)/iu.test(normalized) && /(сохрани|экспорт|выгруз|резерв|backup|бэкап)/iu.test(normalized)) return { steps: [{ tool: "yandex_contacts_backup_to_disk", args: { format: /csv/iu.test(normalized) ? "csv" : "vcard", confirm: true } }] };
     if (/(создай|добавь|запиши|сохрани)\s+контакт/iu.test(normalized)) return { steps: [{ tool: "yandex_contacts_create", args: { ...parseYandexContactCreateRequest(question), confirm: true } }] };
+    if (/(полный|комплект|пакет)/iu.test(normalized)) return { steps: [{ tool: "yandex_contact_full_pack", args: { contact: cleanupYandexContactActionQuery(question), ...extractDateTimeFromText(question), confirm: true } }] };
     if (/(удали|удалить)/iu.test(normalized)) return { steps: [{ tool: "yandex_contacts_delete", args: { query: cleanupYandexContactActionQuery(question), confirm: true } }] };
     if (/(отправь|пошли).{0,80}(ссылк|qr|qr-код|диск|яндекс.?диск)/iu.test(normalized)) return { steps: [{ tool: "yandex_contact_send_disk_link_qr", args: { contact: cleanupYandexContactActionQuery(question), path: extractCloudPath(question), confirm: true } }] };
     if (/(отправь|пошли|напиши).{0,40}(письм|сообщ)/iu.test(normalized)) {
@@ -13537,6 +14620,21 @@ function formatToolResult(result, options) {
       return `${name}: ${row.field} = ${row.value ?? "не указано"}`;
     }
     if (row.date && row.time) return `Сегодня ${row.date}, ${row.time}.`;
+    if (row.status === "calendar-event-created" || row.status === "telemost-event-created" || row.status === "telemost-calendar-fallback-created") {
+      return `${row.status === "calendar-event-created" ? "Событие" : "Телемост"} создан: ${row.title || row.uid}${row.start ? `, ${row.start}` : ""}${row.telemost?.joinUrl ? `\nСсылка: ${row.telemost.joinUrl}` : row.status === "telemost-calendar-fallback-created" ? "\nПрямая ссылка Телемоста через API недоступна, создано событие календаря." : ""}`;
+    }
+    if (row.status === "calendar-event-updated") return `Событие обновлено: ${row.title || row.uid}`;
+    if (row.status === "calendar-event-deleted") return `Событие удалено: ${row.title || row.uid}`;
+    if (row.status === "mail-meeting-pack-created") return `Пакет по письму #${row.uid} создан.\nПисьмо: ${row.saved}\nСсылка: ${row.publicUrl}\nQR-код: ${row.qrPublicUrl}\nСобытие: ${row.event || "-"}`;
+    if (row.status === "contact-full-pack-created") return `Пакет контакта создан: ${row.contact}\nПапка: ${row.folder}\nДокумент: ${row.doc}\nСсылка: ${row.publicUrl}\nQR-код: ${row.qrPublicUrl}\nСобытие: ${row.event || "-"}`;
+    if (row.enabled && row.text && (row.unread !== undefined || row.events !== undefined)) return row.text;
+    if (row.status === "ambiguous" && row.events) return [`Нашел несколько событий. Уточните:`, ...row.events.map((event, index) => `${index + 1}. ${event.title || event.uid} — ${event.startIso || event.start || "-"}`)].join("\n");
+    if (row.status === "not-found" && row.kind === "calendar-event") return `Событие не найдено: ${row.query}`;
+    if (row.status === "document-created") return `Документ создан на Яндекс Диске: ${row.remote}`;
+    if (row.status === "binary-document") return `${row.name || row.remote}: ${row.message}`;
+    if (row.status === "not-document") return `Это не документ: ${row.path}`;
+    if (row.status === "ambiguous" && row.docs) return [`Нашел несколько документов. Уточните:`, ...row.docs.map((doc, index) => `${index + 1}. ${doc.name} — ${doc.path}`)].join("\n");
+    if (row.status === "not-found" && row.docs !== undefined) return `Документ не найден: ${row.query}`;
     if (row.status === "contact-mail-sent") return `Письмо контакту отправлено: ${row.contact}. Тема: ${row.subject || "-"}`;
     if (row.status === "contact-disk-link-sent") return `Отправил контакту ${row.contact} ссылку на Яндекс Диск.\nСсылка: ${row.publicUrl}\nQR-код: ${row.qrPublicUrl}`;
     if (row.status === "contact-folder-created") return `Папка контакта создана: ${row.remote}\nКарточка: ${row.cardPath}`;
@@ -15094,12 +16192,12 @@ function parseOptions(args) {
 
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
-    if (arg === "--json" || arg === "--yes" || arg === "--silent" || arg === "--events" || arg === "--stream-json" || arg === "--stdio" || arg === "--system" || arg === "--headed" || arg === "--headless" || arg === "--no-history" || arg === "--summary" || arg === "--all" || arg === "--full" || arg === "--unread" || arg === "--once" || arg === "--local" || arg === "--cache" || arg === "--tools" || arg === "--files" || arg === "--plan" || arg === "--trace" || arg === "--diff" || arg === "--stage" || arg === "--fts" || arg === "--bare" || arg === "--quiet" || arg === "--optional" || arg === "--project" || arg === "--dry-run" || arg === "--no-color" || arg === "--fail-on-empty" || arg === "--debug" || arg === "--fix" || arg === "--force" || arg === "--append" || arg === "--preserve-active" || arg === "--open" || arg === "--print-url" || arg === "--enable") {
+    if (arg === "--json" || arg === "--yes" || arg === "--silent" || arg === "--events" || arg === "--stream-json" || arg === "--stdio" || arg === "--system" || arg === "--headed" || arg === "--headless" || arg === "--no-history" || arg === "--summary" || arg === "--all" || arg === "--full" || arg === "--unread" || arg === "--once" || arg === "--local" || arg === "--cache" || arg === "--tools" || arg === "--files" || arg === "--plan" || arg === "--trace" || arg === "--diff" || arg === "--stage" || arg === "--fts" || arg === "--bare" || arg === "--quiet" || arg === "--optional" || arg === "--project" || arg === "--dry-run" || arg === "--no-color" || arg === "--fail-on-empty" || arg === "--debug" || arg === "--fix" || arg === "--force" || arg === "--append" || arg === "--preserve-active" || arg === "--open" || arg === "--print-url" || arg === "--enable" || arg === "--email" || arg === "--backup") {
       result[arg.slice(2)] = true;
     } 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 === "--instructions" || arg === "--allowed-tools" || arg === "--tool" || arg === "--uses" || 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-url" || arg === "--redirect-host" || arg === "--redirect-port" || arg === "--redirect-path" || arg === "--debug-file" || arg === "--from" || arg === "--to" || arg === "--radius" || arg === "--address" || arg === "--token" || arg === "--app") {
+    } 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 === "--instructions" || arg === "--allowed-tools" || arg === "--tool" || arg === "--uses" || arg === "--template" || arg === "--minutes" || arg === "--days" || arg === "--time" || arg === "--horizon" || 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-url" || arg === "--redirect-host" || arg === "--redirect-port" || arg === "--redirect-path" || arg === "--debug-file" || arg === "--from" || arg === "--to" || arg === "--radius" || arg === "--address" || arg === "--token" || arg === "--app") {
       result[arg.slice(2)] = args[index + 1];
       index += 1;
     } else {
@@ -15323,9 +16421,13 @@ function printSkillsList(skills, config) {
 async function executeUserSkillTool(tool, args = {}) {
   if (tool === "user_skill_list") return listSkills(await loadConfig()).filter((skill) => skill.source === "user");
   if (tool === "user_skill_create") return userSkillCreate({ ...args, confirm: args.confirm === true });
+  if (tool === "user_skill_update") return userSkillUpdate(args.name, { ...args, confirm: args.confirm === true });
   if (tool === "user_skill_enable") return userSkillSetEnabled(args.name, true);
   if (tool === "user_skill_disable") return userSkillSetEnabled(args.name, false);
   if (tool === "user_skill_delete") return userSkillDelete(args.name, { confirm: args.confirm === true });
+  if (tool === "user_skill_templates") return userSkillTemplates();
+  if (tool === "user_skill_validate") return userSkillValidate(args.name);
+  if (tool === "user_skill_preview") return { status: "preview", text: buildUserSkillPreview(args) };
   throw new Error(`Неизвестный user skill tool: ${tool}`);
 }
 
@@ -15333,22 +16435,41 @@ async function userSkillCreate(args = {}) {
   if (!args.confirm) throw new Error("Для создания пользовательского skill нужен аргумент confirm=true.");
   const name = normalizeUserSkillName(args.name || args.skill || args.title);
   if (!name) throw new Error("Имя skill обязательно.");
-  const description = String(args.description || `Пользовательский skill: ${name}`).trim();
-  const instructions = String(args.instructions || args.text || args.prompt || "").trim();
+  const template = getUserSkillTemplate(args.template);
+  const description = String(args.description || template?.description || `Пользовательский skill: ${name}`).trim();
+  const instructions = String(args.instructions || args.text || args.prompt || template?.instructions || "").trim();
   if (!instructions) throw new Error("Инструкции skill обязательны.");
   const tools = parseCommaList(args.tools || args.allowedTools || args.allowed_tools || args.uses || "");
+  const mergedTools = [...new Set([...(template?.tools || []), ...tools])];
   const dir = path.join(USER_SKILLS_DIR, name);
   const file = path.join(dir, "SKILL.md");
   if (existsSync(file) && !args.overwrite) throw new Error(`Skill уже существует: ${name}. Используйте overwrite=true или --force.`);
   await mkdir(dir, { recursive: true });
-  const body = buildUserSkillMarkdown({ name, description, instructions, tools });
+  const body = buildUserSkillMarkdown({ name, description, instructions, tools: mergedTools });
   await writeFile(file, body, "utf8");
   let enabled = false;
   if (args.enable) {
     await userSkillSetEnabled(name, true);
     enabled = true;
   }
-  return { name, description, file, enabled, tools, status: "created" };
+  return { name, description, file, enabled, tools: mergedTools, status: "created" };
+}
+
+async function userSkillUpdate(name, args = {}) {
+  if (!args.confirm) throw new Error("Для обновления пользовательского skill нужен confirm=true.");
+  const skillName = normalizeUserSkillName(name || args.name || args.skill);
+  if (!skillName) throw new Error("Имя skill обязательно.");
+  const file = path.join(USER_SKILLS_DIR, skillName, "SKILL.md");
+  if (!existsSync(file)) throw new Error(`Пользовательский skill не найден: ${skillName}`);
+  const current = await readFile(file, "utf8");
+  const meta = readSkillMeta(file);
+  const description = String(args.description || meta.description || `Пользовательский skill: ${skillName}`).trim();
+  const instructions = String(args.instructions || args.text || args.prompt || stripFrontmatter(current)).trim();
+  const tools = parseCommaList(args.tools || args.allowedTools || args.allowed_tools || args.uses || inferUserSkillTools(instructions));
+  const body = buildUserSkillMarkdown({ name: skillName, description, instructions, tools });
+  await writeFile(file, body, "utf8");
+  if (args.enable) await userSkillSetEnabled(skillName, true);
+  return { name: skillName, description, file, tools, status: "updated" };
 }
 
 async function userSkillSetEnabled(name, enabled) {
@@ -15442,9 +16563,23 @@ function inferUserSkillTools(question) {
   }
   if (/(календар|событи|встреч|телемост)/iu.test(text)) {
     tools.add("yandex_calendar_list");
+    tools.add("yandex_calendar_search");
     tools.add("yandex_calendar_create_event");
+    tools.add("yandex_calendar_update");
+    tools.add("yandex_calendar_move");
+    tools.add("yandex_calendar_delete");
+    tools.add("yandex_calendar_add_reminder");
     tools.add("yandex_telemost_create_event");
   }
+  if (/(документ|docs|360)/iu.test(text)) {
+    tools.add("yandex_docs_list");
+    tools.add("yandex_docs_find");
+    tools.add("yandex_docs_create_text");
+    tools.add("yandex_docs_read");
+    tools.add("yandex_docs_share");
+    tools.add("yandex_docs_rename");
+    tools.add("yandex_docs_delete");
+  }
   if (/(контакт|адресн)/iu.test(text)) {
     tools.add("yandex_contacts_search");
     tools.add("yandex_contacts_get");
@@ -15485,6 +16620,69 @@ function inferUserSkillTools(question) {
   return [...tools];
 }
 
+function userSkillTemplates() {
+  return [
+    {
+      name: "mail-triage",
+      description: "Разбор почты: найти важные письма, прочитать, сохранить, создать задачу или событие.",
+      tools: ["yandex_mail_list", "yandex_mail_search", "yandex_mail_read", "yandex_mail_save_to_disk", "yandex_mail_create_calendar_event", "yandex_mail_create_task"],
+      instructions: "Помогай разбирать почту пользователя. Сначала показывай краткую сводку, затем выполняй только явно запрошенные действия: чтение, сохранение письма на Диск, создание события или задачи.",
+    },
+    {
+      name: "family-calendar",
+      description: "Семейный календарь: события, напоминания, встречи и ежедневные проверки.",
+      tools: ["yandex_calendar_list", "yandex_calendar_search", "yandex_calendar_create_event", "yandex_calendar_move", "yandex_calendar_add_reminder", "yandex_calendar_delete", "yandex_calendar_reminders_tick"],
+      instructions: "Помогай вести личный календарь. Для изменения календаря требуй явную просьбу пользователя. Всегда называй дату и время события.",
+    },
+    {
+      name: "docs-organizer",
+      description: "Организация документов на Яндекс Диске.",
+      tools: ["yandex_docs_list", "yandex_docs_find", "yandex_docs_create_text", "yandex_docs_read", "yandex_docs_share", "yandex_docs_rename", "yandex_docs_delete", "yandex_disk_maintenance_tick"],
+      instructions: "Помогай искать, создавать и приводить в порядок документы на Яндекс Диске. Не путай облачные документы с локальными файлами на компьютере.",
+    },
+    {
+      name: "contact-workflow",
+      description: "Работа с контактами, письмами, встречами и папками контактов.",
+      tools: ["yandex_contacts_search", "yandex_contacts_get", "yandex_contact_send_mail", "yandex_contact_send_disk_link_qr", "yandex_contact_create_disk_folder", "yandex_contact_create_calendar_event", "yandex_contact_full_pack"],
+      instructions: "Помогай выполнять действия вокруг контакта: найти карточку, отправить письмо, создать папку, отправить ссылку или создать встречу. Если найдено несколько контактов, проси уточнение.",
+    },
+  ];
+}
+
+function getUserSkillTemplate(name) {
+  const normalized = normalizeUserSkillName(name || "");
+  return userSkillTemplates().find((item) => item.name === normalized) || null;
+}
+
+function buildUserSkillPreview(args = {}) {
+  const name = normalizeUserSkillName(args.name || args.skill || args.title || "user-skill");
+  const template = getUserSkillTemplate(args.template);
+  const description = args.description || template?.description || `Пользовательский skill: ${name}`;
+  const instructions = args.instructions || args.text || args.prompt || template?.instructions || "Опишите, что должен делать skill.";
+  const tools = [...new Set([...(template?.tools || []), ...parseCommaList(args.tools || args.allowedTools || args.allowed_tools || args.uses || inferUserSkillTools(instructions))])];
+  return buildUserSkillMarkdown({ name, description, instructions, tools });
+}
+
+async function userSkillValidate(name) {
+  const config = await loadConfig();
+  const skill = findSkill(normalizeUserSkillName(name), config);
+  const checks = [];
+  if (!skill) {
+    return { status: "error", checks: [{ check: "exists", status: "error", message: `Skill не найден: ${name || "-"}` }] };
+  }
+  const text = await readFile(skill.file, "utf8");
+  const meta = readSkillMeta(skill.file);
+  checks.push({ check: "exists", status: "ok", message: skill.file });
+  checks.push({ check: "name", status: meta.name ? "ok" : "error", message: meta.name || "Нет name во frontmatter" });
+  checks.push({ check: "description", status: meta.description ? "ok" : "warn", message: meta.description || "Описание пустое" });
+  checks.push({ check: "instructions", status: stripFrontmatter(text).trim().length >= 40 ? "ok" : "warn", message: "Инструкции должны быть понятными и достаточно подробными" });
+  checks.push({ check: "secrets", status: /(token|api[_-]?key|парол|секрет)\s*[:=]\s*\S{8,}/iu.test(text) ? "error" : "ok", message: "Skill не должен содержать секреты" });
+  const tools = [...text.matchAll(/`([a-z0-9_:-]+)`/giu)].map((match) => match[1]).filter((tool) => ALL_TOOL_ALIASES.includes(tool) || tool.startsWith("mcp:"));
+  const unknownTools = tools.filter((tool) => !ALL_TOOL_ALIASES.includes(tool) && !tool.startsWith("mcp:"));
+  checks.push({ check: "tools", status: unknownTools.length ? "warn" : "ok", message: unknownTools.length ? `Неизвестные tools: ${unknownTools.join(", ")}` : `${tools.length} tools` });
+  return { status: checks.some((row) => row.status === "error") ? "error" : "ok", checks };
+}
+
 function buildUserSkillMarkdown({ name, description, instructions, tools = [] }) {
   const toolLines = tools.length
     ? ["", "Разрешенные/ожидаемые tools для этого skill:", "", ...tools.map((tool) => `- \`${tool}\``)]
@@ -15554,7 +16752,7 @@ function selectSkillsForPrompt(config, question = "", options = {}) {
   if (enabled.has("geo") && isGeoQuestion(normalized)) selected.add("geo");
   const cloudQuestion = isCloudQuestion(normalized);
   if (enabled.has("personal-docs") && cloudQuestion) selected.add("personal-docs");
-  if (enabled.has("yandex-services") && /(яндекс|диск|почт|письм|календар|контакт|телемост|облако)/iu.test(normalized)) selected.add("yandex-services");
+  if (enabled.has("yandex-services") && /(яндекс|диск|почт|письм|календар|контакт|телемост|документ|docs|360|облако)/iu.test(normalized)) selected.add("yandex-services");
   if (enabled.has("reports") && /(отчет|отчёт|выгруз|csv|xlsx|качество|провер)/iu.test(normalized)) selected.add("reports");
   if (enabled.has("local-files") && !cloudQuestion && (options.files || /(файл|папк|readme|документ|архив)/iu.test(normalized))) selected.add("local-files");
   if (enabled.has("browser-agent") && /(браузер|сайт|страниц|url|https?:\/\/)/iu.test(normalized)) selected.add("browser-agent");