@iola_adm/iola-cli 0.2.29 → 0.2.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iola_adm/iola-cli",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "description": "CLI и AI-агент городского округа Йошкар-Ола.",
   "license": "MIT",
   "homepage": "https://github.com/adm-iola/iola-cli#readme",

package/skills/yandex-services/SKILL.md

@@ -21,21 +21,30 @@ description: Сервисы Яндекса через Yandex Connector: ID, Ди
 - `yandex_disk_unshare` - снять публичную ссылку.
 - `yandex_disk_delete` - удалить файл или папку.
 - `yandex_mail_status` - проверить доступ к Яндекс Почте.
+- `yandex_mail_folders` - показать папки Яндекс Почты.
 - `yandex_mail_list` - показать последние письма.
 - `yandex_mail_search` - найти письма.
-- `yandex_mail_read` - прочитать письмо по UID.
+- `yandex_mail_read` - прочитать письмо по UID; обычное чтение помечает письмо прочитанным.
 - `yandex_mail_send` - отправить письмо.
+- `yandex_mail_reply` - ответить на письмо по UID.
+- `yandex_mail_delete` - переместить письмо в корзину.
+- `yandex_mail_mark` - пометить письмо прочитанным или непрочитанным.
+- Автоопрос почты включается командой `iola yandex mail-watch on --minutes 5`, выключается `iola yandex mail-watch off`, ручная проверка `iola yandex mail-watch tick`.
 - `yandex_calendar_status` - проверить доступ к Яндекс Календарю.
 - `yandex_calendar_list` - показать события.
 - `yandex_calendar_create_event` - создать событие.
 - `yandex_contacts_status` - проверить доступ к Яндекс Контактам.
 - `yandex_contacts_list` - показать контакты.
 - `yandex_contacts_search` - найти контакт.
+- `yandex_contacts_add_email` - добавить email в существующий контакт.
 - `yandex_telemost_create_event` - создать календарное событие для встречи.
 
 Безопасность:
 
-- Для отправки письма, удаления файлов, публикации ссылки и создания событий нужен явный запрос пользователя и `confirm=true`.
-- Не отправляй письма, не удаляй файлы и не публикуй ссылки по косвенному намерению.
+- Для отправки письма, ответа на письмо, удаления письма, удаления файлов, публикации ссылки и создания событий нужен явный запрос пользователя и `confirm=true`.
+- Не отправляй письма, не отвечай на письма, не удаляй письма/файлы и не публикуй ссылки по косвенному намерению.
+- Список писем и поиск не должны помечать письма прочитанными. Чтение письма по просьбе пользователя помечает письмо прочитанным.
+- Если пользователь просит отправить письмо по имени контакта, сначала ищи контакт. Если контактов несколько, покажи варианты и попроси уточнить. Если контакта нет или у него нет email, скажи прямо.
+- Если пользователь отправил письмо на введенный email и указал имя контакта, можно предложить добавить email в найденный контакт без email.
 - Не выводи OAuth-токены, API-ключи, пароли и секреты.
 - Если сервис не подключен, скажи запустить `iola yandex setup` или открыть `/master`.

package/src/cli.js

@@ -164,16 +164,21 @@ const YANDEX_TOOLS = [
   "yandex_disk_unshare",
   "yandex_disk_delete",
   "yandex_mail_status",
+  "yandex_mail_folders",
   "yandex_mail_list",
   "yandex_mail_search",
   "yandex_mail_read",
   "yandex_mail_send",
+  "yandex_mail_reply",
+  "yandex_mail_delete",
+  "yandex_mail_mark",
   "yandex_calendar_status",
   "yandex_calendar_create_event",
   "yandex_calendar_list",
   "yandex_contacts_status",
   "yandex_contacts_list",
   "yandex_contacts_search",
+  "yandex_contacts_add_email",
   "yandex_telemost_create_event",
 ];
 const ALL_LOCAL_TOOLS = [...LOCAL_TOOLS, ...FILE_TOOLS, ...YANDEX_TOOLS];
@@ -3304,6 +3309,11 @@ async function handleYandex(args) {
     return;
   }
 
+  if (action === "mail-watch" || action === "mailwatch" || action === "watch-mail") {
+    await handleYandexMailWatch([target, ...rest].filter(Boolean));
+    return;
+  }
+
   if (action === "enable" || action === "disable") {
     const services = [target, ...rest].filter((item) => item && !String(item).startsWith("--"));
     if (services.length === 0) throw new Error("Укажите сервисы. Пример: iola yandex enable disk mail calendar");
@@ -3339,6 +3349,7 @@ async function handleYandex(args) {
   iola yandex menu
   iola yandex status|doctor
   iola yandex services
+  iola yandex mail-watch on|off|status|tick [--minutes 5]
   iola yandex enable disk mail calendar
   iola yandex disable mail
   iola yandex oauth-url [disk mail calendar] [--client-id ID] [--open]
@@ -3368,6 +3379,47 @@ function printYandexServices(options = {}) {
   ]);
 }
 
