@axon-assistant/core 2026.8.23

package/dist/plugin-host.js

@@ -0,0 +1,1870 @@
+// ../core/dist/logger.js
+import { pino } from "pino";
+var logger = pino(
+  {
+    level: process.env["AXON_LOG_LEVEL"] ?? "info",
+    redact: {
+      paths: [
+        "apiKey",
+        "token",
+        "secret",
+        "password",
+        "*.apiKey",
+        "*.token",
+        "*.secret",
+        "*.password",
+        "headers.authorization"
+      ],
+      censor: "[\u0441\u043A\u0440\u044B\u0442\u043E]"
+    }
+  },
+  // Логи — в stderr. stdout остаётся под вывод самой программы: демон печатает
+  // туда строку рукопожатия для родительского процесса, и лог, попавший в тот
+  // же поток, читается как эта строка.
+  process.stderr
+);
+
+// ../core/dist/storage/sqlite.js
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+function requireSqlite() {
+  const original = process.emitWarning;
+  process.emitWarning = (warning, ...rest) => {
+    const text = typeof warning === "string" ? warning : warning.message;
+    if (text.includes("SQLite is an experimental feature"))
+      return;
+    original(warning, ...rest);
+  };
+  try {
+    return require2("node:sqlite");
+  } finally {
+    process.emitWarning = original;
+  }
+}
+var { DatabaseSync } = requireSqlite();
+
+// ../core/dist/memory/Observations.js
+var DAY_MS = 24 * 60 * 60 * 1e3;
+
+// ../core/dist/storage/Backup.js
+import { createRequire as createRequire2 } from "node:module";
+var require3 = createRequire2(import.meta.url);
+
+// ../protocol/dist/primitives.js
+import { z } from "zod";
+var zTimestamp = z.string().datetime();
+var zId = z.string().uuid();
+var zExternalId = z.string().min(1).max(256);
+var zSeq = z.number().int().nonnegative();
+var zCursor = zSeq;
+
+// ../protocol/dist/errors.js
+import { z as z2 } from "zod";
+var zErrorCode = z2.enum([
+  /** Кадр не прошёл валидацию схемы. */
+  "bad_request",
+  /** Токен устройства отсутствует, истёк или отозван. */
+  "unauthorized",
+  /** Токен валиден, но у устройства нет нужного scope. */
+  "forbidden",
+  /** Разговор / сообщение / устройство не найдены. */
+  "not_found",
+  /** Команда неизвестна этой версии ядра. */
+  "unknown_command",
+  /** Major протокола клиента не совпал с ядром. */
+  "protocol_mismatch",
+  /** Клиент просит события, которые уже вычищены компактификацией журнала. */
+  "cursor_too_old",
+  /** Операция отменена пользователем или обрывом соединения. */
+  "cancelled",
+  /** Упёрлись в лимит: бюджет токенов, размер файла, частота запросов. */
+  "limit_exceeded",
+  /** Ошибка внешнего провайдера (AI, умный дом, telegram). */
+  "upstream_failed",
+  /** Всё остальное. */
+  "internal"
+]);
+var zProtocolError = z2.object({
+  code: zErrorCode,
+  /** Человекочитаемое описание. Не парсить. */
+  message: z2.string(),
+  /** Дополнительные поля под конкретный код: `{ retryAfterMs }`, `{ requiredScope }` и т.п. */
+  details: z2.record(z2.unknown()).optional(),
+  /** Есть ли смысл повторить запрос. Клиент не должен угадывать это по коду. */
+  retryable: z2.boolean().default(false)
+});
+
+// ../protocol/dist/domain.js
+import { z as z3 } from "zod";
+var zContentPart = z3.discriminatedUnion("type", [
+  z3.object({
+    type: z3.literal("text"),
+    text: z3.string()
+  }),
+  z3.object({
+    type: z3.literal("blob"),
+    blobId: zId,
+    mime: z3.string(),
+    bytes: z3.number().int().nonnegative(),
+    name: z3.string().optional()
+  })
+]);
+var zRole = z3.enum(["user", "assistant", "tool", "system"]);
+var zUsage = z3.object({
+  inputTokens: z3.number().int().nonnegative(),
+  /** Прочитано из кэша промпта. */
+  cachedInputTokens: z3.number().int().nonnegative().default(0),
+  /** Записано в кэш промпта. */
+  cacheWriteTokens: z3.number().int().nonnegative().default(0),
+  outputTokens: z3.number().int().nonnegative(),
+  /** Оценка стоимости по тарифу провайдера на момент вызова. */
+  costUsd: z3.number().nonnegative().optional(),
+  provider: z3.string(),
+  model: z3.string()
+});
+var zRiskTier = z3.enum(["safe", "sensitive", "dangerous"]);
+var zToolInfo = z3.object({
+  name: z3.string(),
+  title: z3.string(),
+  description: z3.string(),
+  tier: zRiskTier,
+  /** JSON Schema аргументов. Клиенту нужна для отрисовки карточки вызова. */
+  parameters: z3.record(z3.unknown()),
+  /** Кто предоставил инструмент: `builtin` или id плагина. */
+  source: z3.string(),
+  enabled: z3.boolean()
+});
+var zProviderInfo = z3.object({
+  id: z3.string(),
+  title: z3.string(),
+  /** Нужен ли API-ключ. Локальные модели и провайдеры плагинов обходятся без него. */
+  requiresKey: z3.boolean(),
+  /** Под каким именем ключ лежит в секретах ядра. */
+  secretKey: z3.string(),
+  defaultModel: z3.string(),
+  defaultBaseUrl: z3.string().optional(),
+  supportsPromptCache: z3.boolean(),
+  /** Куда идти за ключом — показывается в онбординге. */
+  keyUrl: z3.string().optional(),
+  /** Готов ли к работе: ключ задан либо не требуется. */
+  configured: z3.boolean(),
+  /** `builtin` или `plugin:<id>`. */
+  source: z3.string(),
+  /** Известные модели. У встроенных провайдеров пусто — там модель вводится руками. */
+  models: z3.array(z3.object({
+    id: z3.string(),
+    name: z3.string().optional(),
+    contextTokens: z3.number().int().positive().optional()
+  })).default([])
+});
+var zToolCall = z3.object({
+  /** id приходит от провайдера, поэтому не UUID. */
+  id: zExternalId,
+  name: z3.string(),
+  arguments: z3.record(z3.unknown())
+});
+var zToolResult = z3.discriminatedUnion("ok", [
+  z3.object({
+    ok: z3.literal(true),
+    preview: z3.string(),
+    truncated: z3.boolean().default(false),
+    /** Полный вывод, если он не поместился в preview. */
+    fullBlobId: zId.optional(),
+    durationMs: z3.number().int().nonnegative()
+  }),
+  z3.object({
+    ok: z3.literal(false),
+    error: z3.string(),
+    durationMs: z3.number().int().nonnegative()
+  })
+]);
+var zContextPart = z3.object({
+  key: z3.string(),
+  label: z3.string(),
+  tokens: z3.number().int().nonnegative(),
+  cached: z3.boolean(),
+  detail: z3.string().optional()
+});
+var zContextReport = z3.object({
+  parts: z3.array(zContextPart),
+  totalTokens: z3.number().int().nonnegative(),
+  cacheableTokens: z3.number().int().nonnegative(),
+  provider: z3.string().optional(),
+  model: z3.string().optional(),
+  supportsPromptCache: z3.boolean()
+});
+var zMessage = z3.object({
+  id: zId,
+  conversationId: zId,
+  role: zRole,
+  parts: z3.array(zContentPart),
+  /** Заполняется у assistant-сообщения, которое запросило инструменты. */
+  toolCalls: z3.array(zToolCall).optional(),
+  /** Заполняется у tool-сообщения — к какому вызову относится результат. */
+  toolCallId: zExternalId.optional(),
+  createdAt: zTimestamp,
+  /** Расход на генерацию именно этого сообщения. */
+  usage: zUsage.optional()
+});
+var zConversation = z3.object({
+  id: zId,
+  title: z3.string(),
+  createdAt: zTimestamp,
+  updatedAt: zTimestamp,
+  archived: z3.boolean().default(false),
+  /** Сколько токенов суммарно съел разговор за всё время. Видно пользователю. */
+  totalTokens: z3.number().int().nonnegative().default(0)
+});
+var zRunState = z3.enum(["running", "done", "failed", "cancelled"]);
+var zStopReason = z3.enum([
+  /** Модель закончила ответ сама. */
+  "end_turn",
+  /** Упёрлись в потолок итераций «модель → инструмент → модель». */
+  "max_iterations",
+  /** Исчерпан бюджет токенов на прогон. */
+  "budget_exhausted",
+  /** Пользователь нажал стоп. */
+  "cancelled",
+  /** Разрешение на инструмент не выдано. */
+  "permission_denied",
+  /** Модель отказалась отвечать (сработали классификаторы безопасности). */
+  "refusal",
+  /** Провайдер или инструмент упали. */
+  "error"
+]);
+var zPermissionRequest = z3.object({
+  id: zId,
+  runId: zId,
+  toolName: z3.string(),
+  tier: zRiskTier,
+  /** Почему агент считает, что это нужно — показывается пользователю. */
+  reason: z3.string(),
+  arguments: z3.record(z3.unknown()),
+  /** До какого момента запрос имеет смысл; после — считается протухшим. */
+  expiresAt: zTimestamp
+});
+var zPermissionDecision = z3.enum([
+  "allow_once",
+  "allow_always",
+  "deny_once",
+  "deny_always",
+  /** Никто не ответил до expiresAt. */
+  "expired"
+]);
+var zScope = z3.enum([
+  "chat.read",
+  "chat.write",
+  "tools.safe",
+  "tools.sensitive",
+  "tools.dangerous",
+  "settings.write",
+  "devices.manage"
+]);
+var zDevicePlatform = z3.enum(["desktop", "mobile", "web", "telegram", "cli"]);
+var zDevice = z3.object({
+  id: zId,
+  name: z3.string(),
+  platform: zDevicePlatform,
+  scopes: z3.array(zScope),
+  pairedAt: zTimestamp,
+  lastSeenAt: zTimestamp.optional()
+});
+var zFact = z3.object({
+  id: zId,
+  key: z3.string(),
+  value: z3.string(),
+  /** Откуда факт взялся: `user` — сказал явно, `inferred` — агент вывел сам. */
+  origin: z3.enum(["user", "inferred"]),
+  createdAt: zTimestamp,
+  updatedAt: zTimestamp
+});
+var zObservation = z3.object({
+  id: zId,
+  text: z3.string(),
+  /**
+   * О чём наблюдение. Нужен не для красоты: разные виды стареют с разной
+   * скоростью — привычка живёт годами, а настроение недели две.
+   */
+  kind: z3.enum(["habit", "preference", "context", "mood", "relationship"]),
+  /** Вес на момент записи. Наружу отдаётся как есть, затухание считает ядро. */
+  weight: z3.number(),
+  /** Сколько раз подтверждалось. В отличие от веса, не убывает. */
+  hits: z3.number().int().nonnegative(),
+  createdAt: zTimestamp,
+  updatedAt: zTimestamp,
+  /** Когда в последний раз подтвердилось. От него считается затухание. */
+  lastSeenAt: zTimestamp
+});
+
+// ../protocol/dist/impulse.js
+import { z as z4 } from "zod";
+var zTimeOfDay = z4.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "\u0412\u0440\u0435\u043C\u044F \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 \u0427\u0427:\u041C\u041C");
+var zImpulse = z4.object({
+  enabled: z4.boolean().default(false),
+  /** Сколько раз за сутки агент может написать первым. */
+  maxPerDay: z4.number().int().min(1).max(12).default(3),
+  /** Сколько ждать между двумя своими сообщениями. */
+  minGapMinutes: z4.number().int().min(30).max(24 * 60).default(180),
+  /**
+   * Сколько человек должен молчать, чтобы к нему имело смысл обращаться.
+   *
+   * Написать тому, кто ответил пять минут назад, — не инициатива, а помеха:
+   * он и так здесь, и если бы хотел продолжить, продолжил бы сам.
+   */
+  idleMinutes: z4.number().int().min(5).max(24 * 60).default(45),
+  /** Начало тишины. По умолчанию ночь. */
+  quietFrom: zTimeOfDay.default("23:00"),
+  quietTo: zTimeOfDay.default("09:00")
+});
+
+// ../protocol/dist/persona.js
+import { z as z5 } from "zod";
+var zPersonaPreset = z5.enum(["calm", "warm", "blunt", "custom"]);
+var zPersona = z5.object({
+  /**
+   * Как зовут агента. Пусто — имени ещё нет.
+   *
+   * Умолчания здесь нет намеренно. Подставь любое, даже название программы, —
+   * и агент представится им в первом же разговоре, то есть ответит на вопрос
+   * «как тебя зовут» раньше, чем человек успел на него ответить. Пустая
+   * строка — это не «забыли заполнить», а честное «пока никак».
+   */
+  name: z5.string().max(40).default(""),
+  preset: zPersonaPreset.default("calm"),
+  /** Как зовут человека. Пусто — агент не выдумывает обращение. */
+  userName: z5.string().max(40).default(""),
+  /** На «ты» или на «вы». Влияет и на глаголы, поэтому это не косметика. */
+  address: z5.enum(["\u0442\u044B", "\u0432\u044B"]).default("\u0442\u044B"),
+  /**
+   * Юмор отдельной ручкой, а не частью характера: спокойный человек бывает и
+   * с иронией, и без неё, а вот выкрутить это в пресете невозможно — пресетов
+   * стало бы вдвое больше.
+   */
+  humor: z5.enum(["none", "dry", "playful"]).default("dry"),
+  /** Длина ответа по умолчанию. */
+  verbosity: z5.enum(["short", "normal", "detailed"]).default("normal"),
+  /**
+   * Насколько агент лезет со своим мнением и следующим шагом внутри разговора.
+   * Это не про то, пишет ли он первым, — за это отвечает планировщик.
+   */
+  initiative: z5.enum(["low", "normal", "high"]).default("normal"),
+  emoji: z5.boolean().default(false),
+  /** Свободное дополнение поверх собранного характера. */
+  custom: z5.string().max(4e3).default(""),
+  /**
+   * Знакомство состоялось.
+   *
+   * Пока флага нет, агент получает задание познакомиться — узнать, как
+   * обращаться к человеку и как его называть самого. Хранить это флагом, а не
+   * выводить из «имя не пустое», важно: человек мог сознательно оставить
+   * умолчания, и переспрашивать его об этом каждый разговор — худшее, что
+   * можно сделать со знакомством.
+   */
+  configured: z5.boolean().default(false)
+});
+
+// ../protocol/dist/plugins.js
+import { z as z6 } from "zod";
+var zPluginId = z6.string().min(1).max(40).regex(/^[a-z0-9][a-z0-9_-]*$/, "\u0422\u043E\u043B\u044C\u043A\u043E \u0441\u0442\u0440\u043E\u0447\u043D\u044B\u0435 \u043B\u0430\u0442\u0438\u043D\u0441\u043A\u0438\u0435 \u0431\u0443\u043A\u0432\u044B, \u0446\u0438\u0444\u0440\u044B, \u0434\u0435\u0444\u0438\u0441 \u0438 \u043F\u043E\u0434\u0447\u0451\u0440\u043A\u0438\u0432\u0430\u043D\u0438\u0435");
+var zPluginPermission = z6.enum([
+  /** Читает и пишет файлы вне своей папки. */
+  "fs",
+  /** Ходит в сеть. */
+  "net",
+  /** Запускает процессы. */
+  "shell",
+  /** Читает секреты ядра — только свои, из собственного пространства имён. */
+  "secrets",
+  /** Подписывается на журнал: видит переписку. */
+  "journal"
+]);
+var zMcpTransport = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.literal("stdio"),
+    command: z6.string().min(1),
+    args: z6.array(z6.string()).default([]),
+    env: z6.record(z6.string()).default({}),
+    cwd: z6.string().optional()
+  }),
+  z6.object({
+    type: z6.literal("http"),
+    url: z6.string().url(),
+    headers: z6.record(z6.string()).default({})
+  })
+]);
+var zPluginSettingField = z6.object({
+  key: z6.string().min(1).max(60),
+  label: z6.string().max(120),
+  description: z6.string().max(400).optional(),
+  /**
+   * `secret` хранится шифрованным и не отдаётся обратно клиенту — только
+   * признак «задано». Всё остальное лежит в обычных настройках.
+   */
+  type: z6.enum(["text", "secret", "number", "boolean", "select", "path", "textarea"]),
+  options: z6.array(z6.object({ value: z6.string(), label: z6.string() })).optional(),
+  default: z6.unknown().optional(),
+  required: z6.boolean().default(false),
+  placeholder: z6.string().max(200).optional(),
+  /**
+   * Показывать поле, только когда другое имеет заданное значение.
+   *
+   * Без этого плагин с двумя способами подключения вываливает поля обоих
+   * сразу, и человек заполняет половину впустую. Условие простое до
+   * неприличия — одно поле, одно значение: сложнее бывает нужно редко, а
+   * язык выражений в манифесте плагина означал бы интерпретатор в ядре.
+   */
+  visibleWhen: z6.object({ key: z6.string(), equals: z6.unknown() }).optional()
+});
+var zPluginSettingSection = z6.object({
+  title: z6.string().max(120),
+  description: z6.string().max(600).optional(),
+  fields: z6.array(z6.string()).default([])
+});
+var zPluginAction = z6.object({
+  name: z6.string().min(1).max(60),
+  label: z6.string().max(120),
+  description: z6.string().max(400).optional(),
+  /** Раздел, в котором показать кнопку. Пусто — внизу страницы. */
+  section: z6.string().max(120).optional(),
+  /** Спросить подтверждение перед вызовом. Для необратимого. */
+  confirm: z6.string().max(300).optional()
+});
+var zPluginJob = z6.object({
+  name: z6.string().min(1).max(60),
+  /** Период в секундах. Минимум минута: чаще — это не расписание, а цикл. */
+  everySeconds: z6.number().int().min(60),
+  /** Запускать сразу при активации, не дожидаясь первого периода. */
+  immediate: z6.boolean().default(false)
+});
+var zPluginManifest = z6.object({
+  id: zPluginId,
+  name: z6.string().min(1).max(80),
+  description: z6.string().max(500).default(""),
+  version: z6.string().max(40).default("0.0.0"),
+  author: z6.string().max(120).optional(),
+  homepage: z6.string().max(300).optional(),
+  /** Версия API плагинов, на которую он рассчитан. */
+  api: z6.number().int().positive().default(1),
+  /** Точка входа. Нет — плагин без кода: только MCP-серверы и скиллы. */
+  main: z6.string().max(200).optional(),
+  permissions: z6.array(zPluginPermission).default([]),
+  settings: z6.array(zPluginSettingField).default([]),
+  sections: z6.array(zPluginSettingSection).default([]),
+  actions: z6.array(zPluginAction).default([]),
+  /** Папка со скиллами (*.md) относительно корня плагина. */
+  skills: z6.string().max(200).optional(),
+  mcpServers: z6.record(zMcpTransport).default({}),
+  jobs: z6.array(zPluginJob).default([])
+});
+var zPluginStatus = z6.enum(["disabled", "starting", "ready", "failed", "needs_setup"]);
+var zPluginOrigin = z6.object({
+  type: z6.enum(["catalog", "git", "link", "builtin", "archive"]),
+  /** Идентификатор в каталоге, URL репозитория, путь на диске или имя архива. */
+  ref: z6.string()
+});
+var zMcpServerInfo = z6.object({
+  name: z6.string(),
+  status: zPluginStatus,
+  error: z6.string().optional(),
+  toolCount: z6.number().int().nonnegative().default(0)
+});
+var zSkillInfo = z6.object({
+  /** Уникально в пределах ядра: `<pluginId>/<file>`. */
+  id: z6.string(),
+  name: z6.string(),
+  description: z6.string(),
+  /** Оценка размера тела в токенах — видно, во что обойдётся раскрытие. */
+  tokens: z6.number().int().nonnegative().default(0),
+  enabled: z6.boolean().default(true)
+});
+var zPluginInfo = z6.object({
+  id: zPluginId,
+  name: z6.string(),
+  description: z6.string(),
+  version: z6.string(),
+  author: z6.string().optional(),
+  homepage: z6.string().optional(),
+  origin: zPluginOrigin,
+  permissions: z6.array(zPluginPermission).default([]),
+  /** Форма настроек — интерфейс рисует её по этому описанию. */
+  settings: z6.array(zPluginSettingField).default([]),
+  sections: z6.array(zPluginSettingSection).default([]),
+  actions: z6.array(zPluginAction).default([]),
+  /**
+   * Текущие значения. Секреты сюда не попадают: вместо значения — `true`,
+   * если задано. Иначе токен уехал бы на каждое устройство в снапшоте.
+   */
+  settingValues: z6.record(z6.unknown()).default({}),
+  /** Хочет ли пользователь, чтобы плагин работал. */
+  enabled: z6.boolean(),
+  /** Работает ли он на самом деле. */
+  status: zPluginStatus,
+  /** Почему не работает. Текст для человека, не стектрейс. */
+  error: z6.string().optional(),
+  /** Что плагин принёс в ядро. Пусто, пока он не запустился. */
+  tools: z6.array(z6.object({ name: z6.string(), title: z6.string(), tier: zRiskTier })).default([]),
+  skills: z6.array(zSkillInfo).default([]),
+  mcpServers: z6.array(zMcpServerInfo).default([]),
+  providers: z6.array(z6.string()).default([]),
+  jobs: z6.array(z6.object({
+    name: z6.string(),
+    everySeconds: z6.number().int().positive(),
+    lastRunAt: zTimestamp.optional(),
+    lastError: z6.string().optional()
+  })).default([]),
+  installedAt: zTimestamp,
+  updatedAt: zTimestamp
+});
+var zCatalogEntry = z6.object({
+  id: zPluginId,
+  name: z6.string(),
+  description: z6.string(),
+  tags: z6.array(z6.string()).default([]),
+  homepage: z6.string().optional(),
+  permissions: z6.array(zPluginPermission).default([]),
+  /** Что спросить у человека до установки: токены, пути, ключи. */
+  setup: z6.array(zPluginSettingField).default([]),
+  install: z6.discriminatedUnion("type", [
+    z6.object({ type: z6.literal("git"), url: z6.string(), ref: z6.string().optional() }),
+    /**
+     * Плагин-обёртка вокруг MCP-сервера: ядро соберёт манифест само.
+     * `${setup.ключ}` в аргументах и окружении подставляется из ответов.
+     */
+    z6.object({ type: z6.literal("mcp"), transport: zMcpTransport })
+  ])
+});
+var zPluginSource = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.literal("catalog"),
+    id: zPluginId,
+    /** Ответы на `setup` из записи каталога. */
+    values: z6.record(z6.string()).default({})
+  }),
+  z6.object({
+    type: z6.literal("git"),
+    url: z6.string().min(1),
+    ref: z6.string().optional()
+  }),
+  /**
+   * Свой MCP-сервер, которого нет в каталоге.
+   *
+   * Главный способ поставить что-то в Axon, а не запасной: MCP-серверов
+   * существуют сотни, и каталог из шести проверенных — это закладки, а не
+   * граница возможного. Ядро соберёт вокруг конфигурации плагин-обёртку само.
+   */
+  z6.object({
+    type: z6.literal("mcp"),
+    name: zPluginId,
+    /** Как показать сервер в списке. Пусто — возьмём имя. */
+    title: z6.string().max(80).optional(),
+    transport: zMcpTransport
+  }),
+  /**
+   * Папка на машине ядра. Подключается по месту, а не копируется — это режим
+   * разработки: правишь файлы, перезапускаешь плагин, видишь результат.
+   */
+  z6.object({ type: z6.literal("link"), path: z6.string().min(1) }),
+  /**
+   * Архив, загруженный человеком. Едет блобом, как вложение к сообщению:
+   * гонять мегабайты через WebSocket, у которого своя очередь кадров, — верный
+   * способ подвесить всё остальное на время загрузки.
+   */
+  z6.object({ type: z6.literal("archive"), blobId: zId, name: z6.string().max(200).optional() })
+]);
+
+// ../protocol/dist/routines.js
+import { z as z7 } from "zod";
+var zTimeOfDay2 = z7.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "\u0412\u0440\u0435\u043C\u044F \u0437\u0430\u0434\u0430\u0451\u0442\u0441\u044F \u043A\u0430\u043A \u0427\u0427:\u041C\u041C, \u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440 09:30");
+var zSchedule = z7.discriminatedUnion("kind", [
+  /**
+   * Через равные промежутки. Минимум пять минут: всё, что чаще, — это уже не
+   * расписание, а фоновый цикл, и для него есть плагины.
+   */
+  z7.object({
+    kind: z7.literal("interval"),
+    everyMinutes: z7.number().int().min(5).max(60 * 24 * 30)
+  }),
+  z7.object({ kind: z7.literal("daily"), time: zTimeOfDay2 }),
+  z7.object({
+    kind: z7.literal("weekly"),
+    /** 0 — воскресенье, как в JS. */
+    days: z7.array(z7.number().int().min(0).max(6)).min(1),
+    time: zTimeOfDay2
+  }),
+  /** Разовое напоминание. После срабатывания рутина выключается сама. */
+  z7.object({ kind: z7.literal("once"), at: zTimestamp }),
+  /** Только вручную: кнопкой «Запустить сейчас». */
+  z7.object({ kind: z7.literal("manual") })
+]);
+var zCondition = z7.object({
+  /** Что проверяем: имя переменной или строка с подстановками `${…}`. */
+  left: z7.string().max(2e3),
+  op: z7.enum([
+    "equals",
+    "notEquals",
+    "contains",
+    "notContains",
+    "matches",
+    "empty",
+    "notEmpty",
+    "greaterThan",
+    "lessThan"
+  ]),
+  /** С чем сравниваем. Для `empty` и `notEmpty` не нужно. */
+  right: z7.string().max(2e3).optional()
+});
+var NAME = new RegExp("^\\p{L}[\\p{L}\\p{N}_]*$", "u");
+var zOutputVar = z7.string().regex(NAME, "\u0418\u043C\u044F \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u043E\u0439: \u0431\u0443\u043A\u0432\u0430, \u0434\u0430\u043B\u044C\u0448\u0435 \u0431\u0443\u043A\u0432\u044B, \u0446\u0438\u0444\u0440\u044B \u0438 \u043F\u043E\u0434\u0447\u0451\u0440\u043A\u0438\u0432\u0430\u043D\u0438\u0435").max(40).optional();
+var zRoutineStep = z7.lazy(() => z7.discriminatedUnion("kind", [
+  z7.object({
+    kind: z7.literal("tool"),
+    tool: z7.string().min(1).max(80),
+    args: z7.record(z7.unknown()).default({}),
+    outputVar: zOutputVar,
+    continueOnError: z7.boolean().optional()
+  }),
+  z7.object({
+    kind: z7.literal("prompt"),
+    prompt: z7.string().min(1).max(8e3),
+    outputVar: zOutputVar,
+    maxTokens: z7.number().int().positive().max(4e3).optional()
+  }),
+  z7.object({
+    kind: z7.literal("extract"),
+    from: z7.string().min(1).max(2e3),
+    fields: z7.array(z7.object({ name: z7.string().min(1).max(40), description: z7.string().max(300) })).min(1).max(12),
+    outputVar: zOutputVar
+  }),
+  z7.object({
+    kind: z7.literal("agent"),
+    task: z7.string().min(1).max(4e3),
+    allowTools: z7.array(z7.string()).optional(),
+    budgetTokens: z7.number().int().positive().optional(),
+    outputVar: zOutputVar
+  }),
+  z7.object({
+    kind: z7.literal("if"),
+    condition: zCondition,
+    then: z7.array(zRoutineStep).max(40),
+    otherwise: z7.array(zRoutineStep).max(40).optional()
+  }),
+  z7.object({
+    kind: z7.literal("foreach"),
+    source: z7.string().min(1).max(2e3),
+    steps: z7.array(zRoutineStep).max(40),
+    limit: z7.number().int().positive().max(500).optional()
+  }),
+  z7.object({
+    kind: z7.literal("set"),
+    name: z7.string().regex(NAME).max(40),
+    value: z7.string().max(8e3)
+  }),
+  z7.object({
+    kind: z7.literal("notify"),
+    title: z7.string().min(1).max(200),
+    body: z7.string().max(1e3).optional()
+  }),
+  z7.object({ kind: z7.literal("message"), text: z7.string().min(1).max(2e4) }),
+  z7.object({
+    kind: z7.literal("remember"),
+    key: z7.string().min(1).max(200),
+    value: z7.string().min(1).max(4e3)
+  }),
+  z7.object({ kind: z7.literal("wait"), seconds: z7.number().int().min(1).max(3600) }),
+  z7.object({ kind: z7.literal("stop"), reason: z7.string().max(500).optional() })
+]));
+var zRoutineStatus = z7.enum(["ok", "failed", "skipped", "running"]);
+var zRoutine = z7.object({
+  id: zId,
+  name: z7.string().min(1).max(120),
+  /** Что делает рутина — одной фразой, для списка. */
+  description: z7.string().max(500).default(""),
+  /**
+   * Исходное описание словами. Хранится, чтобы рутину можно было пересобрать
+   * после появления новых инструментов или правки текста.
+   */
+  source: z7.string().max(8e3).default(""),
+  steps: z7.array(zRoutineStep).max(60).default([]),
+  schedule: zSchedule,
+  enabled: z7.boolean(),
+  /**
+   * Разговор, в который пишутся шаги `message`. Заводится при первом прогоне и
+   * живёт дальше: результат рутины — обычная переписка, которую можно открыть,
+   * прочитать и продолжить руками.
+   */
+  conversationId: zId.optional(),
+  /**
+   * Потолок токенов на прогон. Обязателен: за фоновой задачей никто не
+   * смотрит, и перерасход обнаруживается по счёту, а не сразу.
+   */
+  budgetTokens: z7.number().int().positive(),
+  /**
+   * Инструменты сверх безопасных, разрешённые этой рутине. Рядом нет человека,
+   * который подтвердит опасное действие, и подтверждать его молча нельзя.
+   */
+  allowTools: z7.array(z7.string()).default([]),
+  notify: z7.boolean().default(true),
+  createdAt: zTimestamp,
+  updatedAt: zTimestamp,
+  nextRunAt: zTimestamp.optional(),
+  lastRunAt: zTimestamp.optional(),
+  lastStatus: zRoutineStatus.optional(),
+  lastSummary: z7.string().optional()
+});
+var zStepLog = z7.object({
+  /** Путь до шага: «2» — третий шаг, «2.1» — второй шаг внутри него. */
+  path: z7.string(),
+  kind: z7.string(),
+  ok: z7.boolean(),
+  /** Что шаг вернул, обрезанное до разумного. */
+  output: z7.string().optional(),
+  error: z7.string().optional(),
+  durationMs: z7.number().int().nonnegative(),
+  /** Сколько токенов стоил шаг. У большинства шагов — ноль. */
+  tokens: z7.number().int().nonnegative().default(0)
+});
+var zRoutineRun = z7.object({
+  id: z7.number().int().positive(),
+  routineId: zId,
+  startedAt: zTimestamp,
+  finishedAt: zTimestamp.optional(),
+  status: zRoutineStatus,
+  trigger: z7.enum(["schedule", "manual"]),
+  steps: z7.array(zStepLog).default([]),
+  summary: z7.string().default(""),
+  tokens: z7.number().int().nonnegative().default(0)
+});
+var zRoutineCompileReq = z7.object({
+  source: z7.string().min(1).max(8e3),
+  /** Инструменты, которые компилятору разрешено использовать в шагах. */
+  allowTools: z7.array(z7.string()).default([])
+});
+var zRoutineCompileRes = z7.object({
+  name: z7.string(),
+  description: z7.string(),
+  steps: z7.array(zRoutineStep),
+  schedule: zSchedule,
+  /** Замечания компилятора: чего он не смог, что заменил. */
+  warnings: z7.array(z7.string()).default([])
+});
+var zRoutineCreateReq = z7.object({
+  name: z7.string().min(1).max(120),
+  description: z7.string().max(500).default(""),
+  source: z7.string().max(8e3).default(""),
+  steps: z7.array(zRoutineStep).max(60),
+  schedule: zSchedule,
+  budgetTokens: z7.number().int().positive().default(2e4),
+  allowTools: z7.array(z7.string()).default([]),
+  notify: z7.boolean().default(true)
+});
+var zRoutineUpdateReq = z7.object({
+  id: zId,
+  name: z7.string().min(1).max(120).optional(),
+  description: z7.string().max(500).optional(),
+  source: z7.string().max(8e3).optional(),
+  steps: z7.array(zRoutineStep).max(60).optional(),
+  schedule: zSchedule.optional(),
+  enabled: z7.boolean().optional(),
+  budgetTokens: z7.number().int().positive().optional(),
+  allowTools: z7.array(z7.string()).optional(),
+  notify: z7.boolean().optional()
+});
+var zRoutineRunsReq = z7.object({
+  routineId: zId,
+  limit: z7.number().int().positive().max(50).default(10)
+});
+var zRoutineRunsRes = z7.object({ runs: z7.array(zRoutineRun) });
+
+// ../protocol/dist/events.js
+import { z as z8 } from "zod";
+var zJournalEvent = z8.discriminatedUnion("type", [
+  // ── Разговоры ──
+  z8.object({ type: z8.literal("conversation.created"), conversation: zConversation }),
+  z8.object({ type: z8.literal("conversation.renamed"), id: zId, title: z8.string() }),
+  z8.object({ type: z8.literal("conversation.archived"), id: zId, archived: z8.boolean() }),
+  z8.object({ type: z8.literal("conversation.deleted"), id: zId }),
+  // ── Сообщения ──
+  z8.object({ type: z8.literal("message.created"), message: zMessage }),
+  /**
+   * Сообщение изменено задним числом: правка пользователя или подстановка
+   * итогового текста после стрима. Клиент заменяет содержимое целиком.
+   */
+  z8.object({ type: z8.literal("message.amended"), message: zMessage }),
+  z8.object({ type: z8.literal("message.deleted"), id: zId, conversationId: zId }),
+  // ── Прогоны агента ──
+  z8.object({
+    type: z8.literal("run.started"),
+    runId: zId,
+    conversationId: zId,
+    /** Сколько токенов прогону разрешено сжечь. null — без потолка. */
+    budgetTokens: z8.number().int().positive().nullable()
+  }),
+  z8.object({
+    type: z8.literal("run.finished"),
+    runId: zId,
+    conversationId: zId,
+    stopReason: zStopReason,
+    /** Суммарный расход за весь прогон, включая все итерации с инструментами. */
+    usage: zUsage.optional(),
+    iterations: z8.number().int().nonnegative()
+  }),
+  z8.object({
+    type: z8.literal("run.failed"),
+    runId: zId,
+    conversationId: zId,
+    error: z8.string()
+  }),
+  // ── Инструменты ──
+  z8.object({
+    type: z8.literal("tool_call.started"),
+    runId: zId,
+    conversationId: zId,
+    call: zToolCall
+  }),
+  z8.object({
+    type: z8.literal("tool_call.finished"),
+    runId: zId,
+    conversationId: zId,
+    callId: zExternalId,
+    result: zToolResult
+  }),
+  // ── Разрешения ──
+  z8.object({ type: z8.literal("permission.requested"), request: zPermissionRequest }),
+  z8.object({
+    type: z8.literal("permission.resolved"),
+    requestId: zId,
+    decision: zPermissionDecision,
+    /** Какое устройство ответило. Пусто, если решение принято по правилу или по таймауту. */
+    deviceId: zId.optional()
+  }),
+  // ── Память ──
+  z8.object({ type: z8.literal("fact.upserted"), fact: zFact }),
+  z8.object({ type: z8.literal("fact.forgotten"), id: zId }),
+  z8.object({ type: z8.literal("observation.noticed"), observation: zObservation }),
+  z8.object({ type: z8.literal("observation.forgotten"), id: zId }),
+  // ── Инициатива ──
+  /**
+   * Агент написал первым.
+   *
+   * Отдельное событие, а не просто сообщение в разговоре: клиент должен
+   * показать уведомление, а по `message.created` отличить собственный порыв
+   * агента от обычного ответа невозможно — роль там одна и та же.
+   */
+  z8.object({
+    type: z8.literal("impulse.sent"),
+    conversationId: zId,
+    messageId: zId,
+    /** Чем агент объяснил себе, зачем пишет. Видно человеку в интерфейсе. */
+    reason: z8.string()
+  }),
+  // ── Инструменты ──
+  /**
+   * Инструмент включили, выключили или переопределили. Без этого события
+   * клиент не узнаёт о смене состояния и показывает старое: переключатель
+   * выглядит нажатым вхолостую.
+   */
+  z8.object({ type: z8.literal("tool.changed"), tool: zToolInfo }),
+  // ── Плагины ──
+  /**
+   * Плагин поставлен, настроен, включён или выключен — то есть изменилось
+   * решение пользователя. Смена рабочего состояния (запускается, упал,
+   * поднялся) сюда не пишется: это сигнал. Иначе журнал получал бы по паре
+   * записей на плагин при каждом старте ядра — навсегда.
+   */
+  z8.object({ type: z8.literal("plugin.changed"), plugin: zPluginInfo }),
+  z8.object({ type: z8.literal("plugin.removed"), id: z8.string() }),
+  // ── Рутины ──
+  /**
+   * Рутина заведена, изменена или отработала. Исход прогона тоже сюда: это
+   * состояние, которое должно пережить перезапуск и доехать до всех устройств,
+   * а не мигнуть уведомлением у того, кто в этот момент смотрел в экран.
+   */
+  z8.object({ type: z8.literal("routine.changed"), routine: zRoutine }),
+  z8.object({ type: z8.literal("routine.removed"), id: zId }),
+  /**
+   * Рутина просит показать уведомление. В журнале, а не сигналом: у ядра нет
+   * экрана, а показать должен тот клиент, который сейчас на связи — и увидеть
+   * пропущенное при следующем подключении тоже нужно.
+   */
+  z8.object({
+    type: z8.literal("routine.notified"),
+    routineId: zId,
+    title: z8.string(),
+    body: z8.string().optional()
+  }),
+  // ── Устройства ──
+  z8.object({ type: z8.literal("device.paired"), device: zDevice }),
+  z8.object({ type: z8.literal("device.revoked"), id: zId }),
+  // ── Настройки ──
+  /**
+   * Значения не передаются: среди настроек лежат API-ключи, и им нечего делать
+   * в журнале, который синкается на все устройства. Клиент, увидев событие,
+   * перезапрашивает то, к чему у него есть доступ.
+   */
+  z8.object({ type: z8.literal("settings.changed"), keys: z8.array(z8.string()) })
+]);
+var zJournalEntry = z8.object({
+  seq: zSeq,
+  at: zTimestamp,
+  event: zJournalEvent
+});
+
+// ../protocol/dist/signals.js
+import { z as z9 } from "zod";
+var zSignal = z9.discriminatedUnion("type", [
+  /** Кусок текста от модели. Клиент дорисовывает его в открытый пузырь. */
+  z9.object({
+    type: z9.literal("run.delta"),
+    runId: zId,
+    text: z9.string()
+  }),
+  /** Что агент делает прямо сейчас — для честного индикатора вместо вечного «печатает…». */
+  z9.object({
+    type: z9.literal("run.phase"),
+    runId: zId,
+    /**
+     * `retrying` — ждём и пробуем снова после отказа провайдера. Без этой фазы
+     * пауза в восемь секунд выглядит как зависание, и человек жмёт «стоп»
+     * ровно тогда, когда ядро само бы справилось.
+     */
+    phase: z9.enum([
+      "thinking",
+      "calling_tool",
+      "awaiting_permission",
+      "summarizing",
+      "retrying"
+    ]),
+    /** Имя инструмента для фазы calling_tool. */
+    detail: z9.string().optional()
+  }),
+  /**
+   * Расход в реальном времени, пока прогон идёт. Пользователь видит счётчик,
+   * а не узнаёт постфактум, что запрос стоил денег.
+   */
+  z9.object({
+    type: z9.literal("usage.tick"),
+    runId: zId,
+    usage: zUsage,
+    /** Остаток бюджета прогона в токенах. null — потолка нет. */
+    budgetRemaining: z9.number().int().nullable()
+  }),
+  /** Какие ещё устройства сейчас на связи с ядром. */
+  z9.object({
+    type: z9.literal("presence"),
+    deviceIds: z9.array(zId)
+  }),
+  /**
+   * Плагин сменил рабочее состояние: поднимается, поднялся, упал, отдал свои
+   * инструменты. Пропажа такого сигнала не ломает состояние — при следующем
+   * подключении клиент получит актуальную картину снапшотом.
+   */
+  /**
+   * Набор инструментов изменился: поднялся плагин, упал, сняли или поставили.
+   *
+   * Сигналом, а не журнальным событием, потому что состав инструментов —
+   * величина производная: он собирается заново при каждом запуске ядра из
+   * того, какие плагины поднялись. Журналировать это значило бы писать
+   * одинаковую пачку записей на каждый перезапуск.
+   *
+   * Клиент заменяет свой список целиком: досылать разницу здесь не из чего —
+   * инструменты не нумеруются и не досылаются, как сообщения.
+   */
+  z9.object({
+    type: z9.literal("tools.changed"),
+    tools: z9.array(zToolInfo)
+  }),
+  z9.object({
+    type: z9.literal("plugin.status"),
+    plugin: zPluginInfo
+  })
+]);
+
+// ../protocol/dist/settings.js
+import { z as z10 } from "zod";
+var zSecretStatus = z10.object({
+  key: z10.string(),
+  set: z10.boolean(),
+  /** Последние символы значения. Присутствует, только если секрет задан. */
+  hint: z10.string().max(8).optional(),
+  updatedAt: zTimestamp.optional()
+});
+var zSettingsGetReq = z10.object({
+  /** Какие ключи вернуть. Пусто — все, к которым у устройства есть доступ. */
+  keys: z10.array(z10.string()).optional()
+});
+var zSettingsGetRes = z10.object({
+  values: z10.record(z10.unknown()),
+  secrets: z10.array(zSecretStatus)
+});
+var zSettingsSetReq = z10.object({
+  values: z10.record(z10.unknown()).optional(),
+  /**
+   * Секреты пишутся только в одну сторону. `null` — стереть.
+   * Прочитать записанное через протокол нельзя в принципе.
+   */
+  secrets: z10.record(z10.string().nullable()).optional()
+});
+
+// ../protocol/dist/commands.js
+import { z as z11 } from "zod";
+var zSyncPullReq = z11.object({
+  /** Последний seq, который клиент уже применил. 0 — холодный старт. */
+  since: zCursor,
+  limit: z11.number().int().positive().max(1e3).default(200)
+});
+var zSyncPullRes = z11.object({
+  entries: z11.array(zJournalEntry),
+  /** Курсор после применения выданной пачки. */
+  cursor: zSeq,
+  /** Есть ли ещё — тянуть до false, потом слушать `evt`. */
+  hasMore: z11.boolean()
+});
+var zSyncSnapshotReq = z11.object({
+  /** Сколько последних разговоров положить в снапшот. */
+  conversationLimit: z11.number().int().positive().max(200).default(50)
+});
+var zSyncSnapshotRes = z11.object({
+  conversations: z11.array(zConversation),
+  facts: z11.array(zFact),
+  observations: z11.array(zObservation),
+  devices: z11.array(zDevice),
+  tools: z11.array(zToolInfo),
+  /** Вместе с рабочим состоянием: журнал его не хранит, а знать его нужно сразу. */
+  plugins: z11.array(zPluginInfo),
+  routines: z11.array(zRoutine),
+  cursor: zSeq
+});
+var zConversationCreateReq = z11.object({
+  title: z11.string().max(200).optional()
+});
+var zConversationCreateRes = z11.object({ conversation: zConversation });
+var zConversationRenameReq = z11.object({ id: zId, title: z11.string().max(200) });
+var zConversationArchiveReq = z11.object({ id: zId, archived: z11.boolean() });
+var zConversationDeleteReq = z11.object({ id: zId });
+var zOkRes = z11.object({ ok: z11.literal(true) });
+var zMessageHistoryReq = z11.object({
+  conversationId: zId,
+  /** Грузить сообщения старше этого id. Пусто — с конца. */
+  before: zId.optional(),
+  limit: z11.number().int().positive().max(200).default(50)
+});
+var zMessageHistoryRes = z11.object({
+  messages: z11.array(zMessage),
+  hasMore: z11.boolean()
+});
+var zSearchReq = z11.object({
+  query: z11.string().min(1).max(200),
+  limit: z11.number().int().positive().max(100).default(40)
+});
+var zSearchRes = z11.object({
+  hits: z11.array(z11.object({
+    conversationId: zId,
+    conversationTitle: z11.string(),
+    messageId: zId,
+    role: z11.string(),
+    createdAt: zTimestamp,
+    /** Найденные слова обёрнуты в «ёлочки» — клиент подсвечивает по ним. */
+    snippet: z11.string()
+  }))
+});
+var zMessageSendReq = z11.object({
+  conversationId: zId,
+  parts: z11.array(zContentPart).min(1),
+  /** Потолок расхода на этот прогон. Пусто — берётся из настроек ядра. */
+  budgetTokens: z11.number().int().positive().optional(),
+  /** Разрешённые инструменты сверх дефолтных прав устройства. */
+  allowTools: z11.array(z11.string()).optional()
+});
+var zMessageSendRes = z11.object({
+  runId: zId,
+  /** Сообщение пользователя, уже записанное в журнал. */
+  message: zMessage
+});
+var zMessageEditReq = z11.object({
+  id: zId,
+  parts: z11.array(zContentPart).min(1)
+});
+var zMessageRegenerateReq = z11.object({ conversationId: zId });
+var zRunCancelReq = z11.object({ runId: zId });
+var zPermissionResolveReq = z11.object({
+  requestId: zId,
+  decision: zPermissionDecision.exclude(["expired"])
+});
+var zToolListRes = z11.object({ tools: z11.array(zToolInfo) });
+var zToolSetEnabledReq = z11.object({ name: z11.string(), enabled: z11.boolean() });
+var zRoutineListRes = z11.object({ routines: z11.array(zRoutine) });
+var zRoutineRes = z11.object({ routine: zRoutine });
+var zProviderListRes = z11.object({ providers: z11.array(zProviderInfo) });
+var zPluginListRes = z11.object({ plugins: z11.array(zPluginInfo) });
+var zPluginCatalogReq = z11.object({
+  /** Человек нажал «обновить» — идти в сеть, не глядя на свежесть кэша. */
+  refresh: z11.boolean().default(false)
+});
+var zPluginCatalogRes = z11.object({
+  entries: z11.array(zCatalogEntry),
+  /**
+   * Откуда взялся этот список.
+   *
+   * Показывается человеку: каталог из сборки полугодовой давности и свежий
+   * выглядят одинаково, и без пометки непонятно, почему в нём нет того, что
+   * ему обещали.
+   */
+  origin: z11.enum(["network", "cache", "bundled"]),
+  fetchedAt: zTimestamp.optional()
+});
+var zPluginInstallReq = z11.object({ source: zPluginSource });
+var zPluginInstallRes = z11.object({ plugin: zPluginInfo });
+var zPluginIdReq = z11.object({ id: zPluginId });
+var zPluginSetEnabledReq = z11.object({ id: zPluginId, enabled: z11.boolean() });
+var zPluginConfigureReq = z11.object({
+  id: zPluginId,
+  values: z11.record(z11.unknown()).default({}),
+  secrets: z11.record(z11.string().nullable()).default({})
+});
+var zSkillSetEnabledReq = z11.object({ id: z11.string(), enabled: z11.boolean() });
+var zPluginLogsReq = z11.object({
+  id: zPluginId,
+  limit: z11.number().int().positive().max(500).default(200)
+});
+var zPluginLogsRes = z11.object({
+  lines: z11.array(z11.object({ at: z11.string(), level: z11.string(), text: z11.string() }))
+});
+var zDeviceListRes = z11.object({ devices: z11.array(zDevice) });
+var zDeviceRevokeReq = z11.object({ id: zId });
+var zPairBeginReq = z11.object({
+  name: z11.string().max(100),
+  platform: zDevicePlatform,
+  scopes: z11.array(zScope),
+  ttlSeconds: z11.number().int().positive().max(3600).default(300)
+});
+var zPairBeginRes = z11.object({
+  code: z11.string(),
+  expiresInSeconds: z11.number().int().positive()
+});
+var zFactUpsertReq = z11.object({ key: z11.string().max(200), value: z11.string().max(4e3) });
+var zFactUpsertRes = z11.object({ fact: zFact });
+var zFactForgetReq = z11.object({ id: zId });
+var zObservationForgetReq = z11.object({ id: zId });
+var zPluginActionReq = z11.object({
+  id: zPluginId,
+  action: z11.string().min(1).max(60)
+});
+var zPluginActionRes = z11.object({
+  ok: z11.boolean(),
+  message: z11.string().max(2e3)
+});
+var zTelegramLoginReq = z11.object({
+  step: z11.enum(["phone", "code", "password", "cancel"]),
+  value: z11.string().max(200).default("")
+});
+var zTelegramLoginRes = z11.object({
+  state: z11.enum(["code_sent", "password_needed", "done", "cancelled"]),
+  /** Куда пришёл код — в телеграм или сообщением. Только для подсказки. */
+  hint: z11.string().optional(),
+  /** Как зовут вошедший аккаунт. Появляется на последнем шаге. */
+  name: z11.string().optional()
+});
+var zTelegramStatusRes = z11.object({
+  /** Поднят ли бот: у него есть токен и он на связи. */
+  bot: z11.boolean(),
+  /** Работает ли юзербот и под каким именем. */
+  user: z11.boolean(),
+  userName: z11.string().optional()
+});
+var zUsageSummaryReq = z11.object({
+  /** Начало окна, ISO-8601. Пусто — с начала суток по времени ядра. */
+  since: z11.string().datetime().optional()
+});
+var zUsageSummaryRes = z11.object({
+  inputTokens: z11.number().int().nonnegative(),
+  cachedInputTokens: z11.number().int().nonnegative(),
+  outputTokens: z11.number().int().nonnegative(),
+  costUsd: z11.number().nonnegative(),
+  runs: z11.number().int().nonnegative(),
+  /** Разбивка по моделям — видно, куда именно утекает бюджет. */
+  byModel: z11.array(z11.object({
+    provider: z11.string(),
+    model: z11.string(),
+    inputTokens: z11.number().int().nonnegative(),
+    cachedInputTokens: z11.number().int().nonnegative(),
+    outputTokens: z11.number().int().nonnegative(),
+    costUsd: z11.number().nonnegative()
+  }))
+});
+var commands = {
+  "sync.pull": { req: zSyncPullReq, res: zSyncPullRes },
+  "sync.snapshot": { req: zSyncSnapshotReq, res: zSyncSnapshotRes },
+  "conversation.create": { req: zConversationCreateReq, res: zConversationCreateRes },
+  "conversation.rename": { req: zConversationRenameReq, res: zOkRes },
+  "conversation.archive": { req: zConversationArchiveReq, res: zOkRes },
+  "conversation.delete": { req: zConversationDeleteReq, res: zOkRes },
+  "message.history": { req: zMessageHistoryReq, res: zMessageHistoryRes },
+  "message.search": { req: zSearchReq, res: zSearchRes },
+  "context.report": { req: z11.object({ conversationId: zId }), res: zContextReport },
+  "message.send": { req: zMessageSendReq, res: zMessageSendRes },
+  "message.edit": { req: zMessageEditReq, res: zMessageSendRes },
+  "message.regenerate": { req: zMessageRegenerateReq, res: zMessageSendRes },
+  "run.cancel": { req: zRunCancelReq, res: zOkRes },
+  "permission.resolve": { req: zPermissionResolveReq, res: zOkRes },
+  "tool.list": { req: z11.object({}), res: zToolListRes },
+  "tool.setEnabled": { req: zToolSetEnabledReq, res: zOkRes },
+  "provider.list": { req: z11.object({}), res: zProviderListRes },
+  "routine.list": { req: z11.object({}), res: zRoutineListRes },
+  "routine.compile": { req: zRoutineCompileReq, res: zRoutineCompileRes },
+  "routine.create": { req: zRoutineCreateReq, res: zRoutineRes },
+  "routine.update": { req: zRoutineUpdateReq, res: zRoutineRes },
+  "routine.delete": { req: z11.object({ id: zId }), res: zOkRes },
+  "routine.runNow": { req: z11.object({ id: zId }), res: zRoutineRes },
+  "routine.runs": { req: zRoutineRunsReq, res: zRoutineRunsRes },
+  "plugin.list": { req: z11.object({}), res: zPluginListRes },
+  "plugin.catalog": { req: zPluginCatalogReq, res: zPluginCatalogRes },
+  "plugin.install": { req: zPluginInstallReq, res: zPluginInstallRes },
+  "plugin.remove": { req: zPluginIdReq, res: zOkRes },
+  "plugin.setEnabled": { req: zPluginSetEnabledReq, res: zOkRes },
+  "plugin.reload": { req: zPluginIdReq, res: zOkRes },
+  "plugin.update": { req: zPluginIdReq, res: zPluginInstallRes },
+  "plugin.configure": { req: zPluginConfigureReq, res: zOkRes },
+  "plugin.action": { req: zPluginActionReq, res: zPluginActionRes },
+  "plugin.logs": { req: zPluginLogsReq, res: zPluginLogsRes },
+  "skill.setEnabled": { req: zSkillSetEnabledReq, res: zOkRes },
+  "settings.get": { req: zSettingsGetReq, res: zSettingsGetRes },
+  "settings.set": { req: zSettingsSetReq, res: zOkRes },
+  "device.list": { req: z11.object({}), res: zDeviceListRes },
+  "device.revoke": { req: zDeviceRevokeReq, res: zOkRes },
+  "device.pairBegin": { req: zPairBeginReq, res: zPairBeginRes },
+  "fact.upsert": { req: zFactUpsertReq, res: zFactUpsertRes },
+  "fact.forget": { req: zFactForgetReq, res: zOkRes },
+  "observation.forget": { req: zObservationForgetReq, res: zOkRes },
+  "telegram.login": { req: zTelegramLoginReq, res: zTelegramLoginRes },
+  "telegram.logout": { req: z11.object({}), res: zOkRes },
+  "telegram.status": { req: z11.object({}), res: zTelegramStatusRes },
+  "usage.summary": { req: zUsageSummaryReq, res: zUsageSummaryRes }
+};
+var commandNames = Object.keys(commands);
+
+// ../protocol/dist/envelope.js
+import { z as z12 } from "zod";
+var zClientFrame = z12.discriminatedUnion("t", [
+  /** Вызов команды. `id` возвращается в ответном кадре. */
+  z12.object({
+    t: z12.literal("req"),
+    id: zId,
+    cmd: z12.string(),
+    payload: z12.unknown()
+  }),
+  /**
+   * Подтверждение позиции в журнале. Ядро запоминает курсор устройства, чтобы
+   * при следующем подключении сразу знать, с чего досылать.
+   */
+  z12.object({
+    t: z12.literal("ack"),
+    cursor: zCursor
+  }),
+  z12.object({ t: z12.literal("ping") })
+]);
+var zCoreInfo = z12.object({
+  /** Постоянный id этой установки ядра. Клиент по нему отличает «переехал на другое ядро». */
+  coreId: zId,
+  version: z12.string(),
+  /** Как ядро запущено: встроено в десктоп или отдельным сервисом. */
+  mode: z12.enum(["embedded", "standalone"]),
+  /** Права выданного устройству токена — клиент прячет то, что всё равно не разрешат. */
+  scopes: z12.array(zScope)
+});
+var zServerFrame = z12.discriminatedUnion("t", [
+  /** Первый кадр после подключения. До него клиент не шлёт ничего, кроме ping. */
+  z12.object({
+    t: z12.literal("hello"),
+    protocol: z12.number().int(),
+    /**
+     * Ревизия контракта у ядра. `default` здесь обязателен: ядра, выпущенные
+     * до её появления, этого поля не шлют, и без умолчания разбор кадра упал
+     * бы ровно на тех, ради кого она и заводится.
+     */
+    revision: z12.number().int().default(0),
+    core: zCoreInfo,
+    /** Текущая вершина журнала — сразу видно, насколько клиент отстал. */
+    head: zSeq
+  }),
+  z12.object({
+    t: z12.literal("res"),
+    id: zId,
+    payload: z12.unknown()
+  }),
+  z12.object({
+    t: z12.literal("err"),
+    id: zId,
+    error: zProtocolError
+  }),
+  /** Новая запись журнала. Клиент применяет её и двигает курсор. */
+  z12.object({
+    t: z12.literal("evt"),
+    seq: zSeq,
+    at: zTimestamp,
+    event: zJournalEvent
+  }),
+  /** Эфемерика: поток токенов, фазы, счётчик расхода. Потеря не страшна. */
+  z12.object({
+    t: z12.literal("sig"),
+    signal: zSignal
+  }),
+  z12.object({ t: z12.literal("pong") })
+]);
+
+// ../core/dist/agent/Orchestrator.js
+var PERMISSION_TTL_MS = 5 * 60 * 1e3;
+
+// ../core/dist/agent/Impulse.js
+var TICK_MS = 5 * 6e4;
+
+// ../core/dist/memory/vectors.js
+var MISSING = Number.POSITIVE_INFINITY;
+
+// ../core/dist/plugins/CatalogSource.js
+var FRESH_FOR_MS = 6 * 60 * 60 * 1e3;
+var MAX_BYTES = 2 * 1024 * 1024;
+
+// ../core/dist/plugins/install.js
+import { execFile } from "node:child_process";
+
+// ../core/dist/plugins/archive.js
+var MAX_TOTAL_BYTES = 200 * 1024 * 1024;
+var MAX_FILE_BYTES = 50 * 1024 * 1024;
+
+// ../core/dist/plugins/install.js
+import { promisify } from "node:util";
+
+// ../core/dist/plugins/host.js
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+// ../core/dist/plugins/contract.js
+var TO_PLUGIN = {
+  activate: "activate",
+  deactivate: "deactivate",
+  toolExecute: "tool.execute",
+  contribute: "context.contribute",
+  providerChat: "provider.chat",
+  jobRun: "job.run",
+  actionRun: "action.run",
+  /** События: ответа нет. */
+  settingsChanged: "settings.changed",
+  journalEvent: "journal.event"
+};
+var TO_CORE = {
+  registerTool: "tool.register",
+  unregisterTool: "tool.unregister",
+  registerContributor: "context.register",
+  unregisterContributor: "context.unregister",
+  registerProvider: "provider.register",
+  unregisterProvider: "provider.unregister",
+  addSkill: "skill.add",
+  requestPermission: "permission.request",
+  getSettings: "settings.get",
+  setSettings: "settings.set",
+  listFacts: "fact.list",
+  upsertFact: "fact.upsert",
+  writeBlob: "blob.write",
+  ask: "model.ask",
+  notify: "notify",
+  setStatus: "status.set",
+  searchHistory: "history.search",
+  log: "log"
+};
+var HOST_READY = "host.ready";
+
+// ../core/dist/plugins/rpc.js
+var RpcError = class extends Error {
+  code;
+  constructor(message, code = "plugin_error") {
+    super(message);
+    this.code = code;
+    this.name = "RpcError";
+  }
+};
+var RpcPeer = class {
+  send;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  events = /* @__PURE__ */ new Map();
+  /** Запросы, которые сейчас выполняем мы — по ним может прийти `cancel`. */
+  inflight = /* @__PURE__ */ new Map();
+  closed = null;
+  constructor(send) {
+    this.send = send;
+  }
+  // ─── Приём ────────────────────────────────────────────────────────────────
+  handle(method, handler) {
+    this.handlers.set(method, handler);
+  }
+  onEvent(method, handler) {
+    this.events.set(method, handler);
+  }
+  /** Скормить входящий кадр. Вызывается транспортом. */
+  receive(frame) {
+    switch (frame.t) {
+      case "req":
+        void this.dispatch(frame);
+        return;
+      case "res": {
+        const pending = this.pending.get(frame.id);
+        if (!pending)
+          return;
+        this.pending.delete(frame.id);
+        pending.detach();
+        if (pending.timer)
+          clearTimeout(pending.timer);
+        if (frame.ok)
+          pending.resolve(frame.result);
+        else
+          pending.reject(new RpcError(frame.error.message, frame.error.code));
+        return;
+      }
+      case "chunk":
+        this.pending.get(frame.id)?.onChunk?.(frame.value);
+        return;
+      case "evt": {
+        const handler = this.events.get(frame.method);
+        if (handler)
+          handler(frame.params);
+        return;
+      }
+      case "cancel":
+        this.inflight.get(frame.id)?.abort();
+        return;
+    }
+  }
+  async dispatch(frame) {
+    const handler = this.handlers.get(frame.method);
+    if (!handler) {
+      this.send({
+        t: "res",
+        id: frame.id,
+        ok: false,
+        error: { message: `\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u043C\u0435\u0442\u043E\u0434 ${frame.method}`, code: "unknown_method" }
+      });
+      return;
+    }
+    const controller = new AbortController();
+    this.inflight.set(frame.id, controller);
+    try {
+      const result = await handler(frame.params, {
+        signal: controller.signal,
+        push: (value) => this.send({ t: "chunk", id: frame.id, value })
+      });
+      this.send({ t: "res", id: frame.id, ok: true, result: result ?? null });
+    } catch (error) {
+      this.send({
+        t: "res",
+        id: frame.id,
+        ok: false,
+        error: {
+          message: error instanceof Error ? error.message : String(error),
+          ...error instanceof RpcError ? { code: error.code } : {}
+        }
+      });
+    } finally {
+      this.inflight.delete(frame.id);
+    }
+  }
+  // ─── Отправка ─────────────────────────────────────────────────────────────
+  call(method, params = {}, options = {}) {
+    if (this.closed)
+      return Promise.reject(this.closed);
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const abort = () => {
+        if (!this.pending.delete(id))
+          return;
+        this.send({ t: "cancel", id });
+        reject(new RpcError("\u0412\u044B\u0437\u043E\u0432 \u043E\u0442\u043C\u0435\u043D\u0451\u043D", "cancelled"));
+      };
+      options.signal?.addEventListener("abort", abort, { once: true });
+      const pending = {
+        resolve,
+        reject,
+        detach: () => options.signal?.removeEventListener("abort", abort),
+        ...options.onChunk ? { onChunk: options.onChunk } : {}
+      };
+      if (options.timeoutMs && options.timeoutMs > 0) {
+        pending.timer = setTimeout(() => {
+          if (!this.pending.delete(id))
+            return;
+          pending.detach();
+          reject(new RpcError(`\u041E\u0442\u0432\u0435\u0442 \u043D\u0435 \u043F\u0440\u0438\u0448\u0451\u043B \u0437\u0430 ${options.timeoutMs} \u043C\u0441`, "timeout"));
+        }, options.timeoutMs);
+        pending.timer.unref?.();
+      }
+      this.pending.set(id, pending);
+      try {
+        this.send({ t: "req", id, method, params });
+      } catch (error) {
+        this.pending.delete(id);
+        pending.detach();
+        if (pending.timer)
+          clearTimeout(pending.timer);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  emit(method, params = {}) {
+    if (this.closed)
+      return;
+    this.send({ t: "evt", method, params });
+  }
+  /**
+   * Закрыть пира: все незавершённые вызовы падают, новые сразу отклоняются.
+   *
+   * Без этого падение процесса плагина оставляло бы висеть промисы навсегда, и
+   * прогон агента замирал бы молча — худший из возможных способов сломаться.
+   */
+  dispose(reason) {
+    this.closed = reason;
+    for (const [id, pending] of this.pending) {
+      this.pending.delete(id);
+      pending.detach();
+      if (pending.timer)
+        clearTimeout(pending.timer);
+      pending.reject(reason);
+    }
+    for (const controller of this.inflight.values())
+      controller.abort();
+    this.inflight.clear();
+  }
+};
+
+// ../core/dist/plugins/host.js
+var PLUGIN_API_VERSION = 1;
+function startPluginHost() {
+  if (typeof process.send !== "function") {
+    throw new Error("\u0425\u043E\u0441\u0442 \u043F\u043B\u0430\u0433\u0438\u043D\u0430 \u0437\u0430\u043F\u0443\u0449\u0435\u043D \u0431\u0435\u0437 \u043A\u0430\u043D\u0430\u043B\u0430 \u043A \u044F\u0434\u0440\u0443 \u2014 \u0442\u0430\u043A \u043E\u043D \u0431\u0435\u0441\u043F\u043E\u043B\u0435\u0437\u0435\u043D");
+  }
+  const send = process.send.bind(process);
+  const peer = new RpcPeer((frame) => send(frame));
+  process.on("message", (frame) => peer.receive(frame));
+  const tools = /* @__PURE__ */ new Map();
+  const contributors = /* @__PURE__ */ new Map();
+  const providers = /* @__PURE__ */ new Map();
+  const jobs = /* @__PURE__ */ new Map();
+  const actions = /* @__PURE__ */ new Map();
+  const journalListeners = [];
+  const settingsListeners = [];
+  let settings = {};
+  let loaded = null;
+  function buildApi(params) {
+    const log = (level) => (message, data) => peer.emit(TO_CORE.log, { level, message, ...data ? { data } : {} });
+    return {
+      id: params.pluginId,
+      dir: params.dir,
+      dataDir: params.dataDir,
+      log: { debug: log("debug"), info: log("info"), warn: log("warn"), error: log("error") },
+      settings: {
+        all: () => ({ ...settings }),
+        get: (key) => settings[key],
+        set: async (values) => {
+          settings = { ...settings, ...values };
+          await peer.call(TO_CORE.setSettings, { values });
+        },
+        onChange: (listener) => settingsListeners.push(listener),
+        /**
+         * Разбор с умолчанием.
+         *
+         * Живёт здесь, а не у автора плагина: `Number(значение ?? 30)` на
+         * пустой строке даёт ноль, а не тридцать, и галочка из формы приходит
+         * строкой `"false"`, которая истинна. Каждый плагин переписывал бы это
+         * заново и ошибался бы одинаково.
+         */
+        text: (key, fallback) => {
+          const value = settings[key];
+          if (value === void 0 || value === null)
+            return fallback;
+          const text = String(value).trim();
+          return text || fallback;
+        },
+        number: (key, fallback) => {
+          const value = Number(settings[key]);
+          return Number.isFinite(value) ? value : fallback;
+        },
+        flag: (key, fallback) => {
+          const value = settings[key];
+          if (value === void 0 || value === null || value === "")
+            return fallback;
+          if (typeof value === "string")
+            return value !== "false" && value !== "0";
+          return Boolean(value);
+        },
+        lines: (key) => String(settings[key] ?? "").split("\n").map((line) => line.trim()).filter(Boolean)
+      },
+      tools: {
+        register: async (tool) => {
+          tools.set(tool.name, tool);
+          await peer.call(TO_CORE.registerTool, {
+            name: tool.name,
+            title: tool.title,
+            description: tool.description,
+            tier: tool.tier,
+            parameters: tool.parameters,
+            ...tool.deferred ? { deferred: true } : {},
+            ...tool.previewLimit ? { previewLimit: tool.previewLimit } : {}
+          });
+        },
+        unregister: async (name) => {
+          tools.delete(name);
+          await peer.call(TO_CORE.unregisterTool, { name });
+        }
+      },
+      context: {
+        contribute: async (name, stability, contribute) => {
+          contributors.set(name, contribute);
+          await peer.call(TO_CORE.registerContributor, { name, stability });
+        },
+        remove: async (name) => {
+          contributors.delete(name);
+          await peer.call(TO_CORE.unregisterContributor, { name });
+        }
+      },
+      providers: {
+        register: async (provider) => {
+          providers.set(provider.id, provider);
+          await peer.call(TO_CORE.registerProvider, {
+            id: provider.id,
+            label: provider.label,
+            supportsPromptCache: provider.supportsPromptCache,
+            models: provider.models
+          });
+        },
+        unregister: async (id) => {
+          providers.delete(id);
+          await peer.call(TO_CORE.unregisterProvider, { id });
+        }
+      },
+      skills: {
+        add: async (skill) => {
+          await peer.call(TO_CORE.addSkill, skill);
+        }
+      },
+      jobs: {
+        on: (name, run2) => jobs.set(name, run2)
+      },
+      actions: {
+        on: (name, run2) => actions.set(name, run2)
+      },
+      journal: {
+        on: (listener) => journalListeners.push(listener)
+      },
+      memory: {
+        facts: () => peer.call(TO_CORE.listFacts),
+        remember: async (key, value) => {
+          await peer.call(TO_CORE.upsertFact, { key, value });
+        }
+      },
+      blobs: {
+        write: async ({ data, mime, name }) => {
+          const buffer = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+          return peer.call(TO_CORE.writeBlob, {
+            base64: buffer.toString("base64"),
+            mime,
+            ...name ? { name } : {}
+          });
+        }
+      },
+      model: {
+        ask: (input) => peer.call(TO_CORE.ask, input)
+      },
+      notify: async (title, body) => {
+        await peer.call(TO_CORE.notify, { title, ...body ? { body } : {} });
+      },
+      status: {
+        set: async (note, failed) => {
+          await peer.call(TO_CORE.setStatus, { note, ...failed ? { failed } : {} });
+        },
+        clear: async () => {
+          await peer.call(TO_CORE.setStatus, {});
+        }
+      },
+      history: {
+        search: (query, limit) => peer.call(TO_CORE.searchHistory, {
+          query,
+          ...limit ? { limit } : {}
+        })
+      }
+    };
+  }
+  peer.handle(TO_PLUGIN.activate, async (params) => {
+    settings = params.settings ?? {};
+    const module = await loadModule(params.dir);
+    loaded = module;
+    await module.activate(buildApi(params));
+    return null;
+  });
+  peer.handle(TO_PLUGIN.deactivate, async () => {
+    await loaded?.deactivate?.();
+    return null;
+  });
+  peer.handle(TO_PLUGIN.toolExecute, async (params, ctx) => {
+    const tool = tools.get(params.name);
+    if (!tool)
+      throw new RpcError(`\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442 ${params.name} \u043D\u0435 \u0437\u0430\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0438\u0440\u043E\u0432\u0430\u043D`, "not_found");
+    const output = await tool.execute(params.args, {
+      conversationId: params.conversationId,
+      runId: params.runId,
+      signal: ctx.signal,
+      requestPermission: (reason) => peer.call(TO_CORE.requestPermission, { token: params.token, reason })
+    });
+    const result = typeof output === "string" ? { text: output } : { text: output.text, ...output.mime ? { mime: output.mime } : {} };
+    return result;
+  });
+  peer.handle(TO_PLUGIN.contribute, async (params) => {
+    const contribute = contributors.get(params.name);
+    if (!contribute)
+      return null;
+    return await contribute({ conversationId: params.conversationId, userText: params.userText }) ?? null;
+  });
+  peer.handle(TO_PLUGIN.providerChat, async (params, ctx) => {
+    const provider = providers.get(params.providerId);
+    if (!provider)
+      throw new RpcError(`\u041F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440 ${params.providerId} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D`, "not_found");
+    for await (const event of provider.chat(params.request, ctx.signal)) {
+      ctx.push(event);
+    }
+    return null;
+  });
+  peer.handle(TO_PLUGIN.actionRun, async (params) => {
+    const handler = actions.get(params.name);
+    if (!handler)
+      throw new Error(`\u041F\u043B\u0430\u0433\u0438\u043D \u043D\u0435 \u0437\u043D\u0430\u0435\u0442 \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u044F \xAB${params.name}\xBB`);
+    try {
+      const message = await handler();
+      return { ok: true, message: message || "\u0413\u043E\u0442\u043E\u0432\u043E" };
+    } catch (error) {
+      return { ok: false, message: error.message };
+    }
+  });
+  peer.handle(TO_PLUGIN.jobRun, async (params) => {
+    const run2 = jobs.get(params.name);
+    if (!run2)
+      throw new RpcError(`\u0417\u0430\u0434\u0430\u0447\u0430 ${params.name} \u043D\u0435 \u043E\u0431\u044A\u044F\u0432\u043B\u0435\u043D\u0430`, "not_found");
+    await run2();
+    return null;
+  });
+  peer.onEvent(TO_PLUGIN.settingsChanged, ({ values }) => {
+    settings = { ...settings, ...values };
+    for (const listener of settingsListeners)
+      listener(settings);
+  });
+  peer.onEvent(TO_PLUGIN.journalEvent, ({ entry }) => {
+    for (const listener of journalListeners)
+      listener(entry);
+  });
+  process.on("uncaughtException", (error) => {
+    peer.emit(TO_CORE.log, { level: "error", message: `\u041D\u0435\u043E\u0431\u0440\u0430\u0431\u043E\u0442\u0430\u043D\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430: ${error.message}` });
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    peer.emit(TO_CORE.log, { level: "error", message: `\u041D\u0435\u043E\u0431\u0440\u0430\u0431\u043E\u0442\u0430\u043D\u043D\u044B\u0439 \u043E\u0442\u043A\u0430\u0437: ${String(reason)}` });
+  });
+  peer.emit(HOST_READY, { api: PLUGIN_API_VERSION });
+}
+async function loadModule(dir) {
+  const manifest = JSON.parse(fs.readFileSync(path.join(dir, "axon.plugin.json"), "utf8"));
+  if (!manifest.main) {
+    throw new RpcError("\u0423 \u043F\u043B\u0430\u0433\u0438\u043D\u0430 \u043D\u0435\u0442 \u0442\u043E\u0447\u043A\u0438 \u0432\u0445\u043E\u0434\u0430 \u2014 \u0437\u0430\u043F\u0443\u0441\u043A\u0430\u0442\u044C \u043D\u0435\u0447\u0435\u0433\u043E", "no_main");
+  }
+  const entry = path.resolve(dir, manifest.main);
+  const imported = await import(pathToFileURL(entry).href);
+  const module = "activate" in imported ? imported : imported.default;
+  if (!module || typeof module.activate !== "function") {
+    throw new RpcError(`${manifest.main} \u043D\u0435 \u044D\u043A\u0441\u043F\u043E\u0440\u0442\u0438\u0440\u0443\u0435\u0442 activate(api)`, "bad_entry");
+  }
+  return module;
+}
+
+// ../core/dist/plugins/install.js
+var run = promisify(execFile);
+
+// ../core/dist/plugins/LoadedPlugin.js
+import { z as z14 } from "zod";
+
+// ../core/dist/mcp/McpConnection.js
+import { z as z13 } from "zod";
+
+// ../core/dist/routines/Compiler.js
+import { z as z15 } from "zod";
+var RESULT = z15.object({
+  name: z15.string().min(1).max(120),
+  description: z15.string().max(500).default(""),
+  schedule: zSchedule,
+  steps: z15.array(zRoutineStep).max(60)
+});
+
+// ../core/dist/routines/Executor.js
+var VARIABLE = new RegExp("\\$\\{(\\p{L}[\\p{L}\\p{N}_]*)\\}", "gu");
+
+// ../core/dist/providers/AnthropicProvider.js
+import Anthropic from "@anthropic-ai/sdk";
+
+// ../core/dist/providers/pricing.js
+var ANTHROPIC_DEFAULT = {
+  cacheReadRatio: 0.1,
+  cacheWriteRatio: 1.25
+};
+var RATES = {
+  anthropic: {
+    "claude-opus-5": { inputPerMTok: 5, outputPerMTok: 25, ...ANTHROPIC_DEFAULT },
+    "claude-opus-4-8": { inputPerMTok: 5, outputPerMTok: 25, ...ANTHROPIC_DEFAULT },
+    "claude-sonnet-5": { inputPerMTok: 3, outputPerMTok: 15, ...ANTHROPIC_DEFAULT },
+    "claude-haiku-4-5": { inputPerMTok: 1, outputPerMTok: 5, ...ANTHROPIC_DEFAULT }
+  },
+  deepseek: {
+    // У DeepSeek кэш работает иначе: попадание тарифицируется отдельной ставкой,
+    // а не множителем, но в пересчёте это примерно тот же порядок.
+    "deepseek-chat": {
+      inputPerMTok: 0.27,
+      outputPerMTok: 1.1,
+      cacheReadRatio: 0.26,
+      cacheWriteRatio: 1
+    },
+    "deepseek-reasoner": {
+      inputPerMTok: 0.55,
+      outputPerMTok: 2.19,
+      cacheReadRatio: 0.26,
+      cacheWriteRatio: 1
+    }
+  }
+};
+
+// ../core/dist/tools/ToolRegistry.js
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// ../core/dist/tools/builtin/files.js
+import { z as z16 } from "zod";
+var HUGE_FILE_BYTES = 5 * 1024 * 1024;
+
+// ../core/dist/tools/builtin/http.js
+import { z as z17 } from "zod";
+var MAX_RESPONSE_BYTES = 512 * 1024;
+
+// ../core/dist/tools/builtin/memory.js
+import { z as z18 } from "zod";
+
+// ../core/dist/tools/builtin/persona.js
+import { z as z19 } from "zod";
+
+// ../core/dist/tools/builtin/recall.js
+import { z as z20 } from "zod";
+
+// ../core/dist/tools/builtin/shell.js
+import iconv from "iconv-lite";
+import { z as z21 } from "zod";
+var MAX_OUTPUT_BYTES = 512 * 1024;
+
+// ../core/dist/tools/builtin/skills.js
+import { z as z22 } from "zod";
+
+// ../core/dist/tools/builtin/system.js
+import { z as z23 } from "zod";
+
+// src/plugin-host.ts
+startPluginHost();