+async function handleYandexMailWatch(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 || options.interval || rest.find((item) => /^\d+$/u.test(String(item))) || 5));
+    const result = await yandexMailWatchEnable(minutes);
+    console.log(`Автопроверка новых писем включена: каждые ${minutes} минут. Текущий последний UID: ${result.lastUid || "-"}.`);
+    console.log("Для работы по расписанию должен запускаться cron tick: вручную, через daemon или Windows Task Scheduler.");
+    return;
+  }
+  if (action === "off" || action === "disable" || action === "stop" || action === "выкл") {
+    await yandexMailWatchDisable();
+    console.log("Автопроверка новых писем выключена.");
+    return;
+  }
+  if (action === "tick" || action === "run" || action === "check") {
+    const result = await yandexMailWatchTick(options);
+    if (!result.enabled) {
+      console.log("Автопроверка новых писем выключена.");
+    } else if (!result.newMessages.length) {
+      console.log("Новых писем нет.");
+    } else {
+      console.log(["Новые письма:", ...result.newMessages.map((row, index) => `${index + 1}. ${formatYandexMailSummary(row)}`)].join("\n"));
+    }
+    return;
+  }
+  if (action === "status" || action === "doctor") {
+    const config = await loadConfig();
+    const watch = config.yandex?.mailWatch || {};
+    printKeyValue({
+      enabled: watch.enabled ? "yes" : "no",
+      minutes: watch.minutes || "-",
+      mailbox: watch.mailbox || "INBOX",
+      lastUid: watch.lastUid || "-",
+      cron: listCronJobs().some((job) => job.command === "yandex mail-watch tick") ? "yes" : "no",
+    });
+    return;
+  }
+  throw new Error("Команды: iola yandex mail-watch on --minutes 5 | off | status | tick");
+}
+
 async function setupYandexConnector(args = []) {
   const options = parseOptions(args);
   const config = await loadConfig();
@@ -3949,16 +4001,21 @@ async function executeYandexTool(tool, args = {}) {
   if (tool === "yandex_disk_unshare") return yandexDiskUnshare(args.remotePath || args.path);
   if (tool === "yandex_disk_delete") return yandexDiskDelete(args.remotePath || args.path, args);
   if (tool === "yandex_mail_status") return yandexMailStatus();
-  if (tool === "yandex_mail_list") return yandexMailList({ mailbox: args.mailbox || "INBOX", limit: args.limit || 10, unread: Boolean(args.unread) });
-  if (tool === "yandex_mail_search") return yandexMailSearch(args.query || "", { mailbox: args.mailbox || "INBOX", limit: args.limit || 20 });
-  if (tool === "yandex_mail_read") return yandexMailRead(args.uid || args.id, { mailbox: args.mailbox || "INBOX" });
+  if (tool === "yandex_mail_folders") return yandexMailFolders();
+  if (tool === "yandex_mail_list") return yandexMailList({ mailbox: await resolveYandexMailbox(args.mailbox || args.folder || "INBOX"), limit: args.limit || 10, unread: Boolean(args.unread) });
+  if (tool === "yandex_mail_search") return yandexMailSearch(args.query || "", { mailbox: await resolveYandexMailbox(args.mailbox || args.folder || "INBOX"), limit: args.limit || 20 });
+  if (tool === "yandex_mail_read") return yandexMailRead(args.uid || args.id, { mailbox: await resolveYandexMailbox(args.mailbox || args.folder || "INBOX"), markSeen: args.markSeen !== false });
   if (tool === "yandex_mail_send") return yandexMailSend(args);
+  if (tool === "yandex_mail_reply") return yandexMailReply(args);
+  if (tool === "yandex_mail_delete") return yandexMailDelete(args.uid || args.id, { ...args, mailbox: await resolveYandexMailbox(args.mailbox || args.folder || "INBOX") });
+  if (tool === "yandex_mail_mark") return yandexMailMark(args.uid || args.id, args.seen !== false && args.unread !== true, { mailbox: await resolveYandexMailbox(args.mailbox || args.folder || "INBOX") });
   if (tool === "yandex_calendar_status") return yandexCalendarStatus();
   if (tool === "yandex_calendar_create_event") return yandexCalendarCreateEvent(args);
   if (tool === "yandex_calendar_list") return yandexCalendarList(args);
   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);
+  if (tool === "yandex_contacts_add_email") return yandexContactsAddEmail(args.query || args.name || "", args.email, args);
   if (tool === "yandex_telemost_create_event") return yandexTelemostCreateEvent(args);
   throw new Error(`Yandex tool неизвестен: ${tool}`);
 }
@@ -3985,6 +4042,62 @@ async function yandexMailStatus() {
   }
 }
 
+async function yandexMailFolders() {
+  const { token, email } = await yandexMailCredentials();
+  const session = await imapConnect();
+  try {
+    await imapAuthenticate(session, email, token);
+    const text = await imapCommand(session, 'LIST "" "*"');
+    return parseImapListMailboxes(text);
+  } finally {
+    await imapClose(session);
+  }
+}
+
+async function resolveYandexMailbox(value = "INBOX") {
+  const requested = String(value || "INBOX").trim();
+  if (!requested || /^inbox$/iu.test(requested)) return "INBOX";
+  if (!isYandexMailboxAlias(requested)) return requested;
+  const folders = await yandexMailFolders();
+  const target = normalizeYandexMailboxAlias(requested);
+  const found = findYandexMailbox(folders, target);
+  if (found?.name) return found.name;
+  throw new Error(`Папка Яндекс Почты не найдена: ${requested}. Проверьте список папок командой: покажи папки почты.`);
+}
+
+function isYandexMailboxAlias(value) {
+  return /^(sent|send|sentmail|отправ|исход|draft|drafts|чернов|spam|junk|спам|trash|bin|корзин|удален|удалён)$/iu.test(String(value || "").trim());
+}
+
+function normalizeYandexMailboxAlias(value) {
+  const text = String(value || "").toLocaleLowerCase("ru-RU");
+  if (/(sent|send|sentmail|отправ|исход)/iu.test(text)) return "sent";
+  if (/(draft|drafts|чернов)/iu.test(text)) return "drafts";
+  if (/(spam|junk|спам)/iu.test(text)) return "spam";
+  if (/(trash|bin|корзин|удален|удалён)/iu.test(text)) return "trash";
+  return "inbox";
+}
+
+function findYandexMailbox(folders, target) {
+  const special = {
+    sent: "\\Sent",
+    drafts: "\\Drafts",
+    spam: "\\Junk",
+    trash: "\\Trash",
+  }[target];
+  if (special) {
+    const bySpecial = folders.find((folder) => folder.flags.some((flag) => flag.toLocaleLowerCase("en-US") === special.toLocaleLowerCase("en-US")));
+    if (bySpecial) return bySpecial;
+  }
+  const patterns = {
+    sent: /(sent|отправ|исход)/iu,
+    drafts: /(draft|чернов)/iu,
+    spam: /(spam|junk|спам)/iu,
+    trash: /(trash|bin|корзин|удален|удалён)/iu,
+  }[target];
+  return folders.find((folder) => patterns?.test(folder.name) || patterns?.test(folder.displayName || ""));
+}
+
 async function yandexMailList(options = {}) {
   const { token, email } = await yandexMailCredentials();
   const session = await imapConnect();
@@ -4023,6 +4136,52 @@ async function yandexMailSearch(query, options = {}) {
   return rows.filter((row) => normalizeGeoText(`${row.from} ${row.subject} ${row.snippet}`).includes(normalized)).slice(0, Number(options.limit || 20));
 }
 
+async function yandexMailWatchTick(options = {}) {
+  const config = await loadConfig();
+  const watch = config.yandex?.mailWatch || {};
+  if (!watch.enabled && !options.force) return { enabled: false, newMessages: [] };
+  const mailbox = watch.mailbox || "INBOX";
+  const lastUid = Number(watch.lastUid || 0);
+  const rows = await yandexMailList({ mailbox, limit: Number(options.limit || 30), unread: false });
+  const newMessages = rows.filter((row) => Number(row.uid || 0) > lastUid).sort((left, right) => Number(left.uid || 0) - Number(right.uid || 0));
+  const newestUid = Math.max(lastUid, ...rows.map((row) => Number(row.uid || 0)));
+  await saveConfig({
+    yandex: {
+      ...(config.yandex || {}),
+      mailWatch: {
+        ...watch,
+        enabled: watch.enabled !== false,
+        mailbox,
+        lastUid: newestUid,
+        lastCheckedAt: new Date().toISOString(),
+      },
+    },
+  });
+  return { enabled: true, mailbox, lastUid, newestUid, newMessages };
+}
+
+async function yandexMailWatchEnable(minutes = 5) {
+  const config = await loadConfig();
+  const safeMinutes = Math.max(1, Number(minutes || 5));
+  const latest = await yandexMailList({ mailbox: "INBOX", limit: 1, unread: false });
+  const lastUid = latest[0]?.uid || 0;
+  await saveConfig({
+    yandex: {
+      ...(config.yandex || {}),
+      mailWatch: { enabled: true, minutes: safeMinutes, mailbox: "INBOX", lastUid, updatedAt: new Date().toISOString() },
+    },
+  });
+  await upsertCronJob(`каждые ${safeMinutes} минут`, "yandex mail-watch tick", { replaceCommand: true });
+  return { enabled: true, minutes: safeMinutes, mailbox: "INBOX", lastUid };
+}
+
+async function yandexMailWatchDisable() {
+  const config = await loadConfig();
+  await saveConfig({ yandex: { ...(config.yandex || {}), mailWatch: { ...(config.yandex?.mailWatch || {}), enabled: false, updatedAt: new Date().toISOString() } } });
+  deleteCronJobsByCommand("yandex mail-watch tick");
+  return { enabled: false };
+}
+
 async function yandexMailRead(uid, options = {}) {
   if (!uid) throw new Error("UID письма обязателен.");
   const { token, email } = await yandexMailCredentials();
@@ -4031,13 +4190,71 @@ async function yandexMailRead(uid, options = {}) {
     await imapAuthenticate(session, email, token);
     await imapCommand(session, `SELECT ${quoteImapMailbox(options.mailbox || "INBOX")}`);
     const bodyAccessor = options.markSeen === false ? "BODY.PEEK[TEXT]" : "BODY[TEXT]";
-    const fetch = await imapCommand(session, `UID FETCH ${Number(uid)} (UID FLAGS RFC822.SIZE BODY.PEEK[HEADER.FIELDS (DATE FROM SUBJECT)] ${bodyAccessor})`, { timeout: 60000 });
+    const fetch = await imapCommand(session, `UID FETCH ${Number(uid)} (UID FLAGS RFC822.SIZE BODY.PEEK[HEADER.FIELDS (DATE FROM SUBJECT MESSAGE-ID REFERENCES)] ${bodyAccessor})`, { timeout: 60000 });
     return parseImapFetchSummaries(fetch, { full: true })[0] || { uid, status: "not-found" };
   } finally {
     await imapClose(session);
   }
 }
 
+async function yandexMailMark(uid, seen = true, options = {}) {
+  if (!uid) throw new Error("UID письма обязателен.");
+  const { token, email } = await yandexMailCredentials();
+  const session = await imapConnect();
+  try {
+    await imapAuthenticate(session, email, token);
+    const mailbox = options.mailbox || "INBOX";
+    await imapCommand(session, `SELECT ${quoteImapMailbox(mailbox)}`);
+    const command = seen ? "+FLAGS.SILENT" : "-FLAGS.SILENT";
+    await imapCommand(session, `UID STORE ${Number(uid)} ${command} (\\Seen)`);
+    return { uid: Number(uid), mailbox, status: seen ? "seen" : "unseen" };
+  } finally {
+    await imapClose(session);
+  }
+}
+
+async function yandexMailDelete(uid, options = {}) {
+  if (!options.confirm) throw new Error("Для удаления письма нужен аргумент confirm=true.");
+  if (!uid) throw new Error("UID письма обязателен.");
+  const folders = await yandexMailFolders();
+  const trash = options.trashMailbox || findYandexMailbox(folders, "trash")?.name;
+  if (!trash) throw new Error("Не нашел папку корзины в Яндекс Почте. Безопасное удаление невозможно.");
+  const { token, email } = await yandexMailCredentials();
+  const session = await imapConnect();
+  try {
+    await imapAuthenticate(session, email, token);
+    const mailbox = options.mailbox || "INBOX";
+    await imapCommand(session, `SELECT ${quoteImapMailbox(mailbox)}`);
+    await imapCommand(session, `UID MOVE ${Number(uid)} ${quoteImapMailbox(trash)}`, { timeout: 60000 });
+    return { uid: Number(uid), from: mailbox, to: trash, status: "moved-to-trash" };
+  } finally {
+    await imapClose(session);
+  }
+}
+
+async function yandexMailReply(args = {}) {
+  if (!args.confirm) throw new Error("Для ответа на письмо нужен аргумент confirm=true.");
+  const uid = args.uid || args.id;
+  const text = args.text || args.body || args.message || "";
+  if (!uid) throw new Error("UID письма обязателен.");
+  if (!String(text).trim()) throw new Error("Текст ответа пустой.");
+  const mailbox = await resolveYandexMailbox(args.mailbox || args.folder || "INBOX");
+  const original = await yandexMailRead(uid, { mailbox, markSeen: true, includeMessageId: true });
+  if (!original || original.status === "not-found") throw new Error(`Письмо #${uid} не найдено.`);
+  const to = [extractEmailAddress(original.from)].filter(Boolean);
+  if (!to.length) throw new Error("Не удалось определить получателя ответа из поля From.");
+  const subject = /^re:/iu.test(original.subject || "") ? original.subject : `Re: ${original.subject || "(без темы)"}`;
+  const result = await yandexMailSend({
+    to,
+    subject,
+    text,
+    confirm: true,
+    inReplyTo: original.messageId || "",
+    references: original.references || original.messageId || "",
+  });
+  return { ...result, replyToUid: Number(uid), originalFrom: original.from };
+}
+
 async function yandexMailSend(args = {}) {
   if (!args.confirm) throw new Error("Для отправки письма нужен аргумент confirm=true.");
   const to = Array.isArray(args.to) ? args.to : String(args.to || "").split(/[;,]/).map((item) => item.trim()).filter(Boolean);
@@ -4053,7 +4270,7 @@ async function yandexMailSend(args = {}) {
     await smtpCommand(session, `MAIL FROM:<${email}>`);
     for (const recipient of to) await smtpCommand(session, `RCPT TO:<${recipient}>`);
     await smtpCommand(session, "DATA", { expect: /^354/u });
-    await smtpCommand(session, `${dotStuffSmtpData(buildMimeMessage({ from: email, to, subject, text }))}\r\n.`);
+    await smtpCommand(session, `${dotStuffSmtpData(buildMimeMessage({ from: email, to, subject, text, inReplyTo: args.inReplyTo, references: args.references }))}\r\n.`);
     await smtpCommand(session, "QUIT").catch(() => {});
     return { from: email, to, subject, status: "sent" };
   } finally {
@@ -4065,7 +4282,7 @@ function buildXoauth2(email, token) {
   return Buffer.from(`user=${email}\x01auth=Bearer ${token}\x01\x01`).toString("base64");
 }
 
-function buildMimeMessage({ from, to, subject, text }) {
+function buildMimeMessage({ from, to, subject, text, inReplyTo = "", references = "" }) {
   const encodedSubject = Buffer.from(subject, "utf8").toString("base64");
   const messageIdDomain = String(from || "").split("@")[1] || "localhost";
   const messageId = `${randomUUID()}@${messageIdDomain}`;
@@ -4076,13 +4293,15 @@ function buildMimeMessage({ from, to, subject, text }) {
     `Subject: =?UTF-8?B?${encodedSubject}?=`,
     `Date: ${new Date().toUTCString()}`,
     `Message-ID: <${messageId}>`,
+    inReplyTo ? `In-Reply-To: ${inReplyTo}` : "",
+    references ? `References: ${references}` : "",
     "MIME-Version: 1.0",
     "Content-Type: text/plain; charset=utf-8",
     "Content-Transfer-Encoding: base64",
     "X-Mailer: IOLA CLI",
     "",
     Buffer.from(text.replace(/\r?\n/g, "\r\n"), "utf8").toString("base64").replace(/.{1,76}/g, "$&\r\n").trim(),
-  ].join("\r\n");
+  ].filter((line) => line !== "").join("\r\n");
 }
 
 function dotStuffSmtpData(message) {
@@ -4172,7 +4391,7 @@ async function imapClose(session) {
 }
 
 function quoteImapMailbox(value) {
-  return `"${String(value || "INBOX").replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+  return `"${encodeImapModifiedUtf7(String(value || "INBOX")).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
 }
 
 function parseImapSelect(text) {
@@ -4188,6 +4407,55 @@ function parseImapSearchUids(text) {
     .flatMap((match) => match[1].trim().split(/\s+/).map(Number).filter(Boolean));
 }
 
+function parseImapListMailboxes(text) {
+  return String(text || "")
+    .split(/\r?\n/u)
+    .map((line) => {
+      const match = line.match(/^\* LIST \(([^)]*)\) (?:"([^"]*)"|NIL) (?:"((?:\\"|[^"])*)"|(.+))$/iu);
+      if (!match) return null;
+      const flags = [...match[1].matchAll(/\\[^\s)]+/gu)].map((item) => item[0]);
+      const delimiter = match[2] || "";
+      const rawName = (match[3] || match[4] || "").trim();
+      const name = decodeImapModifiedUtf7(rawName.replace(/\\"/g, "\""));
+      return {
+        name,
+        displayName: name,
+        delimiter,
+        flags,
+        special: flags.find((flag) => /\\(?:Inbox|Sent|Drafts|Junk|Trash)/iu.test(flag)) || "",
+      };
+    })
+    .filter(Boolean);
+}
+
+function decodeImapModifiedUtf7(value) {
+  return String(value || "").replace(/&([^-]*)-/gu, (_, data) => {
+    if (!data) return "&";
+    const base64 = data.replace(/,/g, "/");
+    try {
+      const buffer = Buffer.from(base64, "base64");
+      let decoded = "";
+      for (let index = 0; index + 1 < buffer.length; index += 2) {
+        decoded += String.fromCharCode(buffer.readUInt16BE(index));
+      }
+      return decoded;
+    } catch {
+      return `&${data}-`;
+    }
+  });
+}
+
+function encodeImapModifiedUtf7(value) {
+  return String(value || "").replace(/&/gu, "&-").replace(/[^\x20-\x7e]+/gu, (chunk) => {
+    const bytes = [];
+    for (const char of chunk) {
+      const code = char.charCodeAt(0);
+      bytes.push((code >> 8) & 0xff, code & 0xff);
+    }
+    return `&${Buffer.from(bytes).toString("base64").replace(/\//g, ",").replace(/=+$/u, "")}-`;
+  });
+}
+
 function parseImapFetchSummaries(text, options = {}) {
   const rows = [];
   const chunks = String(text || "").split(/\n(?=\* \d+ FETCH)/u);
@@ -4199,7 +4467,15 @@ function parseImapFetchSummaries(text, options = {}) {
     const from = headers.from || "";
     const date = headers.date || "";
     const body = options.full ? stripMailBody(chunk) : stripMailBody(chunk).slice(0, 800);
-    rows.push({ uid, date, from, subject, snippet: body.replace(/\s+/g, " ").trim().slice(0, options.full ? 12000 : 500) });
+    rows.push({
+      uid,
+      date,
+      from,
+      subject,
+      messageId: headers.messageId || "",
+      references: headers.references || "",
+      snippet: body.replace(/\s+/g, " ").trim().slice(0, options.full ? 12000 : 500),
+    });
   }
   return rows;
 }
@@ -4214,9 +4490,18 @@ function parseMailHeaders(value) {
     date: headerValue("Date"),
     from: headerValue("From"),
     subject: headerValue("Subject"),
+    messageId: headerValue("Message-ID"),
+    references: headerValue("References"),
   };
 }
 
+function extractEmailAddress(value) {
+  const text = String(value || "").trim();
+  return text.match(/<([^<>@\s]+@[^<>@\s]+)>/u)?.[1]
+    || text.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/iu)?.[0]
+    || "";
+}
+
 function decodeMimeHeader(value) {
   return String(value || "")
     .replace(/\?=\s+=\?/gu, "?==?")
@@ -4383,7 +4668,7 @@ async function yandexContactsList(args = {}) {
   const rows = [];
   for (const href of hrefs) {
     const card = await yandexDavRequest(new URL(href, "https://carddav.yandex.ru/").toString(), token, { method: "GET", timeout: 30000 }).catch(() => "");
-    rows.push(...parseVCards(card));
+    rows.push(...parseVCards(card).map((row) => args.full ? { ...row, href, card } : row));
   }
   return rows.slice(0, Number(args.limit || 50));
 }
@@ -4395,6 +4680,64 @@ async function yandexContactsSearch(query, args = {}) {
   return rows.filter((row) => normalizeGeoText(`${row.name} ${row.email} ${row.phone}`).includes(normalized)).slice(0, Number(args.limit || 20));
 }
 
+async function resolveYandexMailRecipientFromContacts(query) {
+  const normalized = normalizeContactLookupText(query);
+  if (!normalized) return { status: "not-found", contacts: [] };
+  const rows = await yandexContactsList({ limit: 300 });
+  const matches = rows.filter((row) => contactMatchesQuery(row, normalized)).slice(0, 10);
+  if (!matches.length) return { status: "not-found", contacts: [] };
+  const withEmail = matches.filter((row) => row.email);
+  if (withEmail.length === 1) return { status: "ok", contact: withEmail[0] };
+  if (withEmail.length > 1) return { status: "ambiguous", contacts: withEmail };
+  return matches.length === 1
+    ? { status: "no-email", contact: matches[0] }
+    : { status: "ambiguous", contacts: matches };
+}
+
+async function yandexContactsAddEmail(query, email, args = {}) {
+  if (!args.confirm) throw new Error("Для изменения контакта нужен аргумент confirm=true.");
+  if (!query) throw new Error("Укажите имя или часть имени контакта.");
+  if (!email || !/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/iu.test(String(email))) throw new Error("Укажите корректный email.");
+  const rows = await yandexContactsList({ limit: 500, full: true });
+  const matches = rows.filter((row) => contactMatchesQuery(row, normalizeContactLookupText(query))).slice(0, 10);
+  if (!matches.length) return { status: "not-found", query };
+  if (matches.length > 1 && !args.selectFirst) return { status: "ambiguous", query, contacts: matches.map(({ card, ...row }) => row) };
+  const contact = matches[0];
+  if (contact.email && !args.overwrite) return { status: "has-email", contact: { name: contact.name, email: contact.email } };
+  const updatedCard = upsertVcardEmail(contact.card, email, { overwrite: Boolean(args.overwrite) });
+  const token = await requireYandexOAuthToken("organizer", "Яндекс Контакты");
+  await yandexDavRequest(new URL(contact.href, "https://carddav.yandex.ru/").toString(), token, {
+    method: "PUT",
+    headers: { "content-type": "text/vcard; charset=utf-8" },
+    body: updatedCard,
+    timeout: 45000,
+  });
+  return { status: "updated", name: contact.name, email };
+}
+
+function upsertVcardEmail(card, email, options = {}) {
+  const text = String(card || "").replace(/\r/g, "").trim();
+  if (!text.includes("BEGIN:VCARD")) throw new Error("Контакт не похож на vCard.");
+  if (/^EMAIL[^:]*:/imu.test(text)) {
+    if (!options.overwrite) return text;
+    return text.replace(/^EMAIL[^:]*:[^\n]*/imu, `EMAIL;TYPE=INTERNET:${email}`);
+  }
+  return text.replace(/\nEND:VCARD/iu, `\nEMAIL;TYPE=INTERNET:${email}\nEND:VCARD`);
+}
+
+function contactMatchesQuery(contact, normalizedQuery) {
+  const contactText = normalizeContactLookupText(`${contact.name || ""} ${contact.email || ""}`);
+  if (!contactText || !normalizedQuery) return false;
+  if (contactText.includes(normalizedQuery)) return true;
+  const queryTokens = normalizedQuery.split(/\s+/u).filter(Boolean);
+  const contactTokens = contactText.split(/\s+/u).filter(Boolean);
+  return queryTokens.every((queryToken) => contactTokens.some((contactToken) => contactToken.startsWith(queryToken.slice(0, Math.max(4, Math.min(queryToken.length, 6)))) || queryToken.startsWith(contactToken.slice(0, Math.max(4, Math.min(contactToken.length, 6))))));
+}
+
+function normalizeContactLookupText(value) {
+  return normalizeGeoText(String(value || "").replace(/\b(?:кому|контакт|письмо|сообщение)\b/giu, " ")).trim();
+}
+
 async function yandexContactsBaseUrl(token) {
   const root = "https://carddav.yandex.ru/";
   const principalXml = await yandexDavRequest(root, token, {
@@ -9083,6 +9426,25 @@ function addCronJob(scheduleText, command) {
   }
 }
 
+async function upsertCronJob(scheduleText, command, options = {}) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    const existing = db.prepare("SELECT id FROM cron_jobs WHERE command = ? ORDER BY id DESC LIMIT 1").get(command);
+    if (existing?.id) {
+      db.prepare("UPDATE cron_jobs SET schedule_text = ?, enabled = 1 WHERE id = ?").run(scheduleText, existing.id);
+      return Number(existing.id);
+    }
+    if (options.replaceCommand) {
+      db.prepare("DELETE FROM cron_jobs WHERE command = ?").run(command);
+    }
+    const result = db.prepare("INSERT INTO cron_jobs(schedule_text, command) VALUES (?, ?)").run(scheduleText, command);
+    return Number(result.lastInsertRowid);
+  } finally {
+    db.close();
+  }
+}
+
 function deleteCronJob(id) {
   initDatabase();
   const db = openDatabase();
@@ -9093,6 +9455,16 @@ function deleteCronJob(id) {
   }
 }
 
+function deleteCronJobsByCommand(command) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    db.prepare("DELETE FROM cron_jobs WHERE command = ?").run(command);
+  } finally {
+    db.close();
+  }
+}
+
 function dueCronJobs() {
   initDatabase();
   const db = openDatabase();
@@ -9638,23 +10010,87 @@ async function buildYandexDirectAnswer(question, history = []) {
       ].join("\n");
     }
 
-    if (/(почт|письм|email|e-mail)/iu.test(normalized)) {
+    if (mailFollowup || /(почт|письм|email|e-mail|спам|чернов|отправлен|исходящ|корзин)/iu.test(normalized)) {
+      if (/(авто|автомат|кажд|период|монитор|следи|проверяй|проверку|режим)/iu.test(normalized) && /(включ|запусти|начни|поставь|создай)/iu.test(normalized)) {
+        const minutes = Number(String(question || "").match(/(\d+)\s*(?:мин|минут)/iu)?.[1] || 5);
+        await yandexMailWatchEnable(minutes);
+        return `Автопроверка новых писем включена: каждые ${minutes} минут.`;
+      }
+      if (/(авто|автомат|кажд|период|монитор|следи|проверяй|проверку|режим)/iu.test(normalized) && /(выключ|отключ|останов|убери)/iu.test(normalized)) {
+        await yandexMailWatchDisable();
+        return "Автопроверка новых писем выключена.";
+      }
+      if (/(проверь|получи|есть).{0,40}(нов|свеж)/iu.test(normalized)) {
+        const result = await yandexMailWatchTick({ force: true });
+        if (!result.newMessages.length) return "Новых писем нет.";
+        return ["Новые письма:", ...result.newMessages.map((row, index) => `${index + 1}. ${formatYandexMailSummary(row)}`)].join("\n");
+      }
+      if (/(папк|ящик|mailbox|folder)/iu.test(normalized) && /(покажи|список|какие|есть)/iu.test(normalized)) {
+        const folders = await yandexMailFolders();
+        if (!folders.length) return "Папки Яндекс Почты не найдены.";
+        return ["Папки Яндекс Почты:", ...folders.map((folder, index) => `${index + 1}. ${folder.name}${folder.special ? ` (${folder.special})` : ""}`)].join("\n");
+      }
       if (/(статус|проверь|работает|доступ)/iu.test(normalized)) {
         const result = await yandexMailStatus();
         return `Яндекс Почта подключена: ${result.email}. Входящие: ${result.inbox?.exists ?? "-"}.`;
       }
-      if (/(отправ|напиши|пошли)/iu.test(normalized)) {
+      if (/(ответь|ответить|напиши\s+ответ)/iu.test(normalized)) {
+        const reply = parseYandexMailReplyRequest(question, previousAssistantText);
+        if (!reply.uid || !reply.text) return "Для ответа укажите письмо и текст. Пример: ответь на письмо #2382 текст: спасибо, получил.";
+        const result = await yandexMailReply({ ...reply, confirm: true });
+        return `Ответ отправлен на письмо #${result.replyToUid}: ${result.to.join(", ")}. Тема: ${result.subject}.`;
+      }
+      if (/(удали|удалить|перемести\s+в\s+корзин)/iu.test(normalized)) {
+        const uid = resolveYandexMailUidFromQuestion(question, previousAssistantText);
+        if (!uid) return "Какое письмо удалить? Укажите номер из списка или UID, например: удали письмо #2382.";
+        const mailbox = await resolveYandexMailbox(extractYandexMailboxName(question) || "INBOX");
+        const result = await yandexMailDelete(uid, { mailbox, confirm: true });
+        return `Письмо #${result.uid} перемещено в корзину: ${result.to}.`;
+      }
+      if (/(пометь|отметь|сделай)/iu.test(normalized) && /(прочитан|непрочитан)/iu.test(normalized)) {
+        const uid = resolveYandexMailUidFromQuestion(question, previousAssistantText);
+        if (!uid) return "Какое письмо пометить? Укажите номер из списка или UID.";
+        const seen = !/непрочитан/iu.test(normalized);
+        const mailbox = await resolveYandexMailbox(extractYandexMailboxName(question) || "INBOX");
+        const result = await yandexMailMark(uid, seen, { mailbox });
+        return `Письмо #${result.uid} помечено как ${seen ? "прочитанное" : "непрочитанное"}.`;
+      }
+      if (/(отправь|отправить|напиши|пошли)/iu.test(normalized) && !/(отправлен|исходящ)/iu.test(normalized)) {
         const draft = parseYandexMailSendRequest(question);
+        if (!draft.to.length && draft.contactQuery) {
+          const contactResult = await resolveYandexMailRecipientFromContacts(draft.contactQuery);
+          if (contactResult.status === "not-found") return `В Яндекс Контактах не нашел: ${draft.contactQuery}. Укажите email вручную.`;
+          if (contactResult.status === "no-email") return `Контакт найден, но email не указан: ${contactResult.contact.name}. Укажите email вручную.`;
+          if (contactResult.status === "ambiguous") {
+            return [
+              `Нашел несколько контактов для "${draft.contactQuery}". Уточните, кому отправить:`,
+              ...contactResult.contacts.map((contact, index) => `${index + 1}. ${contact.name || contact.email || "Контакт"}${contact.email ? `, ${contact.email}` : ", email не указан"}`),
+            ].join("\n");
+          }
+          draft.to = [contactResult.contact.email];
+        }
         if (!draft.to.length || !draft.text) {
           return "Для отправки письма укажите получателя и текст. Пример: отправь письмо user@example.com тема: Привет текст: Проверка.";
         }
         const result = await yandexMailSend({ ...draft, confirm: true });
-        return `Письмо отправлено: ${result.to.join(", ")}. Тема: ${result.subject}.`;
+        let contactNote = "";
+        if (draft.contactQuery && result.to[0] && process.stdin.isTTY) {
+          const contactResult = await resolveYandexMailRecipientFromContacts(draft.contactQuery).catch(() => null);
+          if (contactResult?.status === "no-email") {
+            const shouldAdd = await askYesNo(`Добавить ${result.to[0]} в контакт "${contactResult.contact.name}"? [y/N] `, false);
+            if (shouldAdd) {
+              const update = await yandexContactsAddEmail(draft.contactQuery, result.to[0], { confirm: true, selectFirst: true });
+              contactNote = update.status === "updated" ? `\nEmail добавлен в контакт: ${update.name || draft.contactQuery}.` : "";
+            }
+          }
+        }
+        return `Письмо отправлено: ${result.to.join(", ")}. Тема: ${result.subject}.${contactNote}`;
       }
       if (/(сколько|количеств|есть\s+ли)/iu.test(normalized) && /непрочитан/iu.test(normalized)) {
-        const count = await yandexMailCount({ unread: true });
+        const mailbox = await resolveYandexMailbox(extractYandexMailboxName(question) || "INBOX");
+        const count = await yandexMailCount({ mailbox, unread: true });
         if (!count) return "Непрочитанных писем нет.";
-        const latest = await yandexMailList({ limit: 1, unread: true });
+        const latest = await yandexMailList({ mailbox, limit: 1, unread: true });
         return [
           `Непрочитанных писем: ${count}.`,
           latest[0] ? `Самое свежее: ${formatYandexMailSummary(latest[0])}` : "",
@@ -9664,13 +10100,14 @@ async function buildYandexDirectAnswer(question, history = []) {
         const uid = resolveYandexMailUidFromQuestion(question, previousAssistantText)
           || await getLatestYandexMailUid({ unread: /непрочитан/iu.test(normalized) });
         if (!uid) return "Писем для чтения не найдено.";
-        const row = await yandexMailRead(uid);
+        const row = await yandexMailRead(uid, { mailbox: await resolveYandexMailbox(extractYandexMailboxName(question) || "INBOX") });
         if (!row || row.status === "not-found") return `Письмо #${uid} не найдено.`;
         return formatYandexMailRead(row);
       }
+      const mailbox = await resolveYandexMailbox(extractYandexMailboxName(question) || "INBOX");
       const rows = /(найди|поиск)/iu.test(normalized)
-        ? await yandexMailSearch(cleanupYandexQuery(question), { limit: 10 })
-        : await yandexMailList({ limit: 10, unread: /непрочитан/iu.test(normalized) });
+        ? await yandexMailSearch(cleanupYandexQuery(question), { mailbox, limit: 10 })
+        : await yandexMailList({ mailbox, limit: 10, unread: /непрочитан/iu.test(normalized) });
       if (!rows.length) return "Писем по запросу не найдено.";
       return ["Яндекс Почта:", ...rows.map((row, index) => `${index + 1}. ${formatYandexMailSummary(row)}`)].join("\n");
     }
@@ -9682,6 +10119,21 @@ async function buildYandexDirectAnswer(question, history = []) {
     }
 
     if (/(контакт|адресн)/iu.test(normalized)) {
+      if (/(добав|запиши|сохрани).{0,40}(email|e-mail|почт)/iu.test(normalized)) {
+        const email = String(question || "").match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/iu)?.[0] || "";
+        const query = cleanupYandexContactEmailTarget(question, email);
+        if (!email || !query) return "Укажите контакт и email. Пример: добавь email petrov@example.com к контакту Петров.";
+        const result = await yandexContactsAddEmail(query, email, { confirm: true });
+        if (result.status === "not-found") return `Контакт не найден: ${query}.`;
+        if (result.status === "has-email") return `У контакта уже есть email: ${result.contact.name}, ${result.contact.email}.`;
+        if (result.status === "ambiguous") {
+          return [
+            `Нашел несколько контактов для "${query}". Уточните контакт:`,
+            ...result.contacts.map((contact, index) => `${index + 1}. ${contact.name || contact.email || "Контакт"}${contact.email ? `, ${contact.email}` : ""}`),
+          ].join("\n");
+        }
+        return `Email добавлен в контакт: ${result.name || query}, ${result.email}.`;
+      }
       if (/(статус|проверь|работает|доступ)/iu.test(normalized)) {
         const result = await yandexContactsStatus();
         return `Яндекс Контакты подключены: ${result.displayName || result.url}.`;
@@ -9700,7 +10152,7 @@ async function buildYandexDirectAnswer(question, history = []) {
 }
 
 function isYandexServiceQuestion(normalized) {
-  return /(яндекс|яндес|язндекс|язндекс|яндкс|yandex|почт|письм|календар|контакт|телемост)/iu.test(String(normalized || ""));
+  return /(яндекс|яндес|язндекс|язндекс|яндкс|yandex|почт|письм|календар|контакт|телемост|спам|чернов|отправлен|исходящ|корзин)/iu.test(String(normalized || ""));
 }
 
 function isYandexIdentityQuestion(normalized) {
@@ -9712,7 +10164,8 @@ function isYandexIdentityQuestion(normalized) {
 function isYandexMailFollowupQuestion(normalized, question) {
   return isYandexMailReadRequest(normalized)
     || isYandexMailSelectionQuestion(question)
-    || /(самое\s+свеж|последн|текст\s+(?:то\s+)?(?:письм|где)|содержим)/iu.test(String(normalized || ""));
+    || /(ответь|ответить|напиши\s+ответ|удали|удалить|перемести\s+в\s+корзин|пометь|отметь|сделай)/iu.test(String(normalized || ""))
+    || /(самое\s+свеж|последн|получи|получить|текст\s+(?:то\s+)?(?:письм|где)|содержим)/iu.test(String(normalized || ""));
 }
 
 function cleanupYandexQuery(question) {
@@ -9725,6 +10178,16 @@ function cleanupYandexQuery(question) {
     .trim();
 }
 
+function extractYandexMailboxName(question) {
+  const text = String(question || "").toLocaleLowerCase("ru-RU");
+  if (/(спам|spam|junk)/iu.test(text)) return "spam";
+  if (/(чернов|draft)/iu.test(text)) return "drafts";
+  if (/(отправлен|исходящ|sent)/iu.test(text)) return "sent";
+  if (/(корзин|удален|удалён|trash|bin)/iu.test(text)) return "trash";
+  const explicit = String(question || "").match(/(?:папк[аиуы]?|mailbox|folder)\s+["'«]?([^"'».,!?]+)["'»]?/iu)?.[1];
+  return explicit ? explicit.trim() : "";
+}
+
 function extractYandexMailUid(question) {
   const text = String(question || "");
   const explicit = text.match(/(?:#|uid\s*|письм[оа]?\s*)?(\d{3,})/iu)?.[1];
@@ -9743,7 +10206,12 @@ function resolveYandexMailUidFromQuestion(question, previousAssistantText = "")
     const uid = extractYandexMailUidByOrdinal(previousAssistantText, Number(ordinal));
     if (uid) return uid;
   }
-  if (/(самое\s+свеж|последн|текст\s+(?:то\s+)?(?:письм|где)|содержим)/iu.test(String(question || ""))) {
+  const actionOrdinal = String(question || "").match(/(?:удали|удалить|пометь|отметь|сделай|ответь|ответить)\s+#?(\d{1,3})\.?(?!\d)/iu)?.[1];
+  if (actionOrdinal) {
+    const uid = extractYandexMailUidByOrdinal(previousAssistantText, Number(actionOrdinal));
+    if (uid) return uid;
+  }
+  if (/(самое\s+свеж|последн|получи|получить|текст\s+(?:то\s+)?(?:письм|где)|содержим)/iu.test(String(question || ""))) {
     return extractFirstYandexMailUid(previousAssistantText);
   }
   return 0;
@@ -9764,10 +10232,22 @@ function extractFirstYandexMailUid(text) {
 }
 
 function isYandexMailReadRequest(normalizedQuestion) {
-  return /(^|\s)(прочитай|прочти|открой|раскрой|прочитаем)(\s|$)/iu.test(normalizedQuestion)
+  return /(^|\s)(прочитай|прочти|открой|раскрой|прочитаем|получи|получить)(\s|$)/iu.test(normalizedQuestion)
     || /(покажи\s+содерж|о чем|о чём|текст\s+(?:то\s+)?(?:письм|где)|содержим)/iu.test(normalizedQuestion);
 }
 
+function parseYandexMailReplyRequest(question, previousAssistantText = "") {
+  const text = String(question || "").replace(/\s+/g, " ").trim();
+  const uid = resolveYandexMailUidFromQuestion(text, previousAssistantText);
+  const bodyMatch = text.match(/(?:текст|body|сообщение)\s*:\s*(.*)$/iu)
+    || text.match(/(?:ответь|ответить|напиши\s+ответ)(?:\s+на\s+письмо\s+#?\d+|\s+#?\d+)?\s*:?\s*(.*)$/iu);
+  return {
+    uid,
+    text: (bodyMatch?.[1] || "").trim(),
+    mailbox: extractYandexMailboxName(question) || "INBOX",
+  };
+}
+
 async function getLatestYandexMailUid(options = {}) {
   const rows = await yandexMailList({ limit: 1, unread: Boolean(options.unread) });
   return rows[0]?.uid || 0;
@@ -9778,6 +10258,7 @@ function parseYandexMailSendRequest(question) {
   const emails = [...text.matchAll(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/giu)].map((match) => match[0]);
   const subjectMatch = text.match(/(?:тема|subject)\s*:\s*(.*?)(?=\s+(?:текст|body|сообщение)\s*:|$)/iu);
   const bodyMatch = text.match(/(?:текст|body|сообщение)\s*:\s*(.*)$/iu);
+  const contactMatch = text.match(/^(?:отправь|отправить|напиши|пошли)\s+(.+?)(?:\s+письмо|\s+сообщение|\s+текст\s*:|\s+напомни|\s+скажи|$)/iu);
   const withoutCommand = text
     .replace(/^(?:отправь|отправить|напиши|пошли)\s+(?:письмо\s+)?/iu, "")
     .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/giu, "")
@@ -9785,10 +10266,33 @@ function parseYandexMailSendRequest(question) {
   return {
     to: emails,
     subject: (subjectMatch?.[1] || "Сообщение от IOLA CLI").trim(),
-    text: (bodyMatch?.[1] || (!subjectMatch ? withoutCommand : "")).trim(),
+    text: (bodyMatch?.[1] || cleanupYandexMailBodyText(!subjectMatch ? withoutCommand : "")).trim(),
+    contactQuery: cleanupYandexContactQuery((contactMatch?.[1] || "").replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/giu, "")),
   };
 }
 
+function cleanupYandexMailBodyText(value) {
+  return String(value || "")
+    .replace(/^.+?\s+(?:письмо|сообщение)\s+/iu, "")
+    .trim();
+}
+
+function cleanupYandexContactQuery(value) {
+  return String(value || "")
+    .replace(/\b(?:письмо|сообщение|текст|напомни|скажи|ему|ей)\b/giu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function cleanupYandexContactEmailTarget(question, email) {
+  return String(question || "")
+    .replace(email || "", " ")
+    .replace(/\b(?:добавь|добавить|запиши|сохрани|email|e-mail|почту|почта|к|ко|контакту|контакт)\b/giu, " ")
+    .replace(/[,:;.!?]+/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
 function formatYandexMailSummary(row) {
   return `#${row.uid} ${row.subject || "(без темы)"}${row.from ? `, от ${row.from}` : ""}${row.date ? `, ${row.date}` : ""}`;
 }
@@ -10414,8 +10918,8 @@ 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_ls {path}, yandex_disk_mkdir {path}, yandex_disk_find {query,path}, yandex_disk_save_text {path,text}, yandex_mail_list {limit,unread}, yandex_mail_search {query}, yandex_mail_read {uid}, yandex_calendar_list {start,end}, yandex_contacts_search {query}.",
-    "Опасные Yandex tools используй только при явной просьбе пользователя и с confirm=true: yandex_disk_share, yandex_disk_delete, yandex_mail_send, yandex_calendar_create_event, yandex_telemost_create_event.",
+    "Yandex tools: yandex_identity_me {}, yandex_disk_ls {path}, yandex_disk_mkdir {path}, yandex_disk_find {query,path}, yandex_disk_save_text {path,text}, 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_calendar_list {start,end}, yandex_contacts_search {query}.",
+    "Опасные Yandex tools используй только при явной просьбе пользователя и с confirm=true: yandex_disk_share, yandex_disk_delete, yandex_mail_send, yandex_mail_reply, yandex_mail_delete, yandex_calendar_create_event, yandex_telemost_create_event.",
     "MCP tools доступны как mcp:SERVER:TOOL, например mcp:iola-local:search.",
     "Для выгрузки CSV добавь export_report с format=csv и output, если пользователь назвал файл.",
     `Вопрос: ${question}`,
@@ -10484,9 +10988,16 @@ function inferToolPlan(question, options = {}) {
     if (/(найди|поиск)/iu.test(normalized)) return { steps: [{ tool: "yandex_disk_find", args: { query: question, path: CLOUD_DEFAULT_REMOTE_DIR, limit: 20 } }] };
     return { steps: [{ tool: "yandex_disk_ls", args: { path: CLOUD_DEFAULT_REMOTE_DIR } }] };
   }
-  if (/(почт|письм|email|e-mail)/iu.test(normalized)) {
-    if (/(найди|поиск)/iu.test(normalized)) return { steps: [{ tool: "yandex_mail_search", args: { query: question, limit: 20 } }] };
-    return { steps: [{ tool: "yandex_mail_list", args: { limit: 10, unread: /непрочитан/iu.test(normalized) } }] };
+  if (/(почт|письм|email|e-mail|спам|чернов|отправлен|исходящ|корзин)/iu.test(normalized)) {
+    const mailbox = extractYandexMailboxName(question) || "INBOX";
+    const uid = extractYandexMailUid(question);
+    if (/(папк|ящик|mailbox|folder)/iu.test(normalized)) return { steps: [{ tool: "yandex_mail_folders", args: {} }] };
+    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_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 (/(календар|событи|встреч|телемост)/iu.test(normalized)) {
     return { steps: [{ tool: normalized.includes("телемост") ? "yandex_telemost_create_event" : "yandex_calendar_list", args: { limit: 20 } }] };
@@ -11050,6 +11561,10 @@ function formatToolResult(result, options) {
     if (row.provider === "yandex-disk" && row.publicUrl) return `Публичная ссылка: ${row.publicUrl}`;
     if (row.provider === "yandex-disk" && row.remote) return `Яндекс Диск: ${row.status || "ok"} ${row.remote}`;
     if (row.uid && (row.subject || row.from)) return `Письмо #${row.uid}: ${row.subject || "(без темы)"}${row.from ? `, от ${row.from}` : ""}`;
+    if (row.status === "moved-to-trash") return `Письмо #${row.uid} перемещено в корзину: ${row.to}`;
+    if (row.status === "seen" || row.status === "unseen") return `Письмо #${row.uid}: ${row.status === "seen" ? "прочитано" : "непрочитано"}`;
+    if (row.status === "sent" && row.to) return `Письмо отправлено: ${Array.isArray(row.to) ? row.to.join(", ") : row.to}. Тема: ${row.subject || "-"}`;
+    if (row.special || row.delimiter) return `Папка почты: ${row.name}${row.special ? ` (${row.special})` : ""}`;
     if (row.login || row.defaultEmail) return `Yandex ID: ${row.displayName || row.login || "-"}${row.defaultEmail ? `, ${row.defaultEmail}` : ""}`;
     if (row.title && (row.start || row.end)) return `${row.title}: ${row.start || "-"}${row.end ? ` - ${row.end}` : ""}`;
     if (row.email || row.phone) return formatYandexContact(row);

package/test/smoke-test.js

@@ -83,6 +83,17 @@ assertIncludes(cliSource, "resolveYandexMailUidFromQuestion", "Yandex mail follo
 assertIncludes(cliSource, "extractYandexMailUidByOrdinal", "Yandex mail follow-ups should support numbered selections");
 assertIncludes(cliSource, "BODY[TEXT]", "Yandex mail read should mark opened messages as seen");
 assertIncludes(cliSource, "markSeen === false", "Yandex mail read should keep an explicit no-mark fallback");
+assertIncludes(cliSource, "yandex_mail_folders", "Yandex mail should expose folders as a tool");
+assertIncludes(cliSource, "yandex_mail_reply", "Yandex mail should expose reply as a tool");
+assertIncludes(cliSource, "yandex_mail_delete", "Yandex mail should expose safe delete as a tool");
+assertIncludes(cliSource, "yandex_mail_mark", "Yandex mail should expose read/unread mark as a tool");
+assertIncludes(cliSource, "decodeImapModifiedUtf7", "Yandex mail folders should decode IMAP modified UTF-7 names");
+assertIncludes(cliSource, "encodeImapModifiedUtf7", "Yandex mail should select non-ASCII folders via IMAP modified UTF-7");
+assertIncludes(cliSource, "yandexMailWatchEnable", "Yandex mail should support scheduled new-mail polling");
+assertIncludes(cliSource, "yandexMailWatchTick", "Yandex mail should support manual new-mail polling");
+assertIncludes(cliSource, "resolveYandexMailRecipientFromContacts", "Yandex mail should resolve recipients from contacts");
+assertIncludes(cliSource, "yandexContactsAddEmail", "Yandex contacts should support adding email to a contact");
+assertIncludes(cliSource, "yandex_contacts_add_email", "Yandex contacts add email should be exposed as a tool");
 assertIncludes(cliSource, "buildCasualDirectAnswer(question)", "Casual greetings should bypass external AI providers");
 assertNotIncludes(cliSource, "Сервисы через запятую [identity,disk]", "Yandex setup should not ask for services during connector setup");
 if (!packageJson.files.includes("docs/assets/iola-oauth-icon.png")) {

package/wiki//320/241/320/272/320/270/320/273/320/273/321/213-/320/264/320/273/321/217-/320/266/320/270/321/202/320/265/320/273/320/265/320/271.md

@@ -172,9 +172,26 @@ iola geo services "Йошкар-Ола, улица Петрова, 15"
 
 - проверить доступ к почте;
 - показать последние или непрочитанные письма;
+- показать папки почты: входящие, отправленные, черновики, спам, корзина и пользовательские папки;
+- показать письма из конкретной папки, например из спама, черновиков или отправленных;
 - найти письмо;
-- прочитать письмо по UID;
-- отправить письмо только после явного подтверждения.
+- прочитать письмо по UID или номеру из последнего списка;
+- при чтении по просьбе пользователя пометить письмо прочитанным;
+- пометить письмо прочитанным или непрочитанным;
+- отправить письмо только после явного запроса;
+- ответить на письмо по UID или номеру из последнего списка;
+- удалить письмо безопасно: переместить его в корзину, а не стирать безвозвратно.
+- включить автоопрос новых писем, например каждые 5 минут;
+- выключить автоопрос новых писем;
+- вручную проверить новые письма через mail-watch tick;
+- отправить письмо по имени контакта из Яндекс Контактов;
+- если найдено несколько однофамильцев, попросить уточнить получателя;
+- если контакт найден, но email не указан, прямо сообщить об этом;
+- добавить email в существующий контакт по явной просьбе пользователя.
+
+Список писем и поиск не меняют статус письма. Статус меняется только при чтении письма, явной пометке или явном удалении.
+
+Автоопрос почты использует локальный cron CLI. Он не передает письма на сервер IOLA: токены, состояние последнего UID и расписание хранятся на компьютере пользователя.
 
 ### yandex-calendar