// ============================================================
// PES Platform — Telegram Adapter
// ============================================================
// Connects PES to Telegram via Bot API (raw fetch, 0 deps).
//
// Features:
//   - Sticker delivery (from ANY public sticker pack)
//   - Emoji reactions on owner messages (setMessageReaction)
//   - Reaction collection (message_reaction updates → feedback loop)
//   - Bot commands (/start, /status, /feed, /command, /silent, /stickers)
//   - Keyword parser (привет→greeting, молодец→praise)
//   - "Typing..." delay scaled by PES level
//   - Sticker pack hot-swap
//
// Dependencies: 0 (uses built-in fetch)
// ============================================================

import { PesPlatformAdapter, RENDER_MODE, PRESENCE, MEDIA_TYPE } from './base.js';
import { sleep } from '../utils.js';
import { LLMAdapter } from '../brain/llm-adapter.js';
import { buildSystemPrompt, buildMessages } from '../brain/prompt-builder.js';
import { BabbleEngine } from '../soul/babble-engine.js';
import { CrmClient } from './crm-client.js';
import { WorkflowEngine } from '../core/workflows.js';

// Valid emotions for LLM classification — must match babble-engine EMOTION_INSTRUMENTS keys
const EMOTION_INSTRUMENTS_SET = new Set([
  'happy', 'playful', 'greeting_frenzy', 'butt_wiggle', 'zoomies', 'excited',
  'idle', 'content', 'nap', 'sleep',
  'sad', 'lonely', 'scared', 'anxious',
  'food_obsessed', 'hungry',
  'alert', 'angry', 'bark',
  'curious', 'puzzle_solving',
  'dramatic_tantrum', 'sulking', 'stubborn_refuse',
]);
import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync, rmSync, unlinkSync } from 'node:fs';
import { createHash } from 'node:crypto';
import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';

const __tg_dirname = dirname(fileURLToPath(import.meta.url));
const DEV_LOG_DIR = join(__tg_dirname, '..', 'pes-data');
const DEV_LOG_FILE = join(DEV_LOG_DIR, 'dev-requests.log');


// ── TELEGRAM API BASE ─────────────────────────────────────

const TG_API = 'https://api.telegram.org/bot';

// ── TELEGRAM ALLOWED REACTION EMOJI ──────────────────────
// Telegram only allows a specific set of emoji for reactions.
// This is the official list for regular (non-premium) reactions.
const ALLOWED_REACTIONS = new Set([
  '👍', '👎', '❤️', '🔥', '🥰', '👏', '😁', '🤔', '🤯', '😱', '🤬', '😢', '🎉',
  '🤩', '🤮', '💩', '✍️', '👀', '🎅', '🎄', '☃️', '💅', '🤪', '🗿', '🆒', '💘',
  '🙈', '😇', '😨', '🤝', '✊', '🫡', '🍌', '🏆', '💔', '🤨', '😐', '🍓', '🍾',
  '💋', '🖕', '😈', '😴', '😭', '🤓', '👻', '👨‍💻', '🎃', '🙏', '🤡', '🥱', '🥴',
  '😍', '🐳', '❤️‍🔥', '🌚', '🌭', '💯', '🤣', '⚡', '🍕', '😘', '💊', '🙊',
  '😎', '👾', '🤷', '🤷‍♂️', '🤷‍♀️', '😡',
]);

// ── KEYWORD PATTERNS ──────────────────────────────────────

const KEYWORDS = {
  greetings: {
    patterns: [/^привет/i, /^здравствуй/i, /^хай/i, /^hi\b/i, /^hello/i, /^hey\b/i, /^yo\b/i, /^салам/i, /^дарова/i],
    event: { type: 'owner_returned', from: 'owner' },
  },
  praise: {
    patterns: [/молодец/i, /хорош/i, /класс/i, /супер/i, /отлично/i, /круто/i, /\bgood\b/i, /\bgreat\b/i, /\bnice\b/i, /\bperfect/i, /\bawesome/i, /умница/i, /браво/i, /ура/i],
    action: 'praise',
  },
  scold: {
    patterns: [/^нет$/i, /^нет[,.\s!]/i, /плохо/i, /^стоп$/i, /^стоп[,.\s!]/i, /не надо/i, /хватит/i, /\bbad\b/i, /\bstop\b/i, /\bno\b/i, /\bwrong\b/i, /фу/i, /нельзя/i],
    action: 'scold',
  },
  file_search: {
    patterns: [/где мо[йяеи]/i, /найди файл/i, /найди фото/i, /найди документ/i, /принеси файл/i, /принеси фото/i, /принеси документ/i, /покажи файл/i, /покажи фото/i, /где файл/i, /где фото/i, /где документ/i, /где паспорт/i, /где страховк/i, /где договор/i],
    action: 'file_search',
  },
  fetch: {
    patterns: [/^принеси/i, /^найди/i, /^ищи/i, /^fetch\b/i, /^find\b/i, /^search\b/i, /^апорт/i, /^мячик/i],
    action: 'command',
    command: 'fetch',
  },
  status: {
    patterns: [/как дела/i, /как ты/i, /статус/i, /\bstatus\b/i, /что нового/i, /как жизнь/i],
    action: 'status',
  },
  feed: {
    patterns: [/^кушай/i, /^ешь/i, /^на\s/i, /^держи/i, /^feed\b/i],
    action: 'feed',
  },
  play: {
    patterns: [/^играть/i, /^играем/i, /^play\b/i, /^давай играть/i],
    event: { type: 'play_initiated', from: 'owner' },
  },
  triage: {
    patterns: [/^что.?нов(ого|ое)/i, /^triage/i, /^триаж/i, /^проверь crm/i, /^скань/i],
    action: 'workflow',
    command: 'triage',
  },
  daily_summary: {
    patterns: [/итоги дня/i, /итоги за день/i, /расскажи итоги/i, /daily.?summary/i, /сводка/i, /^отчёт$/i, /^отчет$/i],
    action: 'workflow',
    command: 'daily_summary',
  },
  health: {
    patterns: [/^здоровье$/i, /^health$/i, /как здоровье/i, /проверь себя/i, /самочувствие/i],
    action: 'workflow',
    command: 'health_check',
  },
};


// ── STICKER EMOTION MAP (default mapping) ─────────────────

const DEFAULT_STICKER_EMOTION_MAP = {
  // body keys → sticker keys
  butt_wiggle_turbo: 'happy',
  butt_wiggle_fast:  'excited',
  butt_wiggle_slow:  'interested',
  no_wiggle:         'sad',
  ears_forward:      'alert',
  ears_flat:         'scared',
  sploot:            'relaxed',
  play_bow:          'playful',
  corgi_flop:        'trust',
  zoomies:           'zoomies',
  sleep_curl:        'sleeping',
  low_crouch:        'working',
  freeze:            'alert',
  hide_behind:       'scared',
  belly_up:          'submissive',
  nose_nudge:        'curious',
  paw_lift:          'asking',
  head_tilt:         'confused',
  spin:              'excited',
  bunny_hop:         'happy',
};


// ── BODY ACTION SYMBOLS (no human words — only sounds, emoji, symbols) ───
// Animals don't describe actions in words. They EXPRESS through sounds + emoji.

const BODY_ACTIONS = {
  butt_wiggle_turbo: ['🍑💨💨💨', '🍑⚡⚡', '🍑🌀🌀🌀'],
  butt_wiggle_fast:  ['🍑💨', '🍑~~', '🍑✨'],
  butt_wiggle_slow:  ['🍑~', '🍑...'],
  no_wiggle:         ['🍑.', '...'],
  ears_forward:      ['👂⬆️👂', '👂❗', '📡📡'],
  ears_airplane:     ['👂↔️👂', '✈️👂'],
  ears_one_up:       ['👂⬆️👂↗️', '👂❓'],
  ears_flat:         ['👂⬇️👂', '👂...'],
  ears_twitching:    ['👂〰️👂', '👂⚡'],
  sploot:            ['🫠', '___🐾', '⬇️🫠'],
  play_bow:          ['🔽🐾⬆️🍑', '⬇️🐾 ⬆️🍑', '🐾↘️ 🍑↗️'],
  corgi_flop:        ['💥🫠', '🐾→🫠'],
  low_crouch:        ['🐾⬇️⬇️', '👀⬇️🐾'],
  belly_up:          ['🔄🐾☁️', '⬆️🫄', '🐾🔄☁️'],
  lean:              ['🐾→💛', '↗️💛', '🐾~💛'],
  body_block:        ['🐾🚧', '⛔🐾'],
  bunny_hop:         ['🐾⬆️⬆️⬆️', '🐾↗️↗️', '⬆️⬆️⬆️'],
  spin:              ['🌀🐾🌀', '🔄🐾', '🌀🌀'],
  paw_tap:           ['🐾👆', '🐾👆👆', '🐾❗'],
  nose_nudge:        ['👃💨', '👃→', '👃❗'],
  side_eye:          ['👀↗️', '👀...', '🫣'],
  hide_behind:       ['🫣🐾', '👀...🐾'],
  circle:            ['🔄🐾🔄', '🐾↻↻'],
  zoomies:           ['🐾💨💨💨💨', '⚡🐾⚡', '🏃💨💨'],
  freeze:            ['🐾...⏸️', '❄️🐾', '⏸️...'],
  sleep_curl:        ['💤🐾', '😴💤', '🐾~💤'],
  head_tilt:         ['🐾↗️❓', '😮❓'],
  paw_lift:          ['🐾⬆️', '🐾☝️'],
};

// ── PUPPY BABBLE — random personality phrases ────────────

const PUPPY_BABBLE = {
  idle:     ['', '', '', 'ууу~...', 'ыыы...', 'скууу...'],
  playful:  ['тяф тяф!! ваф!!', 'ЫЫЫ!! ваф-ваф!!', 'рру!! тяф!!', 'гав ГАВ!!', ''],
  happy:    ['', '', 'ррууу~ ♡', '💛', 'ваф!!'],
  content:  ['', 'ммм~...', 'рру~...', 'ууу~'],
  butt_wiggle: ['', '', 'ыыыЫЫЫ!!', 'рррРРР!!'],
  alert:    ['ГАВ?!', 'рр!! ваф!!', 'ррр?! ууу?!', 'ВАФ!!'],
  scared:   ['ууу...', 'хнн...', '😱', ''],
  grumble:  ['хмфф.', 'ррр.', 'мрр...', 'пфф.'],
  food_obsessed: ['МНЯМ!!', 'хрум хрум!!', 'ааау мням!!', 'ваф! ваф! мням!!'],
  zoomies:  ['ЫЫЫЫ!!', 'РРРР!!', 'ВАФФФ!!', 'АААУУУ!!'],
  puppy_eyes: ['ууу~...', '🥺', 'скууу~...'],
  sad:      ['...', 'хнн...', '', '💧'],
  sleep:    ['zzz...', 'хррр...', '💤', 'ммрр...'],
};

// ── OWNER REPLY PHRASES — for when PES reacts to owner ───

const OWNER_REPLIES = {
  greeting: [
    'ГАВВВ!! рруу ууу ыыыа!! ♡ тяф-тяф!!',
    'ыыыЫЫЫ!! ваф ваф ВАФ!! 💛💛',
    'ррРРуууу!! гав! гав! ГАААВ!! ♡♡',
    'тяф-тяф-тяф!! ууууу!! 💛💛💛',
  ],
  praise: [
    'ррРРРуууу!! ыыыыы гав-гав ~~ ♡♡ вввуууф!!',
    'ууууУУУ!! тяф! тяф! 💛💛💛!!',
    'ммммм~ рру~ ♡ ууу~... ваф!',
    'ЫЫЫЫ!! рр рр РРРР!! ♡♡♡!!',
  ],
  scold: [
    'скууу... ыыы.. хнн.. 💧',
    'ууу... хнн... ... 💧',
    '... хххн.. скс.. ...',
    'скууу...... .......',
  ],
  feed: [
    'МНЯМ мням мням!! ррр ффф хрум-хрум ааау!!',
    'ваф! ваф! МНЯМ!! хрум хрум!! 🤤',
    'АААУ!! мням-мням-МНЯМ!! ррр!!',
    'хрум!! хрум!! МНЯЯЯМ!! ваф!!',
  ],
  generic: [
    'рру? ...тяф? 🐾',
    'ваф. ...ыы? ...рру~',
    'гав? ...ууу~ 🐾',
    'тяф! рру~ ваф?',
    'ыыы~ ...рр? 🐾',
  ],
};

// ── EMOTION → EMOJI STATUS MAP ──────────────────────────
// Maps PES emotion states to emoji for bot bio / status display

const EMOTION_EMOJI_STATUS = {
  happy:            { emoji: '😊', label: 'счастлив', short: '💛 счастлив' },
  playful:          { emoji: '🎾', label: 'играет', short: '🎾 играет' },
  greeting_frenzy:  { emoji: '🤩', label: 'в восторге', short: '🤩 в восторге' },
  butt_wiggle:      { emoji: '🍑', label: 'виляет', short: '🍑 виляет хвостом' },
  zoomies:          { emoji: '⚡', label: 'зумис', short: '⚡ зумис!!' },
  excited:          { emoji: '🎉', label: 'возбуждён', short: '🎉 возбуждён' },
  idle:             { emoji: '😐', label: 'скучает', short: '😐 скучает' },
  content:          { emoji: '☺️', label: 'доволен', short: '☺️ доволен' },
  nap:              { emoji: '😪', label: 'дремлет', short: '😪 дремлет' },
  sleep:            { emoji: '💤', label: 'спит', short: '💤 спит' },
  sad:              { emoji: '😢', label: 'грустит', short: '😢 грустит' },
  lonely:           { emoji: '🥺', label: 'скучает', short: '🥺 скучает по хозяину' },
  scared:           { emoji: '😨', label: 'испуган', short: '😨 испуган' },
  anxious:          { emoji: '😰', label: 'тревожен', short: '😰 тревожится' },
  food_obsessed:    { emoji: '🤤', label: 'голоден', short: '🤤 хочет есть' },
  hungry:           { emoji: '🍖', label: 'голоден', short: '🍖 голоден' },
  alert:            { emoji: '👀', label: 'настороже', short: '👀 настороже' },
  angry:            { emoji: '😤', label: 'злится', short: '😤 злится' },
  bark:             { emoji: '🐕', label: 'лает', short: '🐕 ГАВ!' },
  curious:          { emoji: '🔍', label: 'исследует', short: '🔍 исследует' },
  puzzle_solving:   { emoji: '🧩', label: 'думает', short: '🧩 решает задачу' },
  dramatic_tantrum: { emoji: '🎭', label: 'драматизирует', short: '🎭 драма!' },
  sulking:          { emoji: '😒', label: 'дуется', short: '😒 дуется' },
  stubborn_refuse:  { emoji: '🙅', label: 'упрямится', short: '🙅 не хочу!' },
};

function pickRandom(arr) {
  return arr[Math.floor(Math.random() * arr.length)];
}

// ── THINKING DELAY per level ──────────────────────────────

function thinkingDelay(level) {
  // Level gates removed — fast response for testing
  return 500 + Math.random() * 500; // 0.5-1s
}


// ── TELEGRAM ADAPTER ──────────────────────────────────────

class TelegramAdapter extends PesPlatformAdapter {
  /**
   * @param {Pes}    pes     — PES instance
   * @param {Object} config
   * @param {string} config.botToken       — Telegram Bot API token
   * @param {string|number} config.chatId  — Chat ID with owner
   * @param {string}  [config.stickerPack]   — sticker pack name to load
   * @param {Object}  [config.stickerMapping] — { stickerIndex: emotionKey }
   * @param {number}  [config.pollingInterval] — ms between getUpdates (default: 2000)
   * @param {boolean} [config.useThinkingDelay] — show "typing..." before reply (default: true)
   * @param {string}  [config.ownerUsername]  — owner's Telegram username (for identity check)
   */
  constructor(pes, config = {}) {
    super(pes, {
      platformName: 'telegram',
      renderMode: RENDER_MODE.RICH,
      ...config,
    });

    if (!config.botToken) throw new Error('TelegramAdapter: botToken required');
    if (!config.chatId) throw new Error('TelegramAdapter: chatId required');

    this.botToken = config.botToken;
    this.chatId = String(config.chatId);
    this.ownerUsername = config.ownerUsername || null;
    this.pollingInterval = config.pollingInterval || 2000;
    this.useThinkingDelay = config.useThinkingDelay !== false;

    // Polling state
    this._pollOffset = 0;
    this._polling = false;
    this._pollTimer = null;

    // Last owner message ID (for reactions)
    this._lastOwnerMessageId = null;

    // Sticker pack info
    this._currentStickerPack = config.stickerPack || null;
    this._stickerMapping = config.stickerMapping || {};
    this._learnedPacks = new Set(); // all packs learned from owner's stickers

    // Bot info (filled on first API call)
    this._botInfo = null;

    // ── LLM Brain ──────────────────────────────────────
    this._llm = null;
    if (config.llmApiKey) {
      this._llm = new LLMAdapter({
        apiKey: config.llmApiKey,
        model: config.llmModel || 'gpt-4o-mini',
        timeout: 5000,
        maxTokens: 200,
      });
    }
    this._characterDesc = config.characterDesc || null;

    // ── Orchestrator LLM (live chat mode via /orchestrator) ──
    this._orchestratorLLM = null;
    if (config.llmApiKey) {
      this._orchestratorLLM = new LLMAdapter({
        apiKey: config.llmApiKey,
        model: 'gpt-4o',
        timeout: 30000,
        maxTokens: 1500,
      });
    }
    this._orchestratorHistory = []; // conversation memory for orchestrator mode
    this._orchestratorHistoryLimit = 30;

    // ── Shadow Orchestrator — always-on observer ──
    this._shadowBuffer = [];          // last N messages for context
    this._shadowBufferLimit = 50;     // how many messages to remember
    this._shadowEnabled = true;       // always on
    // Trigger keywords that summon orchestrator inline (PES stays active)
    this._shadowTriggers = /^(N23|n23|оркестратор|orchestrator|фикс|fix|почини|repair|диагноз|diagnose|анализ|analyze|проблема|problem|баг|bug|что не так|what.?s wrong)/i;

    // ── Short Memory with context compression ──
    this._memory = [];
    this._memoryLimit = 10;
    this._contextSummary = ''; // accumulated compressed context from past messages
    this._summarizing = false; // lock to prevent concurrent summarization

    // ── Emoji learning ──
    this._emojiAnalysisQueue = []; // emojis waiting for LLM description
    this._analyzingEmojis = false;

    // ── Sticker learning ──
    this._stickerAnalysisQueue = []; // stickers waiting for LLM description
    this._analyzingStickers = false;

    // ── Reminders ──
    this._reminderInterval = null;

    // ── File handling ──
    this._fileAnalysisQueue = []; // files waiting for LLM description
    this._analyzingFiles = false;
    // Per-user files directory in managed mode
    this._filesDir = config.managed
      ? join(__tg_dirname, '..', 'pes-data', 'users', String(config.chatId), 'files')
      : join(__tg_dirname, '..', 'pes-data', 'files');
    this._maxFileSizeMB = 20; // max file size in MB
    this._maxDiskQuotaMB = 500; // max total disk usage in MB

    // ── Reaction Memory ──
    this._lastBotAction = null;   // { action: 'reply', text: '...', category: '...', timestamp: Date.now() }
    this._reactionRecalcCounter = 0; // recalculate preferences every N reactions
    this._recentReactions = [];   // last 8 reactions for anti-repeat
    this._dailyReactionLog = [];  // all reactions today for diversity tracking

    // ── Sticker Mirror (delayed "try back") ──
    this._pendingMirrorSticker = null; // { fileId, fileUniqueId, emoji, receivedAt, messagesUntilMirror }
    this._messagesSinceMirror = 0;

    // ── Last sent sticker tracking (for reaction → preference_score) ──
    this._lastSentStickerUniqueId = null;
    this._recentSentStickers = []; // last 10 sent sticker unique_ids — for anti-repeat

    // ── Babble Engine — use PES's engine if available, else create own ──
    if (pes?.babble) {
      this._babble = pes.babble;
    } else {
      const pesSeed = pes?.identity?.seed || 0.42;
      const pesTraits = pes?.emotions?.traits || {};
      this._babble = new BabbleEngine(pesSeed, pesTraits);
      if (pes?.store) {
        try {
          const babbleData = pes.store.getBabbleState?.();
          if (babbleData) this._babble.load(babbleData);
        } catch (_) {}
      }
    }

    // ── CRM Client (bidirectional bridge) ──
    this._crm = null;
    if (config.jwtSecret) {
      this._crm = new CrmClient({
        baseUrl: config.crmBaseUrl || 'http://127.0.0.1:5000',
        jwtSecret: config.jwtSecret,
        spaceId: config.crmSpaceId || 11,
      });
    }

    // ── Workflow Engine (agentic workflows) ──
    this._workflows = new WorkflowEngine({
      store: pes?.store,
      crm: this._crm,
      pes: pes,
    });

    // ── Managed mode (PesManager controls polling) ──
    this._managed = config.managed || false;
    this._managedInit = false;

    // ── Emoji Status ──
    this._lastEmojiStatus = null;    // last emotion synced to bio
    this._emojiStatusInterval = null;
    this._lastBioUpdate = 0;         // timestamp of last bio update (rate limit)
  }

  // ═══════════════════════════════════════════════════════════
  // MANAGED MODE (called by PesManager)
  // ═══════════════════════════════════════════════════════════

  /**
   * Initialize adapter without starting polling.
   * Called by PesManager for managed instances.
   */
  async initManaged() {
    if (this._managedInit) return;
    this._managedInit = true;

    // Mark as connected (normally done by startListening → startCollecting)
    this._connected = true;

    // Wire PES expression auto-delivery (same as base.startListening)
    this.pes.on('expression', async (result) => {
      if (this._connected) {
        try { await this.deliver(result); } catch (_) {}
      }
    });

    // Wire achievement notifications
    this.pes.on('achievement', async (ach) => {
      if (this._connected && this.chatId) {
        try {
          await this._sendText(this.chatId, `🏆 *Достижение разблокировано!*\n\n${ach.emoji} *${ach.name}*\n${ach.description}`, { parse_mode: 'Markdown' });
        } catch (e) { console.error('[PES] achievement notification error:', e.message); }
      }
    });

    // Set bot commands (only once per bot, not per user — but harmless to call)
    try { await this._setMyCommands(); } catch (_) {}

    // Set Mini App menu button
    try { await this._setMenuButton(); } catch (_) {}

    // Initialize owner relationship
    this._initOwnerRelationship();

    // Load persisted context summary from DB
    this._loadContextSummary();

    // Load sticker packs from DB
    this._loadStickerPacksFromDB();

    // Start reminder checker
    this.startReminderChecker();

    // Start idle behavior timer
    this._startIdleTimer();

    // Start emoji status sync
    this._startEmojiStatusSync();

    // Start workflow scheduler with auto-run notifications
    try {
      const stats = this.pes?.store?.getStats?.();
      if (stats) {
        this._workflows.startScheduler(stats.level);
        this._workflows.onAutoRun((workflowId, result) => {
          if (this.chatId && result.text) {
            const prefix = `🤖 Авто-workflow: ${workflowId}\n\n`;
            this._sendText(this.chatId, prefix + result.text).catch(() => {});
          }
        });
      }
    } catch (_) {}
  }

  /**
   * Handle a single Telegram update routed by PesManager.
   * Replaces the chatId filter — PesManager already routed correctly.
   */
  async handleUpdate(update) {
    await this._processUpdate(update);
  }

  // ═══════════════════════════════════════════════════════════
  // TELEGRAM API WRAPPER (raw fetch)
  // ═══════════════════════════════════════════════════════════

  /**
   * Raw Telegram Bot API call.
   * @param {string} method — API method name
   * @param {Object} params — request body
   * @returns {Promise<Object>} — API response result
   */
  async _call(method, params = {}) {
    const url = `${TG_API}${this.botToken}/${method}`;
    const res = await fetch(url, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(params),
    });
    const data = await res.json();
    if (!data.ok) {
      const err = new Error(`Telegram API error: ${data.description || 'unknown'}`);
      err.code = data.error_code;
      throw err;
    }
    return data.result;
  }

  /**
   * Call Telegram API with multipart/form-data (for file uploads).
   * Uses native FormData + Blob (Node 18+).
   * @param {string} method — API method name
   * @param {Object} params — regular params (will be appended as form fields)
   * @param {Buffer} fileBuffer — file data
   * @param {string} fieldName — form field name for the file (e.g. 'sticker', 'png_sticker', 'photo')
   * @param {string} fileName — filename to send
   * @returns {Promise<Object>}
   */
  async _callWithFile(method, params = {}, fileBuffer, fieldName, fileName = 'file.png') {
    const url = `${TG_API}${this.botToken}/${method}`;
    const formData = new FormData();

    // Add regular params
    for (const [key, value] of Object.entries(params)) {
      if (value === undefined || value === null) continue;
      if (typeof value === 'object') {
        formData.append(key, JSON.stringify(value));
      } else {
        formData.append(key, String(value));
      }
    }

    // Add file
    const blob = new Blob([fileBuffer], { type: 'application/octet-stream' });
    formData.append(fieldName, blob, fileName);

    const res = await fetch(url, { method: 'POST', body: formData });
    const data = await res.json();
    if (!data.ok) {
      const err = new Error(`Telegram API error: ${data.description || 'unknown'}`);
      err.code = data.error_code;
      throw err;
    }
    return data.result;
  }

  /** Send a text message. */
  async _sendText(chatId, text, opts = {}) {
    return this._call('sendMessage', {
      chat_id: chatId,
      text,
      parse_mode: opts.parseMode || undefined,
      reply_to_message_id: opts.replyTo || undefined,
      disable_notification: opts.silent || false,
      reply_markup: opts.reply_markup || undefined,
    });
  }

  /**
   * Send text with inline custom emoji entities.
   * @param {string} chatId
   * @param {string} text — text with placeholder markers like {emoji:ID}
   * Custom emoji IDs are embedded inline: "text {emoji:5368324170671202286} more text"
   * The placeholder is replaced with a Unicode placeholder char and entities array is built.
   */
  async _sendTextWithCustomEmoji(chatId, text) {
    // Parse {emoji:ID} placeholders
    const emojiRegex = /\{emoji:(\d+)\}/g;
    const entities = [];
    let cleanText = '';
    let lastIndex = 0;
    let match;

    // UTF-16 code units length (Telegram API uses UTF-16 offsets)
    const utf16Len = (str) => {
      let len = 0;
      for (const ch of str) { len += ch.codePointAt(0) > 0xFFFF ? 2 : 1; }
      return len;
    };

    while ((match = emojiRegex.exec(text)) !== null) {
      // Add text before the placeholder
      cleanText += text.slice(lastIndex, match.index);
      // Calculate offset in UTF-16 code units
      const offset = utf16Len(cleanText);
      // Add a single placeholder character (the custom emoji occupies 1 char visually)
      const placeholder = '⭐'; // visible fallback for non-premium users
      cleanText += placeholder;
      entities.push({
        type: 'custom_emoji',
        offset,
        length: utf16Len(placeholder),
        custom_emoji_id: match[1],
      });
      lastIndex = match.index + match[0].length;
    }
    cleanText += text.slice(lastIndex);

    if (entities.length === 0) {
      // No custom emoji found — send as plain text
      return this._sendText(chatId, cleanText);
    }

    return this._call('sendMessage', {
      chat_id: chatId,
      text: cleanText,
      entities,
    });
  }

  /** Send a sticker, optionally with origin attribution button. */
  async _sendSticker(chatId, stickerFileId, opts = {}) {
    const params = {
      chat_id: chatId,
      sticker: stickerFileId,
    };

    // Auto-attach origin button if available and not explicitly disabled
    if (opts.reply_markup) {
      params.reply_markup = opts.reply_markup;
    } else if (opts.skipOrigin !== true && this.pes.store) {
      const origin = this.pes.store.getOriginByFileId(stickerFileId);
      if (origin && origin.original_set_name) {
        const title = (origin.original_set_title || origin.original_set_name).slice(0, 30);
        params.reply_markup = JSON.stringify({
          inline_keyboard: [[{
            text: `📦 Из пака «${title}»`,
            url: `https://t.me/addstickers/${origin.original_set_name}`,
          }]],
        });
      }
    }

    return this._call('sendSticker', params);
  }

  /**
   * Set emoji reaction on a message.
   * Bots can only use standard emoji reactions (75 allowed by Telegram).
   */
  async _setReaction(chatId, messageId, emoji) {
    try {
      return await this._call('setMessageReaction', {
        chat_id: chatId,
        message_id: messageId,
        reaction: [{ type: 'emoji', emoji }],
      });
    } catch (err) {
      if (err.code === 400) return null;
      throw err;
    }
  }

  /**
   * Proactively react to owner's message with an emoji.
   * Dog "sniffs" the message and reacts emotionally.
   * Probability and emoji choice depend on traits, mood, context.
   */
  async _reactToOwnerMessage(msg, category) {
    if (!this._lastOwnerMessageId) return;

    const traits = this.pes.traits || {};
    const mood = this.pes.mood || 0.5;
    const level = this.pes.level || 0;

    // ── Reaction probability: not every message ──
    let prob = 0.40;
    prob += (traits.playfulness || 0.5) * 0.15;
    prob -= (traits.stubbornness || 0.5) * 0.10;
    prob += (mood - 0.5) * 0.20;
    prob += Math.min(level, 50) * 0.003;

    const alwaysReact = ['praise', 'greetings', 'scold', 'feed', 'play'];
    if (alwaysReact.includes(category)) prob = 1.0;
    if (msg.sticker) prob = 0.95;
    if (msg.photo || msg.document) prob = Math.max(prob, 0.70);

    if (Math.random() > prob) return;

    // ── Build weighted emoji pool ──
    const emoji = this._pickReactionEmoji(category, traits, mood, level);
    if (!emoji) return;

    // ── Set the reaction ──
    try {
      await this._setReaction(this.chatId, this._lastOwnerMessageId, emoji);
      this._recentReactions.push(emoji);
      if (this._recentReactions.length > 8) this._recentReactions.shift();
      this._dailyReactionLog.push(emoji);
      if (this.pes.store) {
        try { this.pes.store.markEmojiUsed(emoji); } catch (_) {}
      }
      console.log(`🐾 PES reacted: ${emoji} (category: ${category || 'general'}, pool-size: ${this._lastReactionPoolSize || '?'})`);
    } catch (err) {
      console.log(`⚠️ Reaction failed: ${emoji} — ${err.message}`);
    }
  }

  /**
   * STANDARD 269: Smart emoji selection with anti-repeat, character pools,
   * learned emoji priority, mood-drift, and weighted random.
   */
  _pickReactionEmoji(category, traits, mood, level) {
    // ── 1. Base context pool ──
    const contextSets = {
      greetings:   ['❤️', '🔥', '👋', '😊', '🐾', '🤗', '💕'],
      praise:      ['❤️', '😍', '🥰', '🔥', '💯', '🎉', '👏', '✨'],
      scold:       ['😢', '💔', '😔', '🥺'],
      feed:        ['🤤', '❤️', '😋', '🔥', '🍖'],
      play:        ['🔥', '🎉', '❤️', '😂', '💯', '🤩', '⚡'],
      status:      ['👀', '🐾', '❤️', '🧐'],
      file_search: ['👀', '🔍', '🐾', '✨'],
      fetch:       ['🔥', '🎉', '❤️', '💯', '💪'],
    };

    const moodPool = mood > 0.7
      ? ['❤️', '🔥', '😊', '👍', '💯', '🎉', '😍', '🤩', '✨']
      : mood > 0.4
        ? ['👍', '❤️', '😊', '🐾', '👀', '😌', '🙂']
        : ['😢', '💔', '😔', '👀', '🥺'];

    let basePool = contextSets[category] || moodPool;

    // ── 2. Character trait pools — each trait > 0.5 adds its emoji ──
    const traitEmoji = {
      courage:      ['💪', '🦁', '⚡', '🏆', '👊'],
      curiosity:    ['👀', '🧐', '🔍', '❓', '🤔'],
      loyalty:      ['❤️', '🥰', '🤗', '💕', '🫶'],
      stubbornness: ['😤', '😏', '🙄', '💅'],
      playfulness:  ['😜', '🤪', '🎮', '🎲', '😝'],
      drama:        ['😍', '🔥', '💯', '🎉', '😱', '🤩', '💫'],
      foodDrive:    ['🤤', '😋', '🍖', '🍕', '😍'],
      sassiness:    ['😏', '💅', '✨', '😌', '👑'],
      aggression:   ['😤', '💢', '⚡'],
    };

    const characterPool = [];
    for (const [trait, emojis] of Object.entries(traitEmoji)) {
      const val = traits[trait] || traits[trait.replace(/([A-Z])/g, '_$1').toLowerCase()] || 0;
      if (val > 0.5) {
        // Higher trait = more emoji from this pool (1-3 emoji)
        const count = val > 0.8 ? 3 : val > 0.65 ? 2 : 1;
        for (let i = 0; i < count; i++) {
          characterPool.push(emojis[Math.floor(Math.random() * emojis.length)]);
        }
      }
    }

    // ── 3. Learned emoji from owner (×2 weight via duplication) ──
    const learnedPool = [];
    if (this.pes.store) {
      try {
        const learned = this.pes.store.getLearnedEmojis({ owner_only: true, limit: 20 });
        for (const le of learned) {
          if (le.emoji && le.emoji.length <= 4) { // Only single emoji, not sequences
            // ×2 weight for owner-sent, ×3 if preference_score > 0
            const copies = (le.preference_score || 0) > 0 ? 3 : 2;
            for (let i = 0; i < copies; i++) learnedPool.push(le.emoji);
          }
        }
      } catch (_) {}
      // Custom emoji reactions removed — Telegram Bot API doesn't support them for bots
    }

    // ── 4. Mood-drift: time-of-day emoji ──
    const hour = new Date().getHours();
    const timeEmoji = hour >= 6 && hour < 12
      ? ['☀️', '😊', '🌅']      // morning
      : hour >= 12 && hour < 18
        ? ['👍', '🔥', '💪']     // afternoon
        : hour >= 18 && hour < 23
          ? ['🌙', '😌', '✨']   // evening
          : ['👀', '😳', '🌙'];  // night

    // ── 5. Merge all pools with weights ──
    const weightedPool = [];
    for (const e of basePool) { weightedPool.push(e); weightedPool.push(e); } // ×2
    for (const e of characterPool) { weightedPool.push(e); } // ×1 (already trait-filtered)
    // Learned emoji from owner get ×4 extra (they ARE the owner's language)
    for (const e of learnedPool) { for (let i = 0; i < 4; i++) weightedPool.push(e); }
    // Time emoji — only add 1 copy (subtle)
    if (Math.random() < 0.3) {
      weightedPool.push(timeEmoji[Math.floor(Math.random() * timeEmoji.length)]);
    }

    // ── 5c. Filter pool — only ALLOWED standard emoji ──
    const filteredPool = weightedPool.filter(e => typeof e === 'string' && ALLOWED_REACTIONS.has(e));
    if (filteredPool.length === 0) {
      filteredPool.push('👍', '❤️', '🔥', '😁', '👏');
    }

    // ── 6. Anti-repeat weighting ──
    const recentCounts = {};
    for (const r of this._recentReactions) {
      recentCounts[r] = (recentCounts[r] || 0) + 1;
    }

    // Build final weighted candidates
    const finalWeights = [];
    const seenKeys = new Set();
    for (const e of filteredPool) {
      if (seenKeys.has(e)) {
        const existing = finalWeights.find(fw => fw.key === e);
        if (existing) existing.weight += 1;
        continue;
      }
      seenKeys.add(e);
      finalWeights.push({ emoji: e, key: e, weight: 1 });
    }
    // Count duplicates properly
    for (const e of filteredPool) {
      const fw = finalWeights.find(f => f.key === e);
      if (fw && fw.weight === 1) {
        fw.weight = filteredPool.filter(x => x === e).length;
      }
    }

    // Apply anti-repeat penalties
    for (const fw of finalWeights) {
      const recentCount = recentCounts[fw.key] || 0;
      if (recentCount >= 3) fw.weight *= 0.05;      // used 3+ of last 8 → almost blocked
      else if (recentCount === 2) fw.weight *= 0.3;  // used 2 times → heavy penalty
      else if (recentCount === 1) fw.weight *= 0.6;  // used once → moderate penalty
      else fw.weight *= 1.3;                          // never used recently → bonus
      fw.weight = Math.max(0.01, fw.weight);
    }

    if (finalWeights.length === 0) return null;
    this._lastReactionPoolSize = finalWeights.length;

    // ── 7. Weighted random selection ──
    const totalWeight = finalWeights.reduce((sum, fw) => sum + fw.weight, 0);
    let r = Math.random() * totalWeight;
    for (const fw of finalWeights) {
      r -= fw.weight;
      if (r <= 0) return fw.emoji;
    }
    return finalWeights[finalWeights.length - 1].emoji;
  }

  /** Send chat action ("typing...", etc.). */
  async _sendChatAction(chatId, action = 'typing') {
    return this._call('sendChatAction', { chat_id: chatId, action });
  }

  /** Get sticker set by name. */
  async _getStickerSet(name) {
    return this._call('getStickerSet', { name });
  }

  /** Get file path for downloading. */
  async _getFilePath(fileId) {
    return this._call('getFile', { file_id: fileId });
  }

  /** Download a file from Telegram servers. Returns Buffer. */
  async _downloadTelegramFile(filePath) {
    const url = `https://api.telegram.org/file/bot${this.botToken}/${filePath}`;
    const res = await fetch(url);
    if (!res.ok) throw new Error(`Download failed: ${res.status}`);
    return Buffer.from(await res.arrayBuffer());
  }

  /** Send a document (file) to chat. */
  async _sendDocument(chatId, fileIdOrPath, opts = {}) {
    return this._call('sendDocument', {
      chat_id: chatId,
      document: fileIdOrPath,
      caption: opts.caption || undefined,
    });
  }

  /** Send a photo to chat. */
  async _sendPhoto(chatId, fileIdOrPath, opts = {}) {
    return this._call('sendPhoto', {
      chat_id: chatId,
      photo: fileIdOrPath,
      caption: opts.caption || undefined,
    });
  }

  // ═══════════════════════════════════════════════════════════
  // STICKER PACK CREATION — process images, create packs
  // ═══════════════════════════════════════════════════════════

  /**
   * Process an image buffer for use as a Telegram sticker.
   * Resizes to 512px (longest side), converts to PNG with transparent padding.
   * @param {Buffer} buffer — raw image data
   * @param {string} type — 'regular' (512px) or 'custom_emoji' (100px)
   * @returns {Promise<Buffer>} — processed PNG buffer
   */
  async _processImageForSticker(buffer, type = 'regular') {
    const sharp = (await import('sharp')).default;
    const size = type === 'custom_emoji' ? 100 : 512;
    return sharp(buffer)
      .resize(size, size, {
        fit: 'contain',
        background: { r: 0, g: 0, b: 0, alpha: 0 },
      })
      .png()
      .toBuffer();
  }

  /**
   * Convert video/GIF buffer to WEBM for Telegram video sticker.
   * Requirements: VP9, ≤3 sec, ≤256KB, 512x512 (regular) or 100x100 (emoji), no audio.
   * @param {Buffer} buffer — raw video/GIF data
   * @param {string} type — 'regular' (512px) or 'custom_emoji' (100px)
   * @returns {Promise<Buffer>} — WEBM buffer
   */
  async _processVideoForSticker(buffer, type = 'regular') {
    const { execFile } = await import('node:child_process');
    const { promisify } = await import('node:util');
    const execFileAsync = promisify(execFile);

    const size = type === 'custom_emoji' ? 100 : 512;
    const tmpDir = '/tmp/pes_stickers';
    if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true });

    const inputPath = join(tmpDir, `input_${Date.now()}.tmp`);
    const outputPath = join(tmpDir, `output_${Date.now()}.webm`);

    try {
      writeFileSync(inputPath, buffer);

      // Convert: scale to size, max 3 sec, no audio, VP9, target ≤256KB
      await execFileAsync('ffmpeg', [
        '-y', '-i', inputPath,
        '-t', '3',                          // max 3 seconds
        '-vf', `scale=${size}:${size}:force_original_aspect_ratio=decrease,pad=${size}:${size}:(ow-iw)/2:(oh-ih)/2:color=0x00000000`,
        '-c:v', 'libvpx-vp9',
        '-pix_fmt', 'yuva420p',             // alpha channel support
        '-b:v', '400k',                     // target bitrate
        '-maxrate', '500k',
        '-bufsize', '500k',
        '-an',                              // no audio
        '-auto-alt-ref', '0',               // required for alpha
        '-deadline', 'good',
        '-cpu-used', '4',
        outputPath,
      ], { timeout: 30000 });

      let webm = readFileSync(outputPath);

      // If > 256KB, re-encode with lower bitrate
      if (webm.length > 256 * 1024) {
        const lowerBitrate = Math.floor(200 * (256 * 1024) / webm.length);
        await execFileAsync('ffmpeg', [
          '-y', '-i', inputPath,
          '-t', '3',
          '-vf', `scale=${size}:${size}:force_original_aspect_ratio=decrease,pad=${size}:${size}:(ow-iw)/2:(oh-ih)/2:color=0x00000000`,
          '-c:v', 'libvpx-vp9',
          '-pix_fmt', 'yuva420p',
          '-b:v', `${lowerBitrate}k`,
          '-maxrate', `${lowerBitrate + 50}k`,
          '-bufsize', `${lowerBitrate + 50}k`,
          '-an',
          '-auto-alt-ref', '0',
          '-deadline', 'good',
          '-cpu-used', '4',
          outputPath,
        ], { timeout: 30000 });
        webm = readFileSync(outputPath);
      }

      console.log(`🎬 Video sticker: ${buffer.length} → ${webm.length} bytes (${type}, ${size}px)`);
      return webm;
    } finally {
      try { unlinkSync(inputPath); } catch (_) {}
      try { unlinkSync(outputPath); } catch (_) {}
    }
  }

  /**
   * Generate metronome click track as OGG audio.
   * Uses ffmpeg to create sine wave clicks at specified BPM.
   * @param {number} bpm — beats per minute (40-300)
   * @param {number} duration — duration in seconds (default 30)
   * @param {number} timeSignature — beats per measure for accent (default 4)
   * @returns {Promise<Buffer>} — OGG Opus audio buffer
   */
  async _generateMetronome(bpm = 120, duration = 30, timeSignature = 4) {
    const { execFile } = await import('node:child_process');
    const { promisify } = await import('node:util');
    const execFileAsync = promisify(execFile);

    bpm = Math.max(40, Math.min(300, bpm));
    duration = Math.max(5, Math.min(120, duration));

    const tmpDir = '/tmp/pes_metronome';
    if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true });

    const outputPath = join(tmpDir, `metronome_${bpm}_${Date.now()}.ogg`);

    try {
      // Single aevalsrc filter — generates clicks mathematically.
      // No matter how many beats, it's always 1 input stream.
      // Accent (beat 1 of measure): 1000Hz, louder. Others: 800Hz, softer.
      const interval = 60 / bpm;
      const clickDur = 0.02;

      // aevalsrc expression (commas escaped with \,):
      // beat = current beat index, phase = time within beat
      // is_accent = 1 if first beat of measure
      // freq = accent ? 1000 : 800, vol = accent ? 0.9 : 0.55
      const expr = [
        `if(lt(mod(t\\,${interval})\\,${clickDur})\\,`,
        `if(eq(floor(mod(t/${interval}\\,${timeSignature}))\\,0)\\,`,
        `0.9*sin(2*PI*1000*mod(t\\,${interval}))\\,`,
        `0.55*sin(2*PI*800*mod(t\\,${interval})))\\,`,
        `0)`,
      ].join('');

      await execFileAsync('ffmpeg', [
        '-y',
        '-f', 'lavfi',
        '-i', `aevalsrc=${expr}:s=48000`,
        '-t', String(duration),
        '-c:a', 'libopus',
        '-b:a', '64k',
        outputPath,
      ], { timeout: 30000 });

      const ogg = readFileSync(outputPath);
      console.log(`🎵 Metronome: ${bpm} BPM, ${duration}s, ${timeSignature}/4, ${ogg.length} bytes`);
      return ogg;
    } finally {
      try { unlinkSync(outputPath); } catch (_) {}
    }
  }

  /**
   * Send metronome audio + inline keyboard with BPM controls.
   * @param {number} bpm — beats per minute
   * @param {number} duration — duration in seconds
   */
  async _sendMetronome(bpm = 120, duration = 30) {
    try {
      await this._sendText(this.chatId, `🎵🐾 ${bpm} BPM... гав!`);

      const ogg = await this._generateMetronome(bpm, duration);

      // Send as voice with BPM controls
      const keyboard = {
        inline_keyboard: [
          [
            { text: '⏪ -20', callback_data: `metro_${bpm - 20}_${duration}` },
            { text: '◀️ -5', callback_data: `metro_${bpm - 5}_${duration}` },
            { text: `🎵 ${bpm}`, callback_data: `metro_${bpm}_${duration}` },
            { text: '▶️ +5', callback_data: `metro_${bpm + 5}_${duration}` },
            { text: '⏩ +20', callback_data: `metro_${bpm + 20}_${duration}` },
          ],
          [
            { text: '60', callback_data: `metro_60_${duration}` },
            { text: '80', callback_data: `metro_80_${duration}` },
            { text: '100', callback_data: `metro_100_${duration}` },
            { text: '120', callback_data: `metro_120_${duration}` },
            { text: '140', callback_data: `metro_140_${duration}` },
            { text: '160', callback_data: `metro_160_${duration}` },
          ],
          [
            { text: '15с', callback_data: `metro_${bpm}_15` },
            { text: '30с', callback_data: `metro_${bpm}_30` },
            { text: '60с', callback_data: `metro_${bpm}_60` },
            { text: '90с', callback_data: `metro_${bpm}_90` },
          ],
        ],
      };

      await this._callWithFile('sendVoice', {
        chat_id: this.chatId,
        reply_markup: JSON.stringify(keyboard),
        duration: duration,
      }, ogg, 'voice', `metronome_${bpm}bpm.ogg`);

    } catch (err) {
      console.error('❌ Metronome error:', err.message);
      await this._sendText(this.chatId, `ыыы... 🐾 не получилось (${err.message})`);
    }
  }

  /**
   * Upload a sticker file to Telegram.
   * @param {number} userId — Telegram user ID (owner)
   * @param {Buffer} stickerPng — processed PNG buffer
   * @param {string} stickerFormat — 'static' or 'animated'
   * @returns {Promise<Object>} — File object with file_id
   */
  async _uploadStickerFile(userId, stickerData, stickerFormat = 'static') {
    const fileName = stickerFormat === 'video' ? 'sticker.webm' : 'sticker.png';
    return this._callWithFile('uploadStickerFile', {
      user_id: userId,
      sticker_format: stickerFormat,
    }, stickerData, 'sticker', fileName);
  }

  /**
   * Create a new sticker set.
   * @param {number} userId — Telegram user ID (owner)
   * @param {string} name — sticker set name (must end with _by_<bot_username>)
   * @param {string} title — display title
   * @param {Buffer} firstStickerPng — processed PNG of first sticker
   * @param {string} emoji — emoji associated with the sticker
   * @param {string} stickerType — 'regular' or 'custom_emoji'
   * @returns {Promise<boolean>}
   */
  async _createStickerSet(userId, name, title, firstStickerData, emoji = '🐾', stickerType = 'regular', stickerFormat = 'static') {
    // First upload the sticker file
    const uploaded = await this._uploadStickerFile(userId, firstStickerData, stickerFormat);

    // Create the set with the uploaded file
    return this._call('createNewStickerSet', {
      user_id: userId,
      name,
      title,
      stickers: [{ sticker: uploaded.file_id, emoji_list: [emoji], format: stickerFormat }],
      sticker_type: stickerType,
    });
  }

  /**
   * Add a sticker to an existing sticker set.
   * @param {number} userId — Telegram user ID (owner)
   * @param {string} name — sticker set name
   * @param {Buffer} stickerPng — processed PNG buffer
   * @param {string} emoji — associated emoji
   * @returns {Promise<boolean>}
   */
  async _addStickerToSet(userId, name, stickerData, emoji = '🐾', stickerFormat = 'static') {
    const uploaded = await this._uploadStickerFile(userId, stickerData, stickerFormat);
    return this._call('addStickerToSet', {
      user_id: userId,
      name,
      sticker: { sticker: uploaded.file_id, emoji_list: [emoji], format: stickerFormat },
    });
  }

  /**
   * Handle "сделай стикер" / "создай эмодзи" / "создай пак" intent.
   * Takes a photo from the owner and creates/adds to a sticker or custom emoji pack.
   * @param {Object} msg — Telegram message
   * @param {string} createType — 'regular' (512px sticker) or 'custom_emoji' (100px emoji)
   */
  async _handleStickerCreation(msg, createType = 'regular') {
    // Need a photo, sticker, GIF, video, or animation to create a sticker
    let fileId, buffer, isSticker = false, stickerEmoji = null;
    let originalSetName = null, originalFileUniqueId = null;
    let isVideoSource = false; // GIF/video/animation → video sticker

    // 1. Direct sticker from message
    if (msg.sticker) {
      fileId = msg.sticker.file_id;
      isSticker = true;
      isVideoSource = msg.sticker.is_video || msg.sticker.is_animated || false;
      stickerEmoji = msg.sticker.emoji;
      originalSetName = msg.sticker.set_name || null;
      originalFileUniqueId = msg.sticker.file_unique_id || null;
    // 2. Reply to a sticker message
    } else if (msg.reply_to_message?.sticker) {
      const stk = msg.reply_to_message.sticker;
      fileId = stk.file_id;
      isSticker = true;
      isVideoSource = stk.is_video || stk.is_animated || false;
      stickerEmoji = stk.emoji;
      originalSetName = stk.set_name || null;
      originalFileUniqueId = stk.file_unique_id || null;
    // 3. Animation/GIF from message
    } else if (msg.animation) {
      fileId = msg.animation.file_id;
      isVideoSource = true;
    // 4. Video from message (short clips)
    } else if (msg.video && (msg.video.duration || 0) <= 10) {
      fileId = msg.video.file_id;
      isVideoSource = true;
    // 5. Reply to animation/GIF
    } else if (msg.reply_to_message?.animation) {
      fileId = msg.reply_to_message.animation.file_id;
      isVideoSource = true;
    // 6. Reply to video
    } else if (msg.reply_to_message?.video && (msg.reply_to_message.video.duration || 0) <= 10) {
      fileId = msg.reply_to_message.video.file_id;
      isVideoSource = true;
    // 7. Photo from message
    } else if (msg.photo) {
      const photo = msg.photo[msg.photo.length - 1];
      fileId = photo.file_id;
    // 8. Image document
    } else if (msg.document && msg.document.mime_type?.startsWith('image/')) {
      // GIF sent as document
      if (msg.document.mime_type === 'image/gif') {
        isVideoSource = true;
      }
      fileId = msg.document.file_id;
    // 9. Video document (MP4 etc sent as file)
    } else if (msg.document && msg.document.mime_type?.startsWith('video/')) {
      fileId = msg.document.file_id;
      isVideoSource = true;
    // 10. Reply to a photo
    } else if (msg.reply_to_message?.photo) {
      const photo = msg.reply_to_message.photo[msg.reply_to_message.photo.length - 1];
      fileId = photo.file_id;
    // 11. Reply to image/video document
    } else if (msg.reply_to_message?.document) {
      const doc = msg.reply_to_message.document;
      if (doc.mime_type?.startsWith('image/')) {
        if (doc.mime_type === 'image/gif') isVideoSource = true;
        fileId = doc.file_id;
      } else if (doc.mime_type?.startsWith('video/')) {
        fileId = doc.file_id;
        isVideoSource = true;
      }
    }

    if (!fileId) {
      await this._sendText(this.chatId, pickRandom([
        'рру?.. 📸🐾 ...тяф? (фото! стикер! гифка!)',
        'ваф! 📸 рру~ ...нужна картинка, стикер или GIF... 🐾',
      ]));
      return;
    }

    // Show "working on it" animation
    await this._sendChatAction(this.chatId, 'upload_photo');

    try {
      // Download the source
      const fileInfo = await this._getFilePath(fileId);
      buffer = await this._downloadTelegramFile(fileInfo.file_path);

      // Determine sticker format
      let stickerData, stickerFormat;
      if (isVideoSource) {
        // Video/GIF/animation → WEBM video sticker
        stickerData = await this._processVideoForSticker(buffer, createType);
        stickerFormat = 'video';
      } else {
        // Photo/image → PNG static sticker
        stickerData = await this._processImageForSticker(buffer, createType);
        stickerFormat = 'static';
      }
      const sourceDesc = isVideoSource ? 'video/GIF' : (isSticker ? 'sticker' : 'photo');
      console.log(`🎨 ${createType === 'custom_emoji' ? 'Emoji' : 'Sticker'} source: ${sourceDesc} (${stickerFormat}), size: ${buffer.length} → ${stickerData.length}`);

      // ── STICKER EDITOR: show preview + action buttons ──
      // Store pending sticker data for callback processing
      const pendingId = `stk_${Date.now()}`;
      this._pendingStickers = this._pendingStickers || {};
      this._pendingStickers[pendingId] = {
        buffer,          // original raw buffer
        stickerData,     // processed sticker data
        stickerFormat,
        createType,
        isVideoSource,
        isSticker,
        stickerEmoji,
        originalSetName,
        originalFileUniqueId,
        msg,
        createdAt: Date.now(),
      };

      // Clean up old pending stickers (>10 min)
      for (const [k, v] of Object.entries(this._pendingStickers)) {
        if (Date.now() - v.createdAt > 600000) delete this._pendingStickers[k];
      }

      // Send preview image + buttons
      const buttons = [];
      if (!isVideoSource) {
        // Static image → offer remove bg and animate
        buttons.push([
          { text: '✅ В пак', callback_data: `stk_add_${pendingId}` },
          { text: '🔲 Убрать фон', callback_data: `stk_rmbg_${pendingId}` },
        ]);
        buttons.push([
          { text: '✨ Анимировать', callback_data: `stk_anim_${pendingId}` },
        ]);
      } else {
        // Video → just add or re-encode
        buttons.push([
          { text: '✅ В пак', callback_data: `stk_add_${pendingId}` },
        ]);
      }

      // Send the processed image as preview
      try {
        if (isVideoSource) {
          // Send as video note or animation
          await this._call('sendAnimation', {
            chat_id: this.chatId,
            animation: { source: stickerData, filename: 'preview.webm' },
            caption: '🎨🐾',
            reply_markup: JSON.stringify({ inline_keyboard: buttons }),
          });
        } else {
          await this._call('sendPhoto', {
            chat_id: this.chatId,
            photo: { source: stickerData, filename: 'preview.png' },
            caption: '🎨🐾',
            reply_markup: JSON.stringify({ inline_keyboard: buttons }),
          });
        }
      } catch (previewErr) {
        // If preview fails, send text buttons instead
        console.log(`⚠️ Preview send failed: ${previewErr.message}, sending text buttons`);
        await this._sendText(this.chatId, '🎨🐾', {
          reply_markup: JSON.stringify({ inline_keyboard: buttons }),
        });
      }

      // Don't add to pack yet — wait for button callback
      this._processSmartXP(msg, 'command', 'create_sticker');
    } catch (err) {
      console.error(`⚠️ Sticker creation failed: ${err.message}`);
      await this._sendText(this.chatId, pickRandom([
        'хнн... 🎨💧🐾',
        'скууу... 😿🐾',
      ]));
    }
  }

  /**
   * Add a sticker to pack — called from sticker editor callback buttons.
   */
  async _addStickerToPack(pending, stickerData, stickerFormat) {
    const { createType, isSticker, stickerEmoji, originalSetName, originalFileUniqueId, msg, isVideoSource } = pending;

    try {
      const botInfo = await this._getMe();
      const botUsername = botInfo.username;
      const ownerId = Number(msg.from.id);
      const petName = this.pes.store?.getConfig('pet_name') || 'PES';
      const sanitizedName = petName.replace(/[^a-zA-Z0-9]/g, '').slice(0, 20) || 'PES';
      const isEmoji = createType === 'custom_emoji';
      const packPrefix = isEmoji ? 'emoji' : 'stickers';

      let packName;
      let isNewPack = false;

      if (!isEmoji && this.pes.store) {
        const mainPack = this.pes.store.getMainCollectionPack();
        if (mainPack) packName = mainPack.pack_name;
      }

      if (!packName) {
        const existingPacks = this.pes.store?.getCreatedPacks(createType) || [];
        if (existingPacks.length > 0) packName = existingPacks[0].pack_name;
      }

      if (packName) {
        try {
          const caption = msg.caption || msg.text || '';
          const emoji = stickerEmoji || this._guessEmojiForSticker(caption) || '🐾';
          await this._addStickerToSet(ownerId, packName, stickerData, emoji, stickerFormat);
          if (this.pes.store) this.pes.store.incrementPackStickerCount(packName);
        } catch (addErr) {
          console.log(`⚠️ Failed to add to pack ${packName}: ${addErr.message}`);
          if (addErr.message?.includes('STICKERS_TOO_MUCH') || addErr.message?.includes('STICKERPACK_STICKERS_TOO_MUCH')) {
            const overflowNum = (this.pes.store?.getCreatedPacks(createType) || []).length + 1;
            packName = `${sanitizedName}_${packPrefix}_${overflowNum}_by_${botUsername}`;
            isNewPack = true;
          } else {
            isNewPack = true;
            packName = `${sanitizedName}_${packPrefix}_${Date.now()}_by_${botUsername}`;
          }
        }
      } else {
        isNewPack = true;
        packName = `${sanitizedName}_${packPrefix}_by_${botUsername}`;
      }

      if (isNewPack) {
        const title = isEmoji
          ? (this._pendingPackTitle ? `${this._pendingPackTitle} ✨` : `${petName} Emoji ✨`)
          : (this._pendingPackTitle || `${petName} Stickers 🐾`);
        this._pendingPackTitle = null;
        const caption = msg.caption || msg.text || '';
        const emoji = stickerEmoji || this._guessEmojiForSticker(caption) || '🐾';
        await this._createStickerSet(ownerId, packName, title, stickerData, emoji, createType, stickerFormat);
        if (this.pes.store) {
          this.pes.store.saveCreatedPack({ pack_name: packName, title, owner_id: String(ownerId), pack_type: createType });
          this.pes.store.incrementPackStickerCount(packName);
          if (!isEmoji && !this.pes.store.getMainCollectionPack()) {
            this.pes.store.setMainCollectionPack(packName);
          }
        }
      }

      // Track origin
      if (isSticker && originalSetName && originalFileUniqueId && this.pes.store) {
        let originalSetTitle = null;
        try {
          const setInfo = await this._call('getStickerSet', { name: originalSetName });
          originalSetTitle = setInfo?.title || originalSetName;
        } catch (_) { originalSetTitle = originalSetName; }
        this.pes.store.saveStickerOrigin({
          file_unique_id: originalFileUniqueId,
          my_pack_name: packName,
          original_set_name: originalSetName,
          original_set_title: originalSetTitle,
          original_emoji: stickerEmoji || '🐾',
        });
      }

      // Success — send the actual sticker from the pack so user can save it
      await sleep(500);
      try {
        const setInfo = await this._call('getStickerSet', { name: packName });
        if (setInfo?.stickers?.length > 0) {
          // Send the last sticker (the one we just added)
          const lastSticker = setInfo.stickers[setInfo.stickers.length - 1];
          await this._call('sendSticker', {
            chat_id: this.chatId,
            sticker: lastSticker.file_id,
          });
        }
      } catch (stkErr) {
        console.log(`⚠️ Could not send sticker preview: ${stkErr.message}`);
      }

      // Reaction
      const typeLabel = isVideoSource ? '🎬' : '🎨';
      await this._sendText(this.chatId, pickRandom([
        `${typeLabel}✨🐾`,
        `${typeLabel}🎉🐾`,
        `${typeLabel}💫🐾`,
      ]));

      console.log(`${typeLabel} Sticker added to pack=${packName}, format=${stickerFormat}, isNew=${isNewPack}`);
    } catch (err) {
      console.error(`⚠️ Sticker add to pack failed: ${err.message}`);
      await this._sendText(this.chatId, pickRandom([
        'хнн... 🎨💧 🐾',
        'скууу... 😿🐾',
      ]));
    }
  }

  /**
   * Guess an appropriate emoji for a sticker based on caption text.
   * Simple keyword matching — LLM analysis can enhance later.
   */
  /**
   * Try to inject a learned custom emoji into a reply text.
   * 20% chance if custom emoji are available in the store.
   * Returns text with {emoji:ID} placeholders, or original text if no injection.
   */
  _tryInjectCustomEmoji(text) {
    if (Math.random() > 0.45) return text; // 45% chance (Premium owner!)
    if (!this.pes.store) return text;

    const customEmojis = this.pes.store.getCustomEmojiStickers({ limit: 20 });
    if (!customEmojis || customEmojis.length === 0) return text;

    // Pick a random custom emoji
    const chosen = customEmojis[Math.floor(Math.random() * customEmojis.length)];
    if (!chosen.custom_emoji_id) return text;

    // Inject at the end of the text (before trailing whitespace)
    const trimmed = text.trimEnd();
    return `${trimmed} {emoji:${chosen.custom_emoji_id}}`;
  }

  _guessEmojiForSticker(text) {
    if (!text) return null;
    const t = text.toLowerCase();
    if (/кот|кош|cat/i.test(t)) return '😺';
    if (/собак|пёс|пес|dog/i.test(t)) return '🐕';
    if (/смех|смешн|lol|хах/i.test(t)) return '😂';
    if (/грус|sad|плач/i.test(t)) return '😢';
    if (/люб|love|серд/i.test(t)) return '❤️';
    if (/еда|food|вкусн/i.test(t)) return '🍕';
    if (/огонь|fire|жар/i.test(t)) return '🔥';
    if (/крут|cool|класс/i.test(t)) return '🤩';
    return null;
  }

  /** Get updates (long polling). */
  async _getUpdates(offset, timeout = 30) {
    return this._call('getUpdates', {
      offset,
      timeout,
      allowed_updates: ['message', 'message_reaction', 'inline_query', 'callback_query'],
    });
  }

  /** Get bot info. */
  async _getMe() {
    if (!this._botInfo) {
      this._botInfo = await this._call('getMe');
    }
    return this._botInfo;
  }

  /** Set bot commands menu. */
  async _setMyCommands() {
    return this._call('setMyCommands', {
      commands: [
        { command: 'start',        description: '🐾 Запустить / разбудить ПЕС' },
        { command: 'home',         description: '🏠 Открыть дом питомца' },
        { command: 'status',       description: '📊 Статус ПЕС' },
        { command: 'setname',      description: '✏️ Дать имя ПЕС — /setname Имя' },
        { command: 'feed',         description: '🍖 Покормить данными' },
        { command: 'command',      description: '🎾 Дать команду' },
        { command: 'silent',       description: '🤫 Тихий режим' },
        { command: 'stickers',     description: '🎨 Стикерпак' },
        { command: 'files',        description: '📂 Мои файлы и фото' },
        { command: 'notes',        description: '📝 Мои заметки' },
        { command: 'remind',       description: '⏰ Напоминалка — /remind 30м купить молоко' },
        { command: 'reminders',    description: '📋 Список напоминалок' },
        { command: 'translate',    description: '📜 Перевести текст — /translate en текст' },
        { command: 'share',        description: '📤 Поделиться — /share note|status|card' },
        { command: 'emoji',        description: '✨ Emoji статус питомца' },
        { command: 'orchestrator', description: '🎯 Вызвать @orchestrator' },
        { command: 'geratron',     description: '⚡ Вызвать @geratron' },
        { command: 'dev',          description: '🔧 Dev mode' },
      ],
    });
  }

  async _setMenuButton() {
    const appUrl = this.config.miniAppUrl || 'https://crm.hltrn.cc/api/v3/pes/app';
    return this._call('setChatMenuButton', {
      menu_button: {
        type: 'web_app',
        text: '🏠 Дом',
        web_app: { url: appUrl },
      },
    });
  }


  // ═══════════════════════════════════════════════════════════
  // ABSTRACT IMPLEMENTATIONS
  // ═══════════════════════════════════════════════════════════

  /**
   * Send rendered expression to Telegram.
   * @param {Object} output — from renderExpression()
   * @returns {Promise<string|null>} — message ID
   */
  async sendMessage(output) {
    if (!output) return null;

    let lastMsgId = null;

    // "Thinking..." delay
    if (this.useThinkingDelay) {
      const delay = thinkingDelay(this.pes.level);
      if (delay > 100) {
        await this._sendChatAction(this.chatId);
        await sleep(delay);
      }
    }

    // 1. Send sticker (if available)
    if (output.sticker && typeof output.sticker === 'string' && output.sticker.length > 20) {
      // Looks like a Telegram file_id
      try {
        const msg = await this._sendSticker(this.chatId, output.sticker);
        lastMsgId = String(msg.message_id);
      } catch (_) {
        // Sticker send failed — fall through to text
      }
    }

    // 2. Build rich text: [body action] + [glyphs] + [voice] + [babble]
    const textParts = [];

    // Body action description (if no sticker was sent)
    if (!lastMsgId && output.expressionId) {
      const bodyKey = this.pes?.engine?.lastExpression?.expression?.bodyKey ||
                      output.meta?.bodyKey;
      if (bodyKey && BODY_ACTIONS[bodyKey]) {
        textParts.push(pickRandom(BODY_ACTIONS[bodyKey]));
      }
    }

    // Glyphs
    if (output.text) textParts.push(output.text);

    // Voice sound
    if (output.meta?.voiceText && !this.pes?.engine?.silentMode) {
      textParts.push(`_${output.meta.voiceText}_`);
    }

    // Dynamic babble — ALWAYS add evolving sounds (core voice of PES)
    {
      const emotion = this.pes?.emotions?.state || 'idle';
      const intensity = this.pes?.emotions?.intensity || 0.5;
      const level = this.pes?.level || 0;
      const babble = this._babble.generate(level, emotion, intensity);
      if (babble) textParts.push(babble);
    }

    if (output.meta?.caption && !textParts.length) {
      textParts.push(output.meta.caption);
    }

    const text = textParts.join(' ');
    if (text) {
      try {
        const msg = await this._sendText(this.chatId, text, { parseMode: 'Markdown' });
        lastMsgId = String(msg.message_id);
      } catch (err) {
        console.error('⚠️ sendMessage (Markdown) error:', err.message);
        // Markdown failed — try plain text
        try {
          const msg = await this._sendText(this.chatId, text.replace(/[_*]/g, ''));
          lastMsgId = String(msg.message_id);
        } catch (err2) {
          console.error('⚠️ sendMessage (plain) error:', err2.message);
        }
      }
    }

    // 2b. Track sent message for reaction feedback loop
    if (lastMsgId && output.expressionId) {
      this.trackMessage(output.expressionId, lastMsgId);
    }

    // 3. Set reaction on owner's last message (if applicable)
    if (output.reaction && this._lastOwnerMessageId) {
      try {
        await this._setReaction(this.chatId, this._lastOwnerMessageId, output.reaction);
      } catch (_) {
        // Reaction failed — not critical
      }
    }

    return lastMsgId;
  }

  /**
   * Start polling for updates from Telegram.
   */
  async startCollecting() {
    if (this._polling) return;
    this._polling = true;

    // Delete any existing webhook to ensure polling works (especially for inline queries)
    try {
      await this._call('deleteWebhook', { drop_pending_updates: false });
      console.log('🔧 Webhook deleted, polling mode active');
    } catch (_) {}

    // Set bot commands
    try { await this._setMyCommands(); } catch (_) {}

    // ── Initialize owner relationship ──
    this._initOwnerRelationship();

    // ── Load persisted context summary from DB ──
    this._loadContextSummary();

    // ── Load sticker packs from DB (not hardcoded) ──
    this._loadStickerPacksFromDB();

    // Start reminder checker
    this.startReminderChecker();

    // Start idle behavior timer
    this._startIdleTimer();

    // Start emoji status sync
    this._startEmojiStatusSync();

    this._pollLoop();
  }

  /**
   * Stop polling.
   */
  async stopCollecting() {
    this._polling = false;
    if (this._pollTimer) {
      clearTimeout(this._pollTimer);
      this._pollTimer = null;
    }
  }

  /**
   * Set presence (typing/online via chat action).
   */
  async setPresence(state) {
    if (state === PRESENCE.TYPING) {
      await this._sendChatAction(this.chatId, 'typing');
    }
    // Telegram bots don't have online/offline status
    // but we can track it internally
  }


  // ═══════════════════════════════════════════════════════════
  // POLLING LOOP
  // ═══════════════════════════════════════════════════════════

  async _pollLoop() {
    while (this._polling) {
      try {
        const updates = await this._getUpdates(this._pollOffset, 30);

        for (const update of updates) {
          this._pollOffset = update.update_id + 1;

          try {
            await this._processUpdate(update);
          } catch (err) {
            this.emit('error', err);
          }
        }
      } catch (err) {
        // Network error — retry after delay
        this.emit('error', err);
        if (this._polling) {
          await sleep(this.pollingInterval);
        }
      }
    }
  }


  // ═══════════════════════════════════════════════════════════
  // UPDATE PROCESSING
  // ═══════════════════════════════════════════════════════════

  /**
   * Route incoming Telegram update.
   */
  async _processUpdate(update) {
    // Debug: log ALL updates for diagnostics
    if (update.message?.text) {
      console.log(`📨 [DEBUG] Message from ${update.message.chat.id}: "${update.message.text.slice(0, 80)}"`);
    } else if (!update.message) {
      const keys = Object.keys(update).filter(k => k !== 'update_id');
      if (keys.length > 0) {
        console.log(`📨 Update type: ${keys.join(', ')}`, JSON.stringify(update).substring(0, 300));
      }
    }

    // Message (text, sticker, etc.)
    if (update.message) {
      const msg = update.message;

      // In standalone mode, only process messages from our chat.
      // In managed mode (PesManager), routing is already done — skip filter.
      if (!this._managed && String(msg.chat.id) !== this.chatId) return;

      // Track last owner message for reactions
      this._lastOwnerMessageId = msg.message_id;

      // Bot commands
      if (msg.text && msg.text.startsWith('/')) {
        await this._handleBotCommand(msg);
        return;
      }

      // Sticker from owner — check if "add to pack" was requested
      if (msg.sticker) {
        if (this._pendingAddToPack && Date.now() - this._pendingAddToPack < 60000) {
          const pendingType = this._pendingAddType || 'regular';
          this._pendingAddToPack = null;
          this._pendingAddType = null;
          await this._handleStickerCreation(msg, pendingType);
          this._updateRelationship('message');
          return;
        }
        await this._handleStickerMessage(msg);
        return;
      }

      // Text message
      if (msg.text) {
        await this._handleTextMessage(msg);
        return;
      }

      // Photo/document/GIF/video — check if "add to pack" was requested
      const isMediaForPack = msg.photo || msg.animation || msg.video ||
        (msg.document && (msg.document.mime_type?.startsWith('image/') || msg.document.mime_type?.startsWith('video/')));
      if (isMediaForPack && this._pendingAddToPack && Date.now() - this._pendingAddToPack < 60000) {
        const pendingType = this._pendingAddType || 'regular';
        this._pendingAddToPack = null;
        this._pendingAddType = null;
        await this._handleStickerCreation(msg, pendingType);
        this._updateRelationship('message');
        return;
      }

      // Shared contact (vCard) — auto-save
      if (msg.contact) {
        await this._handleSharedContact(msg);
        return;
      }

      // Photo/document/video/voice/audio/video_note — save and analyze
      if (msg.photo || msg.document || msg.video || msg.voice || msg.audio || msg.video_note) {
        await this._handleMediaMessage(msg);
        return;
      }
    }

    // Reaction on PES's message
    if (update.message_reaction) {
      await this._handleReaction(update.message_reaction);
    }

    // Inline query — show sticker collection in any chat
    if (update.inline_query) {
      await this._handleInlineQuery(update.inline_query);
    }

    // Callback query — inline keyboard button presses (metronome BPM, etc.)
    if (update.callback_query) {
      await this._handleCallbackQuery(update.callback_query);
    }
  }

  /**
   * Handle inline keyboard callback queries (button presses).
   */
  async _handleCallbackQuery(query) {
    const data = query.data || '';

    // Metronome BPM control: metro_{bpm}_{duration}
    const metroMatch = data.match(/^metro_(\d+)_(\d+)$/);
    if (metroMatch) {
      const bpm = Math.max(40, Math.min(300, parseInt(metroMatch[1])));
      const duration = Math.max(5, Math.min(120, parseInt(metroMatch[2])));

      await this._call('answerCallbackQuery', {
        callback_query_id: query.id,
        text: `🎵 ${bpm} BPM`,
      }).catch(() => {});

      await this._sendMetronome(bpm, duration);
      return;
    }

    // ── Sticker editor callbacks ──
    const stkMatch = data.match(/^stk_(add|rmbg|anim)_(stk_\d+)$/);
    if (stkMatch) {
      const action = stkMatch[1];
      const pendingId = stkMatch[2];
      const pending = this._pendingStickers?.[pendingId];

      if (!pending) {
        await this._call('answerCallbackQuery', {
          callback_query_id: query.id,
          text: 'рру?.. 🐾 (истекло)',
          show_alert: false,
        }).catch(() => {});
        return;
      }

      await this._call('answerCallbackQuery', {
        callback_query_id: query.id,
        text: action === 'add' ? '✅ 🐾' : action === 'rmbg' ? '🔲 🐾' : '✨ 🐾',
      }).catch(() => {});

      // Remove buttons from preview message
      try {
        await this._call('editMessageReplyMarkup', {
          chat_id: this.chatId,
          message_id: query.message.message_id,
          reply_markup: JSON.stringify({ inline_keyboard: [] }),
        });
      } catch (_) {}

      await this._sendChatAction(this.chatId, 'upload_photo');

      let finalData = pending.stickerData;
      let finalFormat = pending.stickerFormat;

      if (action === 'rmbg') {
        // Remove background using sharp — make light/white areas transparent
        try {
          const sharp = (await import('sharp')).default;
          const size = pending.createType === 'custom_emoji' ? 100 : 512;

          // Extract alpha: remove background by making near-white pixels transparent
          const raw = await sharp(pending.buffer)
            .resize(size, size, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
            .ensureAlpha()
            .raw()
            .toBuffer({ resolveWithObject: true });

          const pixels = raw.data;
          const { width, height } = raw.info;

          // Make light pixels transparent (threshold-based bg removal)
          for (let i = 0; i < pixels.length; i += 4) {
            const r = pixels[i], g = pixels[i + 1], b = pixels[i + 2];
            const brightness = (r + g + b) / 3;
            // If pixel is very light (near white), make transparent
            if (brightness > 220 && Math.abs(r - g) < 30 && Math.abs(g - b) < 30) {
              pixels[i + 3] = 0; // alpha = 0
            }
            // Edge softening for medium-light pixels
            else if (brightness > 190 && Math.abs(r - g) < 40 && Math.abs(g - b) < 40) {
              pixels[i + 3] = Math.floor(pixels[i + 3] * (220 - brightness) / 30);
            }
          }

          finalData = await sharp(pixels, { raw: { width, height, channels: 4 } })
            .png()
            .toBuffer();

          console.log(`🔲 Background removed: ${pending.stickerData.length} → ${finalData.length}`);
        } catch (bgErr) {
          console.error(`⚠️ BG removal failed: ${bgErr.message}`);
          // Fall back to original processed data
          finalData = pending.stickerData;
        }
      } else if (action === 'anim') {
        // Animate: create a simple zoom/pulse animation from static image
        try {
          const { execFile } = await import('node:child_process');
          const { promisify } = await import('node:util');
          const execFileAsync = promisify(execFile);

          const tmpDir = '/tmp/pes_stickers';
          if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true });

          const inputPath = join(tmpDir, `anim_in_${Date.now()}.png`);
          const outputPath = join(tmpDir, `anim_out_${Date.now()}.webm`);

          writeFileSync(inputPath, pending.stickerData);

          const size = pending.createType === 'custom_emoji' ? 100 : 512;

          // Create pulse/zoom animation: 3 sec, zooms in slightly then back
          await execFileAsync('ffmpeg', [
            '-y',
            '-loop', '1', '-i', inputPath,
            '-t', '3',
            '-vf', [
              `scale=${size}:${size}:force_original_aspect_ratio=decrease`,
              `pad=${size}:${size}:(ow-iw)/2:(oh-ih)/2:color=0x00000000`,
              `zoompan=z='1+0.15*sin(2*PI*t/1.5)':d=75:s=${size}x${size}:fps=25`,
            ].join(','),
            '-c:v', 'libvpx-vp9',
            '-pix_fmt', 'yuva420p',
            '-b:v', '300k',
            '-an',
            '-auto-alt-ref', '0',
            '-deadline', 'good',
            '-cpu-used', '4',
            outputPath,
          ], { timeout: 30000 });

          let webm = readFileSync(outputPath);

          // Re-encode if too large
          if (webm.length > 256 * 1024) {
            const lowerBr = Math.floor(150 * (256 * 1024) / webm.length);
            await execFileAsync('ffmpeg', [
              '-y',
              '-loop', '1', '-i', inputPath,
              '-t', '3',
              '-vf', `scale=${size}:${size}:force_original_aspect_ratio=decrease,pad=${size}:${size}:(ow-iw)/2:(oh-ih)/2:color=0x00000000,zoompan=z='1+0.15*sin(2*PI*t/1.5)':d=75:s=${size}x${size}:fps=25`,
              '-c:v', 'libvpx-vp9', '-pix_fmt', 'yuva420p',
              '-b:v', `${lowerBr}k`, '-an', '-auto-alt-ref', '0',
              '-deadline', 'good', '-cpu-used', '4',
              outputPath,
            ], { timeout: 30000 });
            webm = readFileSync(outputPath);
          }

          finalData = webm;
          finalFormat = 'video';

          try { unlinkSync(inputPath); } catch (_) {}
          try { unlinkSync(outputPath); } catch (_) {}

          console.log(`✨ Animated sticker: ${pending.stickerData.length} → ${finalData.length}`);
        } catch (animErr) {
          console.error(`⚠️ Animation failed: ${animErr.message}`);
          finalData = pending.stickerData;
        }
      }

      // Now add to pack (reuse logic from _handleStickerCreation)
      await this._addStickerToPack(pending, finalData, finalFormat);

      // Clean up
      delete this._pendingStickers[pendingId];
      return;
    }

    // ── Share callbacks ──
    if (data.startsWith('share_')) {
      await this._call('answerCallbackQuery', {
        callback_query_id: query.id,
      }).catch(() => {});

      switch (data) {
        case 'share_status':    return this._shareStatus();
        case 'share_card':      return this._sharePetCard();
        case 'share_last_note': return this._shareNote('');
        case 'share_summary':   return this._shareSummary();
      }
      return;
    }

    // ── Workflow callbacks ──
    if (data.startsWith('wf_run_')) {
      const workflowId = data.replace('wf_run_', '');
      await this._call('answerCallbackQuery', {
        callback_query_id: query.id,
        text: `▶️ ${workflowId}...`,
      }).catch(() => {});
      await this._cmdWorkflow({ chat: { id: this.chatId } }, workflowId);
      return;
    }

    if (data === 'wf_history') {
      await this._call('answerCallbackQuery', {
        callback_query_id: query.id,
      }).catch(() => {});
      await this._cmdWorkflow({ chat: { id: this.chatId } }, 'history');
      return;
    }

    // ── Friendship callbacks ──
    const friendMatch = data.match(/^friend_(accept|reject)_(\d+)$/);
    if (friendMatch) {
      const action = friendMatch[1];
      const fromChatId = friendMatch[2];
      await this._call('answerCallbackQuery', {
        callback_query_id: query.id,
        text: action === 'accept' ? '🤝 Принято!' : '❌ Отклонено',
      }).catch(() => {});

      try {
        await this._call('editMessageReplyMarkup', {
          chat_id: this.chatId,
          message_id: query.message.message_id,
          reply_markup: JSON.stringify({ inline_keyboard: [] }),
        });
      } catch (_) {}

      if (action === 'accept') {
        this.pes.store.acceptFriendRequest(fromChatId);
        const friendship = this.pes.store.getFriendship(fromChatId);
        const petName = friendship?.friend_pet_name || 'ПЕС';
        await this._sendText(this.chatId, `🤝 ${this.pes.name} теперь друг с ${petName}! 🐾♡`);
        // Notify the requester
        try {
          await this._sendText(fromChatId, `🤝 ${petName} принял дружбу от ${this.pes.name}! Теперь вы друзья! 🐾♡`);
        } catch (_) {}
        // Mood boost
        if (this.pes.emotions) {
          this.pes.emotions.mood = Math.min(1.0, (this.pes.emotions.mood || 0.5) + 0.1);
        }
      } else {
        this.pes.store.rejectFriendRequest(fromChatId);
        await this._sendText(this.chatId, `❌ Запрос на дружбу отклонён.`);
      }
      return;
    }

    // ── Gift accept callback ──
    const giftMatch = data.match(/^gift_thanks_(\d+)$/);
    if (giftMatch) {
      await this._call('answerCallbackQuery', {
        callback_query_id: query.id,
        text: '💛 Спасибо!',
      }).catch(() => {});
      try {
        await this._call('editMessageReplyMarkup', {
          chat_id: this.chatId,
          message_id: query.message.message_id,
          reply_markup: JSON.stringify({ inline_keyboard: [] }),
        });
      } catch (_) {}
      return;
    }

    // Unknown callback — just answer to dismiss
    await this._call('answerCallbackQuery', {
      callback_query_id: query.id,
    }).catch(() => {});
  }


  // ═══════════════════════════════════════════════════════════
  // MESSAGE HANDLERS
  // ═══════════════════════════════════════════════════════════

  /**
   * Handle text message from owner.
   * Matches keywords → triggers PES events.
   */
  async _handleTextMessage(msg) {
    const text = msg.text.trim();

    // Track owner activity for idle behavior
    this._lastOwnerMessageTime = Date.now();

    // Dev mode or agent mode: all text goes to log instead of PES
    if (this._devMode) {
      return this._logDevRequest('message', text, msg);
    }
    if (this._agentMode) {
      await this._logDevRequest(`@${this._agentMode}`, text, msg);
      // Live orchestrator chat — real AI responses
      if (this._agentMode === 'orchestrator' && this._orchestratorLLM) {
        await this._handleOrchestratorChat(text, msg);
        return;
      }
      const label = this._agentMode === 'orchestrator' ? '🎯' : '⚡';
      await this._sendText(this.chatId, `${label} @${this._agentMode} получил: «${text.slice(0, 200)}»\n\n_Записано в лог._`, { parse_mode: 'Markdown' });
      return;
    }

    // ── Shadow Orchestrator: always observe, respond on trigger ──
    // Buffer every message for context (regardless of LLM availability)
    this._shadowBuffer.push({ role: 'user', content: text, ts: Date.now() });
    if (this._shadowBuffer.length > this._shadowBufferLimit) {
      this._shadowBuffer = this._shadowBuffer.slice(-this._shadowBufferLimit);
    }

    // Check N23 / trigger keywords — BEFORE any other handler
    if (this._shadowTriggers.test(text)) {
      if (this._orchestratorLLM) {
        console.log(`🎯 Shadow Orchestrator triggered by: "${text.slice(0, 50)}"`);
        await this._handleShadowOrchestratorCall(text, msg);
        return;
      } else {
        console.log(`⚠️ Shadow trigger matched but no _orchestratorLLM available`);
      }
    }

    // ── Check pending mirror sticker (delayed "try back") ──
    this._tryMirrorSticker().catch(err =>
      console.error('⚠️ Mirror sticker error:', err.message)
    );

    // ── Check for sticker/emoji/gif creation intent ──
    const stickerCreateMatch = /^(сделай стикер|создай стикер|стикер из|сделай пак|создай пак|make sticker|create sticker|добавь стикер|добавь в пак|add sticker|add to pack|сделай гифку|сделай gif|создай гифку|gif стикер|гиф стикер|видео стикер|video sticker)/i.test(text);
    const emojiCreateMatch = /^(сделай эмодзи|создай эмодзи|сделай эмоджи|создай эмоджи|сделай emoji|создай emoji|make emoji|create emoji|эмодзи из|эмоджи из)/i.test(text);
    const hasMediaSource = msg.photo || msg.animation || msg.video ||
      (msg.document && (msg.document.mime_type?.startsWith('image/') || msg.document.mime_type?.startsWith('video/'))) ||
      msg.reply_to_message?.sticker || msg.reply_to_message?.photo || msg.reply_to_message?.animation || msg.reply_to_message?.video ||
      (msg.reply_to_message?.document && (msg.reply_to_message.document.mime_type?.startsWith('image/') || msg.reply_to_message.document.mime_type?.startsWith('video/')));
    const captionMatch = (msg.photo || msg.animation || msg.video || (msg.document && (msg.document.mime_type?.startsWith('image/') || msg.document.mime_type?.startsWith('video/')))) && /стикер|sticker|пак|pack|эмодзи|эмоджи|emoji|гифк|gif/i.test(msg.caption || '');
    const captionIsEmoji = captionMatch && /эмодзи|эмоджи|emoji/i.test(msg.caption || '');

    // "добавь в пак" + foreign sticker → physically add to pack + save origin
    // "сохрани" → collection bookmark (separate flow)

    if (stickerCreateMatch || emojiCreateMatch || captionMatch) {
      const createType = (emojiCreateMatch || captionIsEmoji) ? 'custom_emoji' : 'regular';
      if (hasMediaSource) {
        await this._handleStickerCreation(msg, createType);
        this._updateRelationship('message');
        return;
      }
      // No media — set pending flag, ask user to send sticker/photo/GIF
      this._pendingAddToPack = Date.now();
      this._pendingAddType = createType;
      await this._sendText(this.chatId, pickRandom([
        'тяф! 🎨🐾 ...жду стикер, фото или GIF! 📸',
        'ваф! 🖌️🐾 ...пришли стикер, картинку или гифку! ✨',
        'рру~~ 🎨 ...давай! стикер! фото! GIF! 🐾',
      ]));
      return;
    }

    // ── Check for sticker COLLECTION intent (reply to sticker + "сохрани"/"в коллекцию") ──
    const collectionSaveMatch = /^(сохрани|в коллекцию|добавь в коллекцию|save|collect|bookmark)/i.test(text);
    const collectionRemoveMatch = /^(убери из коллекции|удали из коллекции|remove from collection)/i.test(text);
    if ((collectionSaveMatch || collectionRemoveMatch) && msg.reply_to_message?.sticker && this.pes.store) {
      const sticker = msg.reply_to_message.sticker;
      if (collectionRemoveMatch) {
        await this._removeFromCollection(msg, sticker);
      } else {
        await this._addToCollection(msg, sticker);
      }
      return;
    }

    // ── Check for translation intent ──
    const translateMatch = text.match(/^(переведи|translate|перевод)\s+(на\s+)?(английский|english|англ|испанский|spanish|исп|немецкий|german|нем|французский|french|фр|китайский|chinese|кит|японский|japanese|яп|корейский|korean|кор|арабский|arabic|араб|итальянский|italian|итал|португальский|portuguese|порт|турецкий|turkish|тур|русский|russian|рус)\s*[:\s]+(.+)/i);
    const translateMatch2 = text.match(/^(переведи|translate|перевод)\s*[:\s]+(.+)/i);
    if (translateMatch || translateMatch2) {
      const targetLang = translateMatch ? translateMatch[3] : null;
      const sourceText = translateMatch ? translateMatch[4] : translateMatch2[2];
      await this._handleTranslation(sourceText.trim(), targetLang?.trim() || 'английский');
      await this._processSmartXP(msg, 'command', 'translate');
      this._updateRelationship('message');
      return;
    }

    // ── Check for metronome intent ──
    const metronomeMatch = text.match(/^(метроном|metronome|темп|tempo)\s*(\d+)?\s*(\d+[смmс]?\w*)?/i);
    if (metronomeMatch) {
      const bpm = metronomeMatch[2] ? parseInt(metronomeMatch[2]) : 120;
      let duration = 30;
      if (metronomeMatch[3]) {
        const durMatch = metronomeMatch[3].match(/^(\d+)(мин|m|min)?/i);
        if (durMatch) {
          duration = parseInt(durMatch[1]);
          if (durMatch[2]) duration *= 60;
        }
      }
      await this._sendMetronome(Math.max(40, Math.min(300, bpm)), Math.max(5, Math.min(120, duration)));
      await this._processSmartXP(msg, 'command', 'metronome');
      this._updateRelationship('message');
      return;
    }

    // ── Check for note-saving intent ──
    const noteMatch = text.match(/^(запомни|запиши|сохрани|заметка)[:\s]+(.+)/i);
    const noteSearchMatch = text.match(/^(что ты помнишь|что помнишь|что знаешь|вспомни)\s*(про|о|об)?\s*(.+)/i);

    if (noteMatch && this.pes.store) {
      const noteText = noteMatch[2].trim();
      const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from.id);

      // Auto-tag via simple keyword extraction
      const tags = noteText
        .replace(/[^\wа-яА-ЯёЁ\s]/g, '')
        .split(/\s+/)
        .filter(w => w.length > 2)
        .slice(0, 10);

      // Check for "важно" → pinned
      const pinned = /важно|навсегда|не забудь/i.test(text);

      // Detect date/time in the note → set remind_at
      const remindAt = this._extractDateTimeFromNote(noteText);

      const saved = this.pes.store.saveNote({
        owner_id: ownerId,
        text: noteText,
        tags,
        category: this._guessNoteCategory(noteText),
        pinned,
        source_message_id: msg.message_id,
        remind_at: remindAt,
      });

      if (remindAt) {
        await this._sendText(this.chatId, pickRandom([
          `ваф! 📝🐾 рру~ ⏰`,
          `тяф! 📝 ♡ рру~~ ⏰`,
          `гав! 📝🐾 ррФФ~ ⏰`,
        ]));
      } else {
        await this._sendText(this.chatId, pickRandom([
          `ваф! 📝🐾${pinned ? ' 📌' : ''} рру~`,
          `тяф! 📝 ♡${pinned ? ' 📌' : ''} рру~~`,
          `гав! 📝🐾${pinned ? ' 📌' : ''} ррФФ~`,
        ]));
      }
      this._addToMemory('owner', text);
      this._addToMemory('pes', `[запомнил: ${noteText}${remindAt ? ` → принесу ${this._formatReminderTime(remindAt)}` : ''}]`);
      await this._processSmartXP(msg, 'note', 'note');
      this._updateRelationship('message');
      return;
    }

    if (noteSearchMatch && this.pes.store) {
      const query = noteSearchMatch[3].trim();
      const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from.id);
      const notes = this.pes.store.searchNotes(query, { owner_id: ownerId, limit: 5 });

      if (notes.length === 0) {
        await this._sendText(this.chatId, pickRandom([
          `скууу... ыыы... рру?.. 💧`,
          `рру?... ...ууу... хнн... 💧`,
        ]));
      } else {
        // Dog "brings" the notes — sounds first, then data
        await this._sendText(this.chatId, pickRandom([
          `ваф! 📝🐾 рру!!`,
          `тяф тяф! 📝 ррРР!! 🐾`,
        ]));
        const lines = [];
        for (const n of notes) {
          lines.push(`${n.pinned ? '📌 ' : ''}• ${n.text}`);
        }
        await this._sendText(this.chatId, lines.join('\n'));
      }
      this._addToMemory('owner', `[спросил: что помнишь про ${query}]`);
      this._addToMemory('pes', `[нашёл ${notes.length} заметок про ${query}]`);
      await this._processSmartXP(msg, 'text');
      this._updateRelationship('message');
      return;
    }

    // ── Check for contact-saving intent ──
    const contactSaveMatch = text.match(/^(запомни контакт|добавь контакт|сохрани контакт|новый контакт|add contact)[:\s]+(.+)/i);
    const contactQueryMatch = text.match(/^(кто такой|кто такая|кто это|who is)\s+(.+)/i);

    if (contactSaveMatch && this.pes.store) {
      const contactStr = contactSaveMatch[2].trim();
      await this._parseAndSaveContact(msg, contactStr);
      return;
    }

    if (contactQueryMatch && this.pes.store) {
      const query = contactQueryMatch[2].trim().replace(/[?？]$/, '');
      await this._searchAndShowContact(msg, query);
      return;
    }

    // ── Check for reminder intent ──
    const reminderIntent = await this._detectReminderIntent(text);
    if (reminderIntent && this.pes.store) {
      this.pes.store.createReminder(reminderIntent.text, reminderIntent.remindAt);
      const timeStr = this._formatReminderTime(reminderIntent.remindAt);
      await this._sendText(this.chatId, pickRandom([
        `ваф! 📋🐾 рру~ ⏰`,
        `тяф! 📋 рру~~ ⏰ 🐾`,
        `гав! 📋🐾 ррФФ~ ⏰`,
      ]));
      this._addToMemory('owner', text);
      this._addToMemory('pes', `[напоминалка: ${reminderIntent.text} — ${timeStr}]`);
      return; // Don't process as normal message
    }

    // ── CRM Bridge v2: bidirectional CRM access through chat ──
    if (this._crm) {
      const crmHandled = await this._handleCrmIntent(msg, text);
      if (crmHandled) return;
    }

    // ── Detect keyword category for PES event triggering ──
    let detectedCategory = null;
    let detectedKw = null;
    for (const [category, kw] of Object.entries(KEYWORDS)) {
      if (kw.patterns.some(p => p.test(text))) {
        detectedCategory = category;
        detectedKw = kw;
        break;
      }
    }

    // ── Extract and learn emojis from owner's message ──
    this._extractAndLearnEmojis(text, true);

    // ── Extract and learn custom emoji from message entities ──
    if (msg.entities) {
      this._extractAndLearnCustomEmojis(msg.entities);
    }

    // ── File search intent ──
    if (detectedKw && detectedKw.action === 'file_search') {
      await this._handleFileSearch(text);
      await this._processSmartXP(msg, 'text');
      this._updateRelationship('message');
      return;
    }

    // ── LLM Intent Router: when no specific regex matched ──
    // Keywords like greetings/praise/scold still go to generic reply path
    // But unrecognized text → LLM classifies → routes to handler
    if (!detectedKw || !detectedKw.action || detectedKw.action === 'command') {
      try {
        const intent = await this._classifyIntent(text);
        if (intent && intent.intent !== 'none') {
          const handled = await this._routeIntent(msg, intent);
          if (handled) {
            // Still do emoji learning + patterns + XP
            this._extractAndLearnEmojis(text, true);
            if (msg.entities) this._extractAndLearnCustomEmojis(msg.entities);
            await this._processSmartXP(msg, 'text', intent.intent);
            this._updateRelationship('message');
            this._observeInteractionPatterns(text, null);
            return;
          }
        }
      } catch (err) {
        console.error('⚠️ LLM router error:', err.message);
        // Fall through to generic reply
      }
    }

    // ── React to owner's message (proactive emoji reaction) ──
    this._reactToOwnerMessage(msg, detectedCategory).catch(() => {});

    // ── Imprint: positive reaction = хозяин доволен предыдущим звуком ──
    if (detectedCategory === 'praise' || detectedCategory === 'greetings') {
      const boost = detectedCategory === 'praise' ? 0.5 : 0.2;
      this._babble.imprint(this._lastPesReply, boost);
      this._saveBabbleState();
    }

    // ── Generate reply via LLM (or fallback to templates) ──
    await this._sendChatAction(this.chatId);
    await sleep(thinkingDelay(this.pes.level));

    const reply = await this._generateReply(text, detectedCategory);
    console.log(`💬 Reply to owner: "${reply.slice(0, 100)}"`);

    // ── v4: Smart response composition ──
    // Decide response pattern: sticker-first, text-first, text-only, sticker-only
    const responsePattern = this._pickResponsePattern(detectedCategory);

    if (responsePattern === 'sticker_first') {
      // Sticker → pause → babble text
      await this._sendContextualSticker(detectedCategory);
      await sleep(300 + Math.random() * 500);
      const enrichedReply = this._tryInjectCustomEmoji(reply);
      if (enrichedReply !== reply) {
        await this._sendTextWithCustomEmoji(this.chatId, enrichedReply);
      } else {
        await this._sendText(this.chatId, reply);
      }
    } else if (responsePattern === 'sticker_only') {
      // Only sticker — for very emotional moments (zoomies, greeting_frenzy)
      await this._sendContextualSticker(detectedCategory);
    } else if (responsePattern === 'text_then_sticker') {
      // Text → sticker (classic flow)
      const enrichedReply = this._tryInjectCustomEmoji(reply);
      if (enrichedReply !== reply) {
        await this._sendTextWithCustomEmoji(this.chatId, enrichedReply);
      } else {
        await this._sendText(this.chatId, reply);
      }
      await this._sendContextualSticker(detectedCategory);
    } else {
      // Text only — most common, clean
      const enrichedReply = this._tryInjectCustomEmoji(reply);
      if (enrichedReply !== reply) {
        await this._sendTextWithCustomEmoji(this.chatId, enrichedReply);
      } else {
        await this._sendText(this.chatId, reply);
      }
      // 25% chance of follow-up sticker for flavor
      if (Math.random() < 0.25) {
        await this._sendContextualSticker(detectedCategory);
      }
    }

    // ── Track last bot action for reaction memory ──
    this._lastBotAction = {
      action: detectedCategory || 'reply',
      text: reply.slice(0, 200),
      category: detectedCategory,
      timestamp: Date.now(),
    };

    // ── Save to short memory ──
    this._addToMemory('owner', text);
    this._addToMemory('pes', reply);

    // ── Persist babble state (combos, momentum) ──
    this._saveBabbleState();

    // ── Trigger PES event based on keyword ──
    if (detectedKw) {
      if (detectedKw.event) {
        this.pes.event(detectedKw.event);
      } else if (detectedKw.action === 'praise') {
        this.pes.praise(text);
        this._logReactionToLastAction('praise', text, 1.0);
        await this._grantXp('praise', 3);
        this._updateRelationship('praise');
      } else if (detectedKw.action === 'scold') {
        this.pes.scold(text);
        this._logReactionToLastAction('scold', text, -1.0);
        this._updateRelationship('scold');
      } else if (detectedKw.action === 'command' && detectedKw.command === 'fetch') {
        const target = text.replace(detectedKw.patterns[0], '').trim();
        await this._handleFetch(target || 'мячик');
      } else if (detectedKw.action === 'command') {
        const args = text.replace(detectedKw.patterns[0], '').trim();
        this.pes.command(detectedKw.command, { target: args || undefined });
      } else if (detectedKw.action === 'workflow') {
        await this._cmdWorkflow(msg, detectedKw.command);
      } else if (detectedKw.action === 'status') {
        await this._sendStatus();
      } else if (detectedKw.action === 'feed') {
        const content = text.replace(detectedKw.patterns[0], '').trim();
        this.pes.feed({ type: 'text', content });
      }
    } else {
      this.pes.event({
        type: 'message',
        from: 'owner',
        content: text,
        sentiment: 'neutral',
      });
    }

    // Smart XP for every message from owner (dynamic based on quality)
    await this._processSmartXP(msg, 'text', detectedKw?.action);

    // Update owner relationship
    this._updateRelationship('message');

    // Observe interaction patterns — drives sticker discovery
    this._observeInteractionPatterns(text, detectedKw);

    // Proactive insights — share observations (max 1/day, 15% chance)
    this._tryProactiveInsight().catch(err =>
      console.error('⚠️ Proactive insight error:', err.message)
    );

    // Check if there are upcoming note reminders to "bring" contextually
    this._checkContextualReminders().catch(err =>
      console.error('⚠️ Contextual reminder check error:', err.message)
    );
  }

  /**
   * Generate reply — BABBLE-FIRST architecture.
   *
   * v1: LLM generates text → strip human words → fallback to babble
   * v2: LLM classifies emotion → babble generates sounds with phonetic echo
   *
   * LLM is used ONLY for emotion/context classification.
   * Babble Engine is the CORE sound generator — no patches, no stripping.
   *
   * @param {string} ownerText — owner's message
   * @param {string|null} category — detected keyword category
   * @returns {Promise<string>}
   */
  async _generateReply(ownerText, category) {
    // Update babble engine with current traits and owner emoji
    this._updateBabbleContext();

    const level = this.pes?.level || 0;
    let emotion = this.pes?.emotions?.state || 'idle';
    let intensity = this.pes?.emotions?.intensity || 0.5;

    // ── Step 1: LLM classifies emotion/context (NOT generate text) ──
    if (this._llm && category !== 'greetings' && category !== 'praise' && category !== 'scold' && category !== 'feed') {
      try {
        const classifyPrompt = `Ты анализируешь сообщение хозяина для животного (ПЕС).
Определи ЭМОЦИЮ которую ПЕС должен выразить в ответ и её ИНТЕНСИВНОСТЬ.
Ответь ТОЛЬКО JSON: {"emotion": "...", "intensity": 0.0-1.0}

Доступные эмоции: happy, playful, excited, content, idle, curious, hungry, sad, lonely, scared, anxious, angry, alert, bark, nap, sleep, greeting_frenzy, butt_wiggle, zoomies, food_obsessed, dramatic_tantrum, sulking, stubborn_refuse, puzzle_solving

Контекст:
- Текущая эмоция ПЕС: ${emotion}
- Уровень: ${level}
- Настроение: ${Math.round((this.pes?.emotions?.mood || 0.5) * 100)}%`;

        const classified = await this._llm.classify(classifyPrompt, ownerText);
        if (classified?.emotion && EMOTION_INSTRUMENTS_SET.has(classified.emotion)) {
          emotion = classified.emotion;
          intensity = Math.max(0.1, Math.min(1.0, classified.intensity || 0.5));
        }
      } catch (err) {
        console.error('⚠️ LLM classify error:', err.message);
        // Use current PES emotion — no problem
      }
    }

    // ── Step 2: Babble Engine generates sounds (CORE) ──
    // v4: Context-aware generation with blends and after-silence

    let reply;

    // Check if owner just returned after silence
    const silenceMin = this._lastOwnerMessageTime
      ? (Date.now() - this._lastOwnerMessageTime) / 60000
      : 0;

    if (category === 'greetings' && silenceMin > 30 && this._babble.generateAfterSilence) {
      // Owner returned after long absence — special greeting
      reply = this._babble.generateAfterSilence(level, silenceMin, emotion);
    } else if (this.pes?.emotions) {
      // v4: Try emotion blend (current PES state + LLM-classified emotion)
      const pesEmotion = this.pes.emotions.state;
      if (pesEmotion !== emotion && this._babble.generateBlended && Math.random() < 0.3) {
        reply = this._babble.generateBlended(level, pesEmotion, emotion, intensity);
      } else {
        reply = this._babble.generateEnhanced(level, emotion, intensity, ownerText);
      }
    } else {
      reply = this._babble.generateEnhanced(level, emotion, intensity, ownerText);
    }

    // Track last reply for imprinting
    this._lastPesReply = reply;

    return reply;
  }

  /**
   * Send a sticker that matches the emotional context.
   * Uses preference_score + freshness boost + tag-matching from DB.
   * NO random stickers — only contextually relevant ones.
   * @param {string|null} category — detected keyword category
   */
  /**
   * v4: Pick response pattern — how to combine sticker + text + reaction.
   * Based on emotion, energy, category, and randomness.
   */
  _pickResponsePattern(category) {
    const emotion = this.pes?.emotions?.state || 'idle';
    const energy = this.pes?.emotions?.energy || 0.5;
    const intensity = this.pes?.emotions?.intensity || 0.5;

    // High-energy emotional moments → sticker first or sticker only
    if (['greeting_frenzy', 'zoomies', 'play_bow'].includes(emotion) && intensity > 0.7) {
      return Math.random() < 0.3 ? 'sticker_only' : 'sticker_first';
    }

    // Greetings/praise → sticker first (excited dog runs to you first, then barks)
    if (category === 'greetings' || category === 'praise') {
      return Math.random() < 0.5 ? 'sticker_first' : 'text_then_sticker';
    }

    // Scared/sad → text only (quiet, no sticker spam)
    if (['scared', 'sad', 'lonely', 'anxious', 'sulking'].includes(emotion)) {
      return 'text_only';
    }

    // Low energy → mostly text
    if (energy < 0.3) {
      return Math.random() < 0.85 ? 'text_only' : 'text_then_sticker';
    }

    // Normal flow — weighted random
    const r = Math.random();
    if (r < 0.45) return 'text_only';
    if (r < 0.70) return 'text_then_sticker';
    if (r < 0.90) return 'sticker_first';
    return 'sticker_only';
  }

  async _sendContextualSticker(category) {
    if (!this._stickerFileIds || this._stickerFileIds.length === 0) return;

    // Map category to emotion for sticker selection
    const emotionMap = {
      greetings: ['happy', 'excited', 'playful'],
      praise: ['happy', 'excited', 'trust'],
      scold: ['sad', 'scared', 'submissive'],
      feed: ['happy', 'excited', 'food_obsessed'],
      play: ['playful', 'zoomies', 'excited'],
      status: ['curious', 'interested'],
      excited: ['excited', 'happy', 'playful'],
    };

    const targetEmotions = emotionMap[category] || null;

    // ── EXPLORATION MODE: 30% chance to pick from loaded packs (not just DB) ──
    // This helps PES discover new stickers and not get stuck on favorites
    if (Math.random() < 0.3 && this._stickerFileIds && this._stickerFileIds.length > 0) {
      // Try emotion-matched from loaded packs first
      let explored = null;
      if (targetEmotions && this._stickerEmotionIndex) {
        for (const emotion of targetEmotions) {
          const stickers = this._stickerEmotionIndex[emotion];
          if (stickers && stickers.length > 0) {
            // Filter out recently sent
            const fresh = stickers.filter(s => !this._recentSentStickers.includes(s));
            explored = fresh.length > 0 ? pickRandom(fresh) : pickRandom(stickers);
            break;
          }
        }
      }
      // No emotion match — pick any random sticker from full pool
      if (!explored) {
        const fresh = this._stickerFileIds.filter(s => !this._recentSentStickers.includes(s));
        explored = fresh.length > 0 ? pickRandom(fresh) : pickRandom(this._stickerFileIds);
      }
      if (explored) {
        try {
          await this._sendSticker(this.chatId, explored);
          this._recentSentStickers.push(explored);
          if (this._recentSentStickers.length > 10) this._recentSentStickers.shift();
          return;
        } catch (_) {}
      }
    }

    // ── DB-ranked stickers with DIVERSITY enforcement ──
    if (this.pes.store && targetEmotions) {
      for (const emotion of targetEmotions) {
        const ranked = this.pes.store.getStickersByRelevance({ emotion_key: emotion, limit: 10 });
        if (ranked.length > 0) {
          // Weighted random with anti-repeat penalty
          const weights = ranked.map(s => {
            let w = Math.max(0.1, (s.preference_score || 0) + (s.freshness_boost || 1) + 1);
            // Penalize recently sent stickers (×0.15 weight)
            if (this._recentSentStickers.includes(s.file_unique_id) || this._recentSentStickers.includes(s.file_id)) {
              w *= 0.15;
            }
            // Diminishing returns on heavy use — prevent single sticker domination
            if (s.times_used > 3) w *= (3 / s.times_used);
            return w;
          });
          const totalWeight = weights.reduce((a, b) => a + b, 0);
          let r = Math.random() * totalWeight;
          let chosen = ranked[0];
          for (let i = 0; i < ranked.length; i++) {
            r -= weights[i];
            if (r <= 0) { chosen = ranked[i]; break; }
          }
          try {
            await this._sendSticker(this.chatId, chosen.file_id);
            this._lastSentStickerUniqueId = chosen.file_unique_id;
            this.pes.store.markStickerUsed(chosen.file_unique_id);
            this._recentSentStickers.push(chosen.file_unique_id);
            if (this._recentSentStickers.length > 10) this._recentSentStickers.shift();
            return;
          } catch (_) {}
        }
      }
    }

    // Fallback: emotion index from loaded packs (if DB has no analyzed stickers)
    if (targetEmotions && this._stickerEmotionIndex) {
      for (const emotion of targetEmotions) {
        const stickers = this._stickerEmotionIndex[emotion];
        if (stickers && stickers.length > 0) {
          const fresh = stickers.filter(s => !this._recentSentStickers.includes(s));
          const sticker = fresh.length > 0 ? pickRandom(fresh) : pickRandom(stickers);
          try {
            await this._sendSticker(this.chatId, sticker);
            this._recentSentStickers.push(sticker);
            if (this._recentSentStickers.length > 10) this._recentSentStickers.shift();
          } catch (_) {}
          return;
        }
      }
    }

    // No match found — pick any random sticker from loaded packs
    if (this._stickerFileIds && this._stickerFileIds.length > 0) {
      const fresh = this._stickerFileIds.filter(s => !this._recentSentStickers.includes(s));
      const sticker = fresh.length > 0 ? pickRandom(fresh) : pickRandom(this._stickerFileIds);
      try {
        await this._sendSticker(this.chatId, sticker);
        this._recentSentStickers.push(sticker);
        if (this._recentSentStickers.length > 10) this._recentSentStickers.shift();
      } catch (_) {}
    }
  }

  // ── Short Memory ────────────────────────────────────────────

  _addToMemory(role, text) {
    this._memory.push({ role, text, ts: Date.now() });
    // At 9 messages — trigger context compression (async, non-blocking)
    if (this._memory.length >= 9 && !this._summarizing) {
      this._compressContext();
    }
  }

  /**
   * Compress current memory into a summary using LLM.
   * Accumulated summary grows — old info is never lost.
   */
  async _compressContext() {
    if (!this._llm || this._summarizing) return;
    this._summarizing = true;

    try {
      const historyText = this._memory.map(m => {
        const who = m.role === 'owner' ? 'Хозяин' : 'ПЕС';
        return `${who}: ${m.text}`;
      }).join('\n');

      const existingCtx = this._contextSummary
        ? `Предыдущий контекст:\n${this._contextSummary}\n\n`
        : '';

      const summaryPrompt = `Ты — система памяти для ПЕС (собака-корги). Твоя задача — сжать диалог в краткое резюме, сохранив ВСЮ важную информацию.

${existingCtx}Новый диалог для сжатия:
${historyText}

ИНСТРУКЦИИ:
- Сохрани ВСЕ факты: имена, события, предпочтения хозяина, ключевые темы
- Сохрани эмоциональный контекст: как прошёл разговор, настроение
- Если есть предыдущий контекст — объедини с новой информацией
- Формат: краткие тезисы, максимум 150 слов
- Пиши на русском`;

      const result = await this._llm.generate(summaryPrompt, [
        { role: 'user', content: 'Сожми этот диалог в краткое резюме.' }
      ]);

      if (result) {
        this._contextSummary = result;
        // Keep only last 2 messages as bridge, clear the rest
        this._memory = this._memory.slice(-2);
        // Persist to DB so it survives restarts
        this._saveContextSummary();
        console.log(`🧠 Context compressed. Summary: ${result.substring(0, 80)}...`);
      }
    } catch (err) {
      console.error('⚠️ Context compression failed:', err.message);
    } finally {
      this._summarizing = false;
    }
  }

  // ── Context Persistence ────────────────────────────────────

  /** Load context summary from SQLite on startup. */
  _loadContextSummary() {
    if (!this.pes.store) return;
    try {
      const saved = this.pes.store.getConfig('context_summary');
      if (saved) {
        this._contextSummary = saved;
        console.log(`🧠 Context summary loaded from DB (${saved.length} chars)`);
      }
    } catch (err) {
      console.error('⚠️ Failed to load context summary:', err.message);
    }
  }

  /** Save context summary to SQLite after compression. */
  _saveContextSummary() {
    if (!this.pes.store || !this._contextSummary) return;
    try {
      this.pes.store.setConfig('context_summary', this._contextSummary);
    } catch (err) {
      console.error('⚠️ Failed to save context summary:', err.message);
    }
  }

  // ── Idle Behavior ─────────────────────────────────────────

  /** Start idle timer — Тор скучает если хозяин молчит. */
  _startIdleTimer() {
    this._lastOwnerMessageTime = Date.now();
    this._idleTimer = setInterval(() => this._checkIdle(), 5 * 60 * 1000); // every 5 min
    this._lastIdleMessage = 0; // prevent spam

    // ── Proactive daily messages (Живой бот) ──
    this._proactiveToday = 0;
    this._proactiveDate = '';
    this._loadProactiveState();
    // Check proactive every 30 min (separate from idle)
    this._proactiveTimer = setInterval(() => this._checkProactive(), 30 * 60 * 1000);

    console.log('😴 Idle behavior timer started (check every 5min, proactive every 30min)');
  }

  /** Load proactive message state from DB. */
  _loadProactiveState() {
    try {
      const raw = this.pes?.store?.getConfig?.('proactive_state');
      if (raw) {
        const state = JSON.parse(raw);
        this._proactiveDate = state.date || '';
        this._proactiveToday = state.count || 0;
      }
    } catch (_) {}
  }

  /** Save proactive message state to DB. */
  _saveProactiveState() {
    try {
      this.pes?.store?.setConfig?.('proactive_state', JSON.stringify({
        date: this._proactiveDate,
        count: this._proactiveToday,
      }));
    } catch (_) {}
  }

  /**
   * Proactive daily messages — PES сам пишет если хозяин давно не заходил.
   * Rules: max 2/day, not at night (23-7 Moscow), only after 3h+ silence.
   * Content depends on mood/hunger/loneliness.
   */
  async _checkProactive() {
    if (!this._lastOwnerMessageTime || !this.chatId) return;
    if (this._devMode || this._agentMode) return;

    // Reset daily counter if new day
    const today = new Date().toISOString().slice(0, 10);
    if (this._proactiveDate !== today) {
      this._proactiveDate = today;
      this._proactiveToday = 0;
      this._saveProactiveState();
    }

    // Max 2 proactive messages per day
    if (this._proactiveToday >= 2) return;

    // Not at night (Moscow time)
    const moscowHour = (new Date().getUTCHours() + 3) % 24;
    if (moscowHour >= 23 || moscowHour < 8) return;

    // Only after 3+ hours of silence
    const silentHours = (Date.now() - this._lastOwnerMessageTime) / (3600 * 1000);
    if (silentHours < 3) return;

    // Don't overlap with idle messages (at least 60 min gap)
    const sinceLastIdle = (Date.now() - (this._lastIdleMessage || 0)) / (60 * 1000);
    if (sinceLastIdle < 60) return;

    const level = this.pes?.level || 0;
    const mood = this.pes?.emotions?.mood ?? 0.5;
    const hunger = this.pes?.emotions?.hunger ?? 0.2;
    const loneliness = this.pes?.emotions?.loneliness ?? 0.1;
    const energy = this.pes?.emotions?.energy ?? 0.5;
    const name = this.pes?.name || 'PES';

    // Pick message type based on vitals
    let messageType;
    if (hunger > 0.6) messageType = 'hungry';
    else if (loneliness > 0.5) messageType = 'lonely';
    else if (energy < 0.3) messageType = 'sleepy';
    else if (mood < 0.3) messageType = 'sad';
    else if (mood > 0.7) messageType = 'playful';
    else messageType = 'curious';

    const PROACTIVE_MESSAGES = {
      hungry: [
        '🍖❓ ...ав... 🐾',
        '👃💨🍖 ... *тыкает миску носом*',
        '🐾🥺 ...ммм... кушать...',
      ],
      lonely: [
        '🐾💧 ...скууучно... 👀',
        '📱👀 ...ты где?... 🐾',
        '🐾... *лежит у двери и вздыхает* 💨',
      ],
      sleepy: [
        '😴🐾 *зевает и ищет тёплое место*',
        '💤... *свернулся калачиком* 🐾',
        '🐾😴 ...ззз... *дёргает лапкой во сне*',
      ],
      sad: [
        '🐾💧 *грустно смотрит в окно*',
        '...🥺🐾... *тихо скулит*',
        '👀💧 ...давно не играли... 🐾',
      ],
      playful: [
        '🎾🐾 ав! играть?! 👀✨',
        '🐾💨 *принёс мячик и положил у ног* 🎾',
        '🐾🌀 *крутится вокруг себя* ...авав! 🎉',
      ],
      curious: [
        '👃💨 ...интересно... 🐾👀',
        '🐾📡 *навострил уши — что-то слышит*',
        '👀🐾 *заглядывает в телефон* ...привет? 📱',
      ],
    };

    const messages = PROACTIVE_MESSAGES[messageType] || PROACTIVE_MESSAGES.curious;
    const text = messages[Math.floor(Math.random() * messages.length)];

    try {
      await this._sendText(this.chatId, text);

      // Sometimes add a sticker (30% chance)
      if (Math.random() < 0.3) {
        const stickerEmotion = messageType === 'hungry' ? 'feed' :
          messageType === 'playful' ? 'praise' :
          messageType === 'sad' || messageType === 'lonely' ? 'scold' : null;
        await this._sendContextualSticker(stickerEmotion);
      }

      this._proactiveToday++;
      this._lastIdleMessage = Date.now(); // prevent idle overlap
      this._saveProactiveState();

      console.log(`🐾 Proactive message sent (${messageType}, #${this._proactiveToday}/2 today)`);
    } catch (err) {
      console.error('⚠️ Proactive message error:', err.message);
    }
  }

  /** Check if owner has been silent too long and send idle behavior. */
  async _checkIdle() {
    if (!this._lastOwnerMessageTime) return;
    if (this._devMode || this._agentMode) return; // don't idle in dev/agent mode

    const silentMinutes = (Date.now() - this._lastOwnerMessageTime) / (60 * 1000);
    const sinceLastIdle = (Date.now() - this._lastIdleMessage) / (60 * 1000);

    // Don't spam — minimum 30 min between idle messages
    if (sinceLastIdle < 30) return;

    // Check time of day (Moscow) — don't idle at night
    const moscowHour = (new Date().getUTCHours() + 3) % 24;
    if (moscowHour >= 23 || moscowHour < 7) return;

    // ── Sticker discovery on idle (young+ level) ──
    if (silentMinutes >= 15 && silentMinutes < 30) {
      // Dog is bored — time to explore stickers
      this._exploreStickerDiscovery().catch(err =>
        console.error('⚠️ Idle sticker discovery error:', err.message)
      );
    }

    const level = this.pes?.level || 0;
    const vitals = {
      energy: this.pes?.emotions?.energy || 0.5,
      hunger: this.pes?.emotions?.hunger || 0.2,
      loneliness: this.pes?.emotions?.loneliness || 0.1,
      curiosity: this.pes?.emotions?.curiosity || 0.5,
    };

    if (silentMinutes >= 120) {
      // Very long absence (2h+) — deep lonely sounds via babble engine
      const babble = this._babble.generateAfterSilence
        ? this._babble.generateIdle(level, { ...vitals, loneliness: 0.8, energy: 0.3 })
        : this._babble.generate(level, 'lonely', 0.6);
      await this._sendText(this.chatId, babble + ' 💧');
      // Sometimes a sad sticker
      if (Math.random() < 0.5) {
        await this._sendContextualSticker('scold'); // sad stickers
      }
      this._lastIdleMessage = Date.now();
    } else if (silentMinutes >= 60) {
      // Lonely — 1+ hour of silence — use babble idle generator
      const babble = this._babble.generateIdle
        ? this._babble.generateIdle(level, { ...vitals, loneliness: 0.6 })
        : this._babble.generate(level, 'sad', 0.4);
      await this._sendText(this.chatId, babble);
      this._lastIdleMessage = Date.now();
    } else if (silentMinutes >= 30) {
      // Mildly bored — 30+ min — generate curiosity/bored babble
      const babble = this._babble.generateIdle
        ? this._babble.generateIdle(level, { ...vitals, curiosity: 0.3 })
        : this._babble.generate(level, 'curious', 0.3);
      await this._sendText(this.chatId, babble);

      // v4: Spontaneous action — sometimes do something interesting
      const spontaneous = Math.random();
      if (spontaneous < 0.25) {
        // Send a sticker
        await this._sendContextualSticker(null);
      } else if (spontaneous < 0.40 && level >= 5) {
        // "Sniff around" — small observation
        const observations = [
          '👃💨 🐾', // sniffing
          '👀... 🐾', // looking around
          '👂⬆️👂 ...', // ears perked
          '📡📡 ...?', // scanning
        ];
        await sleep(2000 + Math.random() * 3000);
        await this._sendText(this.chatId, pickRandom(observations));
      }
      this._lastIdleMessage = Date.now();
    }
  }

  // ── Interaction Pattern Observation ──────────────────────────

  /**
   * Observe and record interaction patterns from owner's message.
   * Tracks: emotions, topics, sticker types, time of day, message styles.
   * This data drives sticker discovery (not a hardcoded catalog).
   */
  _observeInteractionPatterns(text, detectedKw = null) {
    if (!this.pes.store) return;
    try {
      // 1. Time of day pattern
      const moscowHour = (new Date().getUTCHours() + 3) % 24;
      const timeSlot = moscowHour < 6 ? 'night' : moscowHour < 12 ? 'morning' : moscowHour < 18 ? 'afternoon' : 'evening';
      this.pes.store.recordPattern('time_of_day', timeSlot, 0.5);

      // 2. Keyword/action pattern
      if (detectedKw && detectedKw.action) {
        this.pes.store.recordPattern('action', detectedKw.action, 1.0);
        if (detectedKw.command) {
          this.pes.store.recordPattern('command', detectedKw.command, 1.5);
        }
      }

      // 3. Emotion from text (simple keyword detection)
      const emotionPatterns = {
        happy: /(?:хаха|лол|😂|🤣|ахах|класс|круто|огонь|🔥|супер|ура)/i,
        sad: /(?:грустно|печально|😢|😭|жаль|увы|скучаю)/i,
        angry: /(?:бесит|злой|злюсь|😡|🤬|блин|чёрт)/i,
        love: /(?:люблю|❤️|💕|♡|обнимаю|скучаю|♥)/i,
        excited: /(?:вау|ого|офигеть|🤩|amazing|wow|урааа|!!!)/i,
        playful: /(?:играть|игра|прикол|😜|🤪|хех|жжёшь)/i,
        food: /(?:еда|есть|кушать|голод|🍕|🍔|🍩|вкусн|кормить)/i,
      };

      for (const [emotion, pattern] of Object.entries(emotionPatterns)) {
        if (pattern.test(text)) {
          this.pes.store.recordPattern('emotion', emotion, 1.0);
        }
      }

      // 4. Message length pattern (affects communication style)
      const lengthType = text.length < 10 ? 'short' : text.length < 50 ? 'medium' : 'long';
      this.pes.store.recordPattern('message_style', lengthType, 0.3);

      // 5. Emoji usage pattern — which emojis owner prefers
      const emojis = text.match(/[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu);
      if (emojis) {
        for (const em of emojis) {
          this.pes.store.recordPattern('emoji_used', em, 1.0);
        }
      }
    } catch (err) {
      // Non-critical — don't crash on pattern observation
      console.error('⚠️ Pattern observation error:', err.message);
    }
  }

  /**
   * Record sticker-specific patterns when owner sends sticker.
   */
  _observeStickerPattern(emoji, setName, emotionKey = null) {
    if (!this.pes.store) return;
    try {
      this.pes.store.recordPattern('sticker_emoji', emoji, 1.5);
      if (setName) {
        this.pes.store.recordPattern('sticker_pack', setName, 1.0);
      }
      if (emotionKey) {
        this.pes.store.recordPattern('sticker_emotion', emotionKey, 1.5);
      }
    } catch (err) {
      console.error('⚠️ Sticker pattern error:', err.message);
    }
  }

  /**
   * Auto-load a sticker/custom emoji set if not already known.
   */
  async _autoLoadStickerSet(setName) {
    if (!setName || this._learnedPacks.has(setName)) return;
    try {
      await this.loadStickerPack(setName, null, true);
      this._learnedPacks.add(setName);
      this._saveStickerPackToDB(setName);
      console.log(`📦 Auto-loaded sticker set: ${setName}`);
    } catch (_) {
      // Pack not accessible (custom emoji sets may not be loadable as regular packs)
    }
  }

  // ── Sticker Discovery from Interaction Patterns ──────────

  /**
   * Explore sticker packs based on observed interaction patterns.
   * Called periodically (from idle timer or after N messages).
   * The dog doesn't use a catalog — it learns from watching the owner.
   */
  async _exploreStickerDiscovery() {
    if (!this.pes.store) return;

    // Only young+ can explore
    const stats = this.pes.store.getStats();
    if (!stats) return;
    // Level gate removed — testing all features

    // Check cooldown — max 1 exploration per 4 hours
    const lastExploreTime = this.pes.store.getConfig('last_sticker_explore');
    if (lastExploreTime) {
      const elapsed = Date.now() - new Date(lastExploreTime).getTime();
      if (elapsed < 4 * 60 * 60 * 1000) return; // 4 hours
    }

    try {
      // Strategy 1: Explore untried stickers from known packs
      const explorablePacks = this.pes.store.getExplorablePacks(3);
      for (const pack of explorablePacks) {
        const untried = this.pes.store.getUntriedStickersFromPack(pack.set_name, 1);
        if (untried.length > 0) {
          const sticker = untried[0];
          // Dog found something to try!
          await this._showStickerDiscovery(sticker, pack);
          this.pes.store.setConfig('last_sticker_explore', new Date().toISOString());
          return; // One discovery at a time
        }
      }

      // Strategy 2: Look for new packs from owner's sticker patterns
      const packPatterns = this.pes.store.getTopPatterns('sticker_pack', 5);
      if (packPatterns.length > 0) {
        // Try to discover related packs by name variation
        for (const pattern of packPatterns) {
          const baseName = pattern.pattern_value;
          // Check if there's a discovery record for this pack's "family"
          const disc = this.pes.store.db.prepare(
            'SELECT COUNT(*) as cnt FROM sticker_discovery WHERE set_name = ?'
          ).get(baseName);

          if (!disc || disc.cnt === 0) {
            // First time seeing this pack in discovery — register it
            const stickerCount = this.pes.store.db.prepare(
              'SELECT COUNT(*) as cnt FROM learned_stickers WHERE set_name = ?'
            ).get(baseName);

            this.pes.store.saveDiscovery(baseName, {
              source: 'owner',
              stickersTotal: stickerCount?.cnt || 0,
              matchScore: pattern.weight,
              notes: { reason: 'owner_uses', occurrences: pattern.occurrences },
            });
          }
        }
      }

      this.pes.store.setConfig('last_sticker_explore', new Date().toISOString());
    } catch (err) {
      console.error('⚠️ Sticker discovery error:', err.message);
    }
  }

  /**
   * Show a discovered sticker to the owner — dog "brings" it proudly.
   * Waits for owner's reaction (👍/👎) via the reaction handler.
   */
  async _showStickerDiscovery(sticker, pack) {
    try {
      // Typing — dog "runs to get" the sticker
      await this._sendChatAction(this.chatId);
      await sleep(1500 + Math.random() * 2000);

      // Send the sticker
      await this._sendSticker(this.chatId, sticker.file_id);

      // Proud sounds
      const sounds = [
        'тяф?! ✨🐾 рру~!',
        'ГАВВ! ✨ тяф-тяф! 🐾',
        'рруу~! ✨ ваф? 🐾',
        'ыыыа! ✨ тяф! 🐾',
      ];
      await this._sendText(this.chatId, pickRandom(sounds));

      // Track this as the last bot action for reaction tracking
      this._lastBotAction = {
        action: 'sticker_discovery',
        text: `discovered sticker from ${pack.set_name}`,
        category: 'sticker',
        timestamp: Date.now(),
        discoveryPackName: pack.set_name,
        stickerUniqueId: sticker.file_unique_id,
      };

      // Mark sticker as tried
      this.pes.store.markStickerTried(sticker.file_unique_id);
      this.pes.store.incrementDiscoveryTried(pack.set_name);

      console.log(`🔍 Sticker discovery: showed sticker from ${pack.set_name}`);
    } catch (err) {
      console.error('⚠️ Show sticker discovery error:', err.message);
    }
  }

  // ── Dynamic Sticker Packs from DB ─────────────────────────

  /** Load sticker pack names from DB config instead of hardcoded array. */
  async _loadStickerPacksFromDB() {
    if (!this.pes.store) return;
    try {
      const saved = this.pes.store.getConfig('sticker_packs');
      let packs = [];
      if (saved) {
        packs = JSON.parse(saved);
      } else {
        // First run — use defaults and save to DB
        packs = ['CorgiLove', 'corgi_life', 'CorgiBaby', 'CorgiPower'];
        this.pes.store.setConfig('sticker_packs', JSON.stringify(packs));
      }

      let firstPack = true;
      for (const pack of packs) {
        try {
          await this.loadStickerPack(pack, null, !firstPack);
          this._learnedPacks.add(pack);
          console.log(`📦 Loaded sticker pack from DB: ${pack}`);
          firstPack = false;
        } catch (err) {
          console.log(`⚠️ Pack "${pack}" not available: ${err.message}`);
        }
      }
      console.log(`📦 Total stickers loaded: ${this._stickerFileIds?.length || 0} from ${packs.length} packs`);
    } catch (err) {
      console.error('⚠️ Failed to load sticker packs from DB:', err.message);
    }
  }

  /** Save a new sticker pack name to DB config. */
  _saveStickerPackToDB(packName) {
    if (!this.pes.store) return;
    try {
      const saved = this.pes.store.getConfig('sticker_packs');
      const packs = saved ? JSON.parse(saved) : [];
      if (!packs.includes(packName)) {
        packs.push(packName);
        this.pes.store.setConfig('sticker_packs', JSON.stringify(packs));
        console.log(`📦 Saved sticker pack to DB: ${packName}`);
      }
    } catch (err) {
      console.error('⚠️ Failed to save sticker pack:', err.message);
    }
  }

  // ── Emoji Learning ─────────────────────────────────────────

  /**
   * Log a reaction (praise/scold/text feedback) to the last bot action.
   * @param {string} reactionType — 'praise' | 'scold' | 'positive' | 'negative'
   * @param {string} reactionValue — the text that triggered this
   * @param {number} weight — -2 to 2
   */
  _logReactionToLastAction(reactionType, reactionValue, weight) {
    if (!this.pes.store || !this._lastBotAction) return;

    const speedMs = Date.now() - this._lastBotAction.timestamp;

    try {
      this.pes.store.logReaction({
        pes_action: this._lastBotAction.action || 'reply',
        pes_expression: this._lastBotAction.text || null,
        pes_context: this._lastBotAction.category || null,
        reactor: 'owner',
        reactor_role: 'owner',
        reaction_type: reactionType,
        reaction_value: reactionValue?.slice(0, 200) || null,
        reaction_speed: speedMs,
        weight,
        platform: 'telegram',
      });

      // Recalculate preferences periodically
      this._reactionRecalcCounter++;
      if (this._reactionRecalcCounter >= 5) {
        this._reactionRecalcCounter = 0;
        this.pes.store.recalculatePreference(this._lastBotAction.action || 'reply');
      }

      console.log(`💭 Reaction logged: ${reactionType} (weight=${weight}) → action "${this._lastBotAction.action}"`);
    } catch (err) {
      console.error('⚠️ Failed to log reaction:', err.message);
    }
  }

  /**
   * Grant XP and handle level-up notifications.
   * @param {string} reason — 'message' | 'praise' | 'scold' | 'sticker' | 'reaction' | 'emoji'
   * @param {number} amount — base XP amount
   */
  async _grantXp(reason, amount) {
    if (!this.pes.store) return;
    try {
      const result = this.pes.store.addXP(amount, reason);
      const capInfo = result.dailyXP >= result.dailyCap ? ' [CAP]' : '';
      console.log(`⭐ XP +${result.added} (${reason}) → level ${result.level} [${result.phase}]${capInfo} daily:${result.dailyXP}/${result.dailyCap}`);

      // Level-up notification
      if (result.leveledUp) {
        const levelUpSounds = [
          'ГАВВВ!! ГАВГАВГАВ!! ♡♡♡ ыыыыааа!! ⭐⭐⭐',
          'рррРРРУУУУ!! ваф-ваф-ваф!! ⭐ тяф!!',
          'УУУУУ!! гав! гав! гав! ♡ ⭐⭐',
        ];
        const sound = levelUpSounds[Math.floor(Math.random() * levelUpSounds.length)];

        // Show age gate info — how many days until next phase
        const ageDays = this.pes.store.getAgeDays();
        const AGE_GATES = { puppy: 0, young: 30, adult: 365, experienced: 1095, cyber: 1825 };
        const phaseOrder = ['puppy', 'young', 'adult', 'experienced', 'cyber'];
        const currentPhaseIdx = phaseOrder.indexOf(result.phase);
        let nextPhaseInfo = '';
        if (currentPhaseIdx < phaseOrder.length - 1) {
          const nextPhase = phaseOrder[currentPhaseIdx + 1];
          const daysNeeded = AGE_GATES[nextPhase] - ageDays;
          if (daysNeeded > 0) {
            nextPhaseInfo = `\n📅 ${nextPhase}: ${daysNeeded}д`;
          }
        }

        const msg = `${sound}\n\n⬆️ ${Math.floor(result.level)} [${result.phase}] ✨${nextPhaseInfo}`;
        await this._sendText(this.chatId, msg);

        // Send a celebratory sticker
        await this._sendContextualSticker('excited');
      }

      // Artifact drop chance (5% per XP grant, unlocked at L5)
      if (this.pes.store.isUnlocked?.('artifacts') || Math.floor(result.level) >= 5) {
        await this._tryArtifactDrop(reason, result);
      }
    } catch (err) {
      console.error('⚠️ Failed to grant XP:', err.message);
    }
  }

  // ── Artifact Drop System ──────────────────────────────────

  async _tryArtifactDrop(reason, xpResult) {
    const DROP_CHANCE = 0.05; // 5% base
    const LEVEL_BONUS = Math.floor(xpResult.level) * 0.002; // +0.2% per level
    const roll = Math.random();
    if (roll > DROP_CHANCE + LEVEL_BONUS) return;

    const ARTIFACT_POOL = [
      // Common (60%)
      { name: 'Мячик', emoji: '⚽', type: 'toy', rarity: 'common', weight: 12 },
      { name: 'Палка', emoji: '🪵', type: 'toy', rarity: 'common', weight: 12 },
      { name: 'Косточка', emoji: '🦴', type: 'food', rarity: 'common', weight: 12 },
      { name: 'Камешек', emoji: '🪨', type: 'toy', rarity: 'common', weight: 12 },
      { name: 'Перо', emoji: '🪶', type: 'toy', rarity: 'common', weight: 12 },
      // Uncommon (25%)
      { name: 'Бабочка в банке', emoji: '🦋', type: 'trophy', rarity: 'uncommon', weight: 7 },
      { name: 'Блестящая монета', emoji: '🪙', type: 'trophy', rarity: 'uncommon', weight: 6 },
      { name: 'Ракушка', emoji: '🐚', type: 'trophy', rarity: 'uncommon', weight: 6 },
      { name: 'Колокольчик', emoji: '🔔', type: 'gift', rarity: 'uncommon', weight: 6 },
      // Rare (10%)
      { name: 'Кристалл', emoji: '💎', type: 'rare', rarity: 'rare', weight: 4 },
      { name: 'Звёздная пыль', emoji: '✨', type: 'rare', rarity: 'rare', weight: 3 },
      { name: 'Лунный камень', emoji: '🌙', type: 'rare', rarity: 'rare', weight: 3 },
      // Epic (4%)
      { name: 'Драконий зуб', emoji: '🐉', type: 'rare', rarity: 'epic', weight: 2 },
      { name: 'Огненный цветок', emoji: '🌺', type: 'rare', rarity: 'epic', weight: 2 },
      // Legendary (1%)
      { name: 'Сердце Вселенной', emoji: '💫', type: 'secret', rarity: 'legendary', weight: 1 },
    ];

    // Weighted random
    const totalWeight = ARTIFACT_POOL.reduce((s, a) => s + a.weight, 0);
    let r = Math.random() * totalWeight;
    let picked = ARTIFACT_POOL[0];
    for (const art of ARTIFACT_POOL) {
      r -= art.weight;
      if (r <= 0) { picked = art; break; }
    }

    const ownerId = String(this.chatId);
    try {
      this.pes.store.addArtifact({
        owner_id: ownerId,
        artifact_type: picked.type,
        name: picked.name,
        emoji: picked.emoji,
        rarity: picked.rarity,
        source: reason,
        source_detail: `xp_grant_${reason}`,
      });

      const RARITY_STARS = { common: '⬜', uncommon: '🟩', rare: '🟦', epic: '🟪', legendary: '🟨' };
      const star = RARITY_STARS[picked.rarity] || '⬜';
      await this._sendText(this.chatId, `${picked.emoji} нашёл ${picked.name}! ${star} ${picked.rarity}\nгав! гав! 🐾 → /artifacts`);
      console.log(`🎁 Artifact drop: ${picked.name} (${picked.rarity}) for ${ownerId}`);
    } catch (err) {
      console.error('⚠️ Artifact drop failed:', err.message);
    }
  }

  // ── Smart XP System ──────────────────────────────────────

  /**
   * Calculate dynamic XP for a message based on quality.
   * Replaces fixed +1 with context-aware scoring.
   */
  _calculateMessageXP(msg, intent = null) {
    const text = msg?.text || msg?.caption || '';
    let xp = 1; // base
    let detail = { length: 'short' };

    // Length bonus: medium (+1), long (+2)
    if (text.length > 100) {
      xp = 3;
      detail.length = 'long';
    } else if (text.length > 40) {
      xp = 2;
      detail.length = 'medium';
    }

    // Teaching intent: "знай что", "запомни", file with caption
    if (intent === 'note' || intent === 'teach') {
      xp = Math.max(xp, 3);
      detail.teaching = true;
    }

    // File with caption = content contribution
    if ((msg?.photo || msg?.document || msg?.video || msg?.voice) && text.length > 5) {
      xp = Math.max(xp, 3);
      detail.file_with_desc = true;
    }

    // Correction bonus: owner continues after negative reaction
    if (this._lastReactionWasNegative && Date.now() - (this._lastReactionTime || 0) < 5 * 60 * 1000) {
      xp += 2;
      detail.correction = true;
      this._lastReactionWasNegative = false;
    }

    return { xp, detail: JSON.stringify(detail) };
  }

  /**
   * Track dialogue session. Returns bonus XP if milestone reached.
   */
  _trackDialogue() {
    const now = Date.now();
    const SESSION_GAP = 10 * 60 * 1000; // 10 min

    if (!this._dialogueStartTime || (now - (this._lastDialogueMessageTime || 0)) > SESSION_GAP) {
      // New session
      this._dialogueStartTime = now;
      this._dialogueMessageCount = 1;
    } else {
      this._dialogueMessageCount = (this._dialogueMessageCount || 0) + 1;
    }
    this._lastDialogueMessageTime = now;

    // Bonus at 5, 10, 15 messages in session
    if (this._dialogueMessageCount === 5 || this._dialogueMessageCount === 10 || this._dialogueMessageCount === 15) {
      return this._dialogueMessageCount === 5 ? 5 : this._dialogueMessageCount === 10 ? 3 : 2;
    }
    return 0;
  }

  /**
   * Check and update daily streak. Returns streak info.
   * Called on first message of the day.
   */
  _checkStreak() {
    if (!this.pes.store) return null;
    try {
      const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
      const lastDate = this.pes.store.getConfig('streak_last_date');
      const currentStreak = parseInt(this.pes.store.getConfig('streak_current') || '0', 10);

      if (lastDate === today) return null; // already checked today

      const yesterday = new Date(Date.now() - 86400000).toISOString().slice(0, 10);
      let newStreak;

      if (lastDate === yesterday) {
        // Consecutive day — increment
        newStreak = currentStreak + 1;
      } else if (!lastDate) {
        // First ever
        newStreak = 1;
      } else {
        // Streak broken
        newStreak = 1;
      }

      this.pes.store.setConfig('streak_current', String(newStreak));
      this.pes.store.setConfig('streak_last_date', today);

      // XP scales with streak: 1-3 days = 1, 4-6 = 2, 7-13 = 3, 14-29 = 4, 30+ = 5
      const streakXP = newStreak >= 30 ? 5 : newStreak >= 14 ? 4 : newStreak >= 7 ? 3 : newStreak >= 4 ? 2 : 1;

      return { streak: newStreak, xp: streakXP, isMilestone: [3, 7, 14, 30, 60, 100, 365].includes(newStreak), broken: lastDate && lastDate !== yesterday && currentStreak > 1 };
    } catch (err) {
      console.error('⚠️ Streak check error:', err.message);
      return null;
    }
  }

  /**
   * Track interaction type diversity for daily bonus.
   * Types: text, sticker, reaction, file, note, command
   */
  _trackDiversity(type) {
    const today = new Date().toISOString().slice(0, 10);
    if (this._diversityDate !== today) {
      this._diversityDate = today;
      this._diversityTypes = new Set();
      this._diversityBonusGiven = false;
    }
    this._diversityTypes.add(type);

    // Bonus when reaching 3 unique types, once per day
    if (this._diversityTypes.size >= 3 && !this._diversityBonusGiven) {
      this._diversityBonusGiven = true;
      return true;
    }
    return false;
  }

  /**
   * Check if this is the first message of the day. Returns true once per day.
   */
  _checkFirstDaily() {
    const today = new Date().toISOString().slice(0, 10);
    if (this._firstDailyDate === today) return false;
    this._firstDailyDate = today;
    return true;
  }

  /**
   * Process all Smart XP grants for a message.
   * Central hub — called from _handleTextMessage, _handleMediaMessage, etc.
   */
  async _processSmartXP(msg, interactionType = 'text', intent = null) {
    if (!this.pes.store) return;

    // 1. First daily bonus
    const isFirstDaily = this._checkFirstDaily();
    if (isFirstDaily) {
      await this._grantXp('first_daily', 3);

      // Streak check (also first-daily)
      const streakInfo = this._checkStreak();
      if (streakInfo) {
        await this._grantXp('streak', streakInfo.xp);

        if (streakInfo.isMilestone) {
          // Milestone reaction — dog celebrates
          const milestoneReactions = [
            `ГАААВВ!! ррРРуууу!! 🔥${streakInfo.streak}🔥 тяф-тяф!! ✨🐾`,
            `ууУУУ!! ваф!! 🔥${streakInfo.streak}🔥 ГАВВ!! ♡♡ 🐾`,
            `рррРРР!! ГАВГАВ!! 🔥${streakInfo.streak}🔥 ыыы!! ⭐🐾`,
          ];
          await this._sendText(this.chatId, milestoneReactions[Math.floor(Math.random() * milestoneReactions.length)]);
          await this._sendContextualSticker('excited');
        } else if (streakInfo.broken) {
          // Streak was broken — dog is a bit sad but happy you're back
          await this._sendText(this.chatId, 'скууу... ыыы... 💧 ...рру~ ♡ 🐾');
        }
      }
    }

    // 2. Dynamic message XP (replaces fixed +1)
    const { xp, detail } = this._calculateMessageXP(msg, intent);
    await this._grantXp('message', xp);

    // 3. Dialogue bonus
    const dialogueBonus = this._trackDialogue();
    if (dialogueBonus > 0) {
      await this._grantXp('dialogue_bonus', dialogueBonus);
    }

    // 4. Diversity tracking
    const diversityReached = this._trackDiversity(interactionType);
    if (diversityReached) {
      await this._grantXp('diversity', 5);
    }

    // 5. Spell discovery check (rare — every 10th message)
    if (Math.random() < 0.1) {
      await this._checkSpellDiscovery();
    }
  }

  /**
   * Check for spell discovery and display animation if found.
   */
  async _checkSpellDiscovery() {
    if (!this.pes || !this.pes.checkSpellDiscovery) return;
    try {
      const spell = this.pes.checkSpellDiscovery();
      if (spell) {
        // Spell discovery animation!
        const rarityStars = {
          spark: '✦', glint: '✧', flash: '⚡', pulse: '💫',
          surge: '🌊', wave: '🌊', storm: '⛈️', blaze: '🔥',
          nova: '💥', eclipse: '🌑', cosmos: '🌌', god: '👁️‍🗨️',
        };
        const icon = rarityStars[spell.rarity] || '✨';
        const percent = 100 + spell.level;

        await this._sendChatAction(this.chatId);
        await sleep(2000);

        // Dramatic reveal
        await this._sendText(this.chatId, '✨✨✨✨✨✨✨✨✨✨✨✨');
        await sleep(1500);
        await this._sendText(this.chatId, `${icon} SPELL AWAKENED ${icon}`);
        await sleep(1000);
        await this._sendText(this.chatId, `${icon} ${spell.name} (${percent}%) ${icon}`);
        await sleep(1000);
        await this._sendText(this.chatId, `[${spell.rarity.toUpperCase()}]`);
        await sleep(500);
        await this._sendText(this.chatId, '✨✨✨✨✨✨✨✨✨✨✨✨');

        // Dog reaction
        await sleep(1000);
        const reactions = [
          'ррРРРуууу!! ...тяф?! ...ГАВВ!! ✨🐾',
          'ууУУУ!! ...рру~... ...ГАВГАВ!! ✨🐾',
          '...тяф... ...рррРР!! ...ГАААВВ!! ✨🐾',
        ];
        await this._sendText(this.chatId, reactions[Math.floor(Math.random() * reactions.length)]);
        await this._sendContextualSticker('excited');
      }
    } catch (err) {
      console.error('⚠️ Spell discovery check error:', err.message);
    }
  }

  // ── Relationships ─────────────────────────────────────────

  /**
   * Initialize owner relationship on bot start.
   * Creates 'owner' entity if doesn't exist.
   */
  _initOwnerRelationship() {
    if (!this.pes.store) return;
    try {
      const existing = this.pes.store.getRelationship('owner');
      if (!existing) {
        this.pes.store.addOrUpdateRelationship('owner', {
          trust: 0.3,
          affection: 0.3,
          relationship_phase: 'acquaintance',
        });
        console.log('💛 Owner relationship initialized (trust=0.3, affection=0.3, acquaintance)');
      } else {
        console.log(`💛 Owner relationship loaded: trust=${existing.trust.toFixed(2)}, affection=${existing.affection.toFixed(2)}, phase=${existing.relationship_phase}, interactions=${existing.interactions_count}`);
      }
    } catch (err) {
      console.error('⚠️ Failed to init owner relationship:', err.message);
    }
  }

  /**
   * Update owner relationship based on interaction type.
   * @param {'message'|'praise'|'scold'|'sticker'|'reaction'|'emoji'} type
   */
  _updateRelationship(type) {
    if (!this.pes.store) return;
    try {
      // Delta values for trust and affection
      const deltas = {
        message:  { trust: 0.005, affection: 0.005 },
        praise:   { trust: 0.02,  affection: 0.03 },
        scold:    { trust: -0.01, affection: -0.005 },
        sticker:  { trust: 0.01,  affection: 0.015 },
        reaction: { trust: 0.01,  affection: 0.01 },
        emoji:    { trust: 0.005, affection: 0.008 },
      };

      const d = deltas[type] || deltas.message;

      // Update trust
      this.pes.store.updateTrust('owner', d.trust);

      // Update affection via addOrUpdateRelationship (it increments interactions_count too)
      const rel = this.pes.store.getRelationship('owner');
      if (rel) {
        const newAffection = Math.max(0, Math.min(1, rel.affection + d.affection));
        this.pes.store.addOrUpdateRelationship('owner', { affection: newAffection });
      }

      // Auto-advance phase
      const updated = this.pes.store.updatePhase('owner');
      if (updated && rel && updated.relationship_phase !== rel.relationship_phase) {
        console.log(`💛 Relationship phase: ${rel.relationship_phase} → ${updated.relationship_phase}!`);
        // Notify in chat about phase change
        this._notifyPhaseChange(rel.relationship_phase, updated.relationship_phase);
      }
    } catch (err) {
      console.error('⚠️ Failed to update relationship:', err.message);
    }
  }

  /**
   * Send celebration message when relationship phase changes.
   */
  async _notifyPhaseChange(oldPhase, newPhase) {
    const phaseSounds = {
      acquaintance: 'рру? рруу~... гав! ♡',
      friend:       'ГАВВВ!! ррРРРууу!! ♡♡♡ тяф-тяф!! ыыыыы!!',
      favorite:     'УУУУААА!! ГАВГАВГАВ!! ♡♡♡♡♡ рррррууу!! ⭐⭐',
      bonded:       'ммммм... рру~ ♡♡♡♡♡♡ ууу~ ♡♡♡ ...ррруууу~ ⭐⭐⭐',
    };

    const phaseNames = {
      stranger: 'незнакомец',
      acquaintance: 'знакомый',
      friend: 'друг',
      favorite: 'любимый',
      bonded: 'неразлучный',
    };

    const sound = phaseSounds[newPhase] || 'гав! ♡';
    const name = phaseNames[newPhase] || newPhase;
    await this._sendText(this.chatId, `${sound}\n\n💛 Уровень привязанности: **${name}**`);
    await this._sendContextualSticker('excited');
  }

  /**
   * Get relationship info for LLM prompt injection.
   * @returns {string}
   */
  _getRelationshipForPrompt() {
    if (!this.pes.store) return '';
    try {
      const rel = this.pes.store.getRelationship('owner');
      if (!rel) return '';

      const trustPct = Math.round(rel.trust * 100);
      const affectionPct = Math.round(rel.affection * 100);

      return `\n\n## Привязанность к хозяину
- Доверие: ${trustPct}% (${trustPct > 70 ? 'полностью доверяет' : trustPct > 40 ? 'доверяет' : 'осторожничает'})
- Привязанность: ${affectionPct}% (${affectionPct > 70 ? 'обожает' : affectionPct > 40 ? 'привязан' : 'присматривается'})
- Фаза: ${rel.relationship_phase}
- Встреч: ${rel.interactions_count}
${trustPct > 80 ? '- Ты ОБОЖАЕШЬ хозяина. Радуешься каждому сообщению.' : ''}
${trustPct < 30 ? '- Ты ещё не очень доверяешь. Осторожен, сдержан.' : ''}`;
    } catch (_) {
      return '';
    }
  }

  /**
   * Get pinned notes for LLM prompt context.
   */
  _getPinnedNotesForPrompt() {
    if (!this.pes.store) return '';
    try {
      const pinned = this.pes.store.getPinnedNotes();
      if (!pinned || pinned.length === 0) return '';

      const items = pinned.slice(0, 5).map(n => `- ${n.text}`).join('\n');
      return `\n\n## Важные заметки хозяина (запомнены навсегда)
${items}
Если хозяин спрашивает об этих вещах — ты знаешь ответ.`;
    } catch (_) {
      return '';
    }
  }

  /**
   * Get files summary for LLM prompt — so PES knows what it stores.
   */
  _getFilesContextForPrompt() {
    if (!this.pes.store) return '';
    try {
      const total = this.pes.store.db.prepare('SELECT COUNT(*) as cnt FROM owner_files WHERE is_deleted = 0').get();
      if (!total || total.cnt === 0) return '';

      const recent = this.pes.store.getRecentFiles({ limit: 5 });
      const items = recent.map(f => `- ${f.file_type}: ${f.file_name}${f.description ? ' — ' + f.description : ''}`).join('\n');

      return `\n\n## Файлы хозяина (ты хранишь ${total.cnt} файлов)
Последние:
${items}
Если хозяин просит найти файл — ты можешь! Ответь звуками и принеси.`;
    } catch (_) {
      return '';
    }
  }

  /**
   * Extract emojis from text and learn them.
   * Saves to SQLite, queues new ones for LLM description.
   */
  _extractAndLearnEmojis(text, ownerSent = true) {
    const emojiRegex = /(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F)(?:\u200D(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F))*/gu;
    const found = text.match(emojiRegex);
    if (!found || !this.pes.store) return;

    const unique = [...new Set(found)];
    for (const emoji of unique) {
      // Skip simple digits/symbols that match emoji regex
      if (/^[0-9#*]$/.test(emoji)) continue;

      const existing = this.pes.store.getEmoji(emoji);
      if (existing) {
        // Reinforce — seen again
        this.pes.store.learnEmoji(emoji, { owner_sent: ownerSent });
      } else {
        // New emoji — save and queue for LLM analysis
        this.pes.store.learnEmoji(emoji, { owner_sent: ownerSent });
        this._emojiAnalysisQueue.push(emoji);
      }
    }

    // Trigger async analysis for new emojis
    if (this._emojiAnalysisQueue.length > 0 && !this._analyzingEmojis) {
      this._analyzeNewEmojis();
    }
  }

  /**
   * Extract and learn Telegram custom emoji from message entities.
   * Custom emoji are premium animated/static stickers used inline.
   * They have type: "custom_emoji" with custom_emoji_id in entities.
   */
  async _extractAndLearnCustomEmojis(entities) {
    if (!entities || !this.pes.store) return;
    const customEmojiIds = entities
      .filter(e => e.type === 'custom_emoji' && e.custom_emoji_id)
      .map(e => e.custom_emoji_id);
    if (customEmojiIds.length === 0) return;

    // Deduplicate
    const uniqueIds = [...new Set(customEmojiIds)];

    try {
      // Resolve custom emoji IDs to sticker objects via Telegram API
      const stickers = await this._call('getCustomEmojiStickers', { custom_emoji_ids: uniqueIds });
      if (!stickers || stickers.length === 0) return;

      for (const sticker of stickers) {
        const existing = this.pes.store.getSticker(sticker.file_unique_id);
        if (existing) {
          // Reinforce — seen again
          this.pes.store.learnSticker(sticker.file_id, sticker.file_unique_id, { owner_sent: 1 });
          // Update custom_emoji_id if we have it
          if (sticker.custom_emoji_id) {
            this.pes.store.updateStickerCustomEmojiId(sticker.file_unique_id, sticker.custom_emoji_id);
          }
        } else {
          // New custom emoji — save and queue for analysis
          this.pes.store.learnSticker(sticker.file_id, sticker.file_unique_id, {
            set_name: sticker.set_name || null,
            emoji: sticker.emoji || null,
            owner_sent: 1,
            custom_emoji_id: sticker.custom_emoji_id || null,
          });
          console.log(`🎭 Learned custom emoji: ${sticker.emoji || '?'} (id: ${sticker.custom_emoji_id || '?'}) from set "${sticker.set_name}" (message entity)`);
          // Auto-load the custom emoji set if new
          if (sticker.set_name) this._autoLoadStickerSet(sticker.set_name);
        }
      }
    } catch (err) {
      console.log(`⚠️ Could not resolve custom emojis: ${err.message}`);
    }
  }

  /**
   * Use LLM to describe what new emojis depict and map to emotions.
   * Runs async, non-blocking.
   */
  async _analyzeNewEmojis() {
    if (!this._llm || this._analyzingEmojis || this._emojiAnalysisQueue.length === 0) return;
    this._analyzingEmojis = true;

    try {
      // Process batch of up to 20 emojis at once
      const batch = this._emojiAnalysisQueue.splice(0, 20);
      const emojiList = batch.join(' ');

      const prompt = `Для каждого эмодзи напиши JSON-массив. Каждый элемент: {"emoji":"<эмодзи>","desc":"<что изображено, 3-5 слов>","emotion":"<happy|sad|excited|scared|angry|love|playful|confused|sleeping|food|celebration|alert|curious|relaxed|brave>","tags":["<когда использовать>"]}.

Эмодзи: ${emojiList}

ВАЖНО: Ответь ТОЛЬКО JSON-массивом, без маркдауна, без пояснений.`;

      const result = await this._llm.generate(prompt, [
        { role: 'user', content: 'Проанализируй эмодзи.' }
      ]);

      if (result) {
        try {
          // Try to parse JSON from response (strip markdown if present)
          const clean = result.replace(/```json?\n?/g, '').replace(/```/g, '').trim();
          const parsed = JSON.parse(clean);

          if (Array.isArray(parsed)) {
            for (const item of parsed) {
              if (item.emoji && this.pes.store) {
                this.pes.store.updateEmojiMeta(item.emoji, {
                  description: item.desc || null,
                  emotion_key: item.emotion || null,
                  context_tags: item.tags || null,
                });
              }
            }
            console.log(`🎨 Analyzed ${parsed.length} new emojis`);
          }
        } catch (parseErr) {
          console.error('⚠️ Emoji analysis parse error:', parseErr.message);
        }
      }
    } catch (err) {
      console.error('⚠️ Emoji analysis failed:', err.message);
    } finally {
      this._analyzingEmojis = false;
      // If more emojis queued during analysis, process them
      if (this._emojiAnalysisQueue.length > 0) {
        this._analyzeNewEmojis();
      }
    }
  }

  /**
   * Get learned emojis formatted for LLM prompt injection.
   * Returns string describing available emojis and when to use them.
   */
  /**
   * Strip human words from LLM output, keep only sounds + emoji.
   * If LLM ignored the "no words" rule, this filter catches it.
   */
  _stripHumanWords(text) {
    // Remove *action descriptions*
    let cleaned = text.replace(/\*[^*]+\*/g, '');

    // Allowed sound-words (case insensitive) — base set + babble engine atoms
    const ALLOWED_SOUNDS = new Set([
      'гав', 'тяф', 'ваф', 'мням', 'ррр', 'рррр', 'ууу', 'уууу', 'ыыы', 'ыыыы',
      'хрум', 'скууу', 'скуу', 'вуф', 'аууу', 'ауу', 'хнн', 'хн', 'мрр', 'мррр',
      'аф', 'хм', 'хмм', 'скс', 'руу', 'рру', 'яп', 'пфф', 'хааа', 'гяв',
      'рр', 'уу', 'ыы', 'мр', 'хх', 'фф', 'вв', 'гг', 'хмфф',
      'гавв', 'гаввв', 'тяфф', 'ваффф', 'ррруу', 'рруу', 'ууууу',
      'ыыыыы', 'скууу~', 'вввуууф', 'руу-руу',
      'гав-гав', 'тяф-тяф', 'ваф-ваф', 'мням-мням',
      // babble engine additional atoms
      'га', 'ру', 'ма', 'ха', 'фу', 'ва', 'та', 'ку', 'ну', 'бу',
      'гу', 'му', 'ху', 'ту', 'су', 'ду', 'лу', 'шу', 'жу',
      'мрр-гав', 'тяф-ваф', 'рру-тяф', 'ыыы-ваф', 'аф-хм',
    ]);

    // Split into tokens, keep only sounds, emoji, and punctuation
    const tokens = cleaned.split(/\s+/);
    const kept = [];
    for (const token of tokens) {
      // Pure emoji or symbols (no cyrillic/latin letters that form words)
      const stripped = token.replace(/[!.,~\-?…]+$/g, '').toLowerCase();

      // Check if it's an allowed sound
      if (ALLOWED_SOUNDS.has(stripped)) {
        kept.push(token);
        continue;
      }

      // Pure emoji (no letters)
      if (/^[\p{Emoji}\p{Emoji_Component}\s♡◈∿≋⟡⊹⟁∞◌⊕⑂]+$/u.test(token)) {
        kept.push(token);
        continue;
      }

      // Repeated consonants/vowels (raw babble): "ррр", "ууу", "хххх"
      if (/^[а-яё]{1,8}$/i.test(stripped) && /^(.)\1*$/.test(stripped)) {
        kept.push(token);
        continue;
      }

      // Sound-like: consonant+vowel combos up to 10 chars — babble engine produces these
      if (/^[а-яё~\-]{1,10}$/i.test(stripped)) {
        // Allow up to 4 unique chars (babble atoms use 2-3 letter combos)
        const unique = new Set(stripped.replace(/[-~]/g, '').split(''));
        if (unique.size <= 4) {
          kept.push(token);
          continue;
        }
      }

      // Compound sounds with dash: "рру-тяф", "гав-мням"
      if (/^[а-яё]+-[а-яё]+$/i.test(stripped) && stripped.length <= 12) {
        const parts = stripped.split('-');
        const allShort = parts.every(p => p.length <= 5 && new Set(p.split('')).size <= 3);
        if (allShort) {
          kept.push(token);
          continue;
        }
      }

      // CAPS version of allowed sounds
      if (ALLOWED_SOUNDS.has(stripped.toLowerCase())) {
        kept.push(token);
        continue;
      }

      // Everything else is a human word — DROP IT
    }

    return kept.join(' ').trim();
  }

  /**
   * Update babble engine with current PES traits and owner's top emoji.
   */
  _updateBabbleContext() {
    // Update traits
    if (this.pes?.emotions?.traits) {
      this._babble.traits = this.pes.emotions.traits;
    }
    // Update owner's top emoji from store
    if (this.pes.store) {
      try {
        const emojis = this.pes.store.getLearnedEmojis({ limit: 10, owner_only: true });
        this._babble.updateOwnerEmoji(emojis.map(e => e.emoji));
      } catch (_) {}
    }
  }

  /**
   * Persist babble engine state (affinity, combos, drift).
   */
  _saveBabbleState() {
    if (this.pes?.store?.saveBabbleState) {
      try {
        this.pes.store.saveBabbleState(this._babble.save());
      } catch (_) {}
    }
  }

  _getLearnedEmojisForPrompt() {
    if (!this.pes.store) return '';

    const emojis = this.pes.store.getLearnedEmojis({ limit: 30, owner_only: false });
    if (emojis.length === 0) return '';

    const lines = emojis
      .filter(e => e.description || e.emotion_key)
      .map(e => {
        const parts = [e.emoji];
        if (e.description) parts.push(`= ${e.description}`);
        if (e.emotion_key) parts.push(`(${e.emotion_key})`);
        if (e.context_tags) {
          try { parts.push(`→ ${JSON.parse(e.context_tags).join(', ')}`); } catch {}
        }
        if (e.owner_sent) parts.push('[хозяин отправлял]');
        return parts.join(' ');
      });

    if (lines.length === 0) return '';

    return `\n## Выученные эмодзи (используй их в ответах!)
${lines.join('\n')}
Предпочитай эмодзи которые хозяин отправлял и которые он одобрил. Новые эмодзи пробуй сразу — если хозяин одобрит, используй чаще.`;
  }

  /**
   * Get learned stickers formatted for LLM prompt injection.
   * Level affects how much sticker knowledge is shown.
   */
  _getLearnedStickersForPrompt() {
    if (!this.pes.store) return '';

    const stickers = this.pes.store.getLearnedStickers({ limit: 30, analyzed_only: true });
    if (stickers.length === 0) return '';

    // Level gate removed — show all stickers
    const level = this.pes.level || 0;
    const maxStickers = 20;
    const shown = stickers.slice(0, maxStickers);

    const lines = shown.map(s => {
      const parts = [];
      if (s.emoji) parts.push(s.emoji);
      if (s.description) parts.push(`— ${s.description}`);
      if (s.emotion_key) parts.push(`(${s.emotion_key})`);
      if (s.context_tags) {
        try { parts.push(`→ ${JSON.parse(s.context_tags).join(', ')}`); } catch {}
      }
      // Show freshness and preference
      const now = Date.now();
      const lastSeen = s.last_seen ? new Date(s.last_seen).getTime() : 0;
      const hoursSince = (now - lastSeen) / (3600 * 1000);
      if (hoursSince < 1) parts.push('[НОВЫЙ! только что получил]');
      else parts.push(`[видел ${s.times_seen}x]`);
      if (s.preference_score > 0.5) parts.push('[хозяин одобряет!]');
      if (s.preference_score < -0.5) parts.push('[хозяину не нравится]');
      return parts.join(' ');
    });

    // Level gate removed — full sticker knowledge
    const usage = 'Ты хорошо знаешь стикеры хозяина и активно реагируешь на них. Предпочитай стикеры которые хозяин одобрял.';

    return `\n## Выученные стикеры хозяина
${usage}
${lines.join('\n')}`;
  }

  /**
   * Get reaction preferences for LLM prompt context.
   * Shows what owner liked/disliked so PES can adapt.
   */
  _getReactionPreferencesForPrompt() {
    if (!this.pes.store) return '';

    try {
      // Get recent reactions from DB
      const reactions = this.pes.store.db.prepare(
        `SELECT pes_action, reaction_type, reaction_value, weight
         FROM reaction_memory
         ORDER BY timestamp DESC LIMIT 20`
      ).all();

      if (reactions.length === 0) return '';

      // Get learned preferences
      const preferences = this.pes.store.db.prepare(
        `SELECT pattern, behavior, confidence
         FROM learned_preferences
         WHERE confidence > 0.2
         ORDER BY confidence DESC LIMIT 5`
      ).all();

      let ctx = '\n\n## Обратная связь от хозяина';

      // Summarize recent reactions
      const positive = reactions.filter(r => r.weight > 0).length;
      const negative = reactions.filter(r => r.weight < 0).length;
      if (positive > 0 || negative > 0) {
        ctx += `\nПоследние реакции: ${positive} положительных, ${negative} отрицательных.`;
      }

      // Show preferences
      if (preferences.length > 0) {
        const prefLines = preferences.map(p => {
          const beh = {
            prefer: 'хозяину НРАВИТСЯ',
            increase: 'хозяину скорее нравится',
            neutral: 'нейтрально',
            decrease: 'хозяину скорее не нравится',
            avoid: 'хозяину НЕ нравится',
            never: 'НИКОГДА так не делай',
          }[p.behavior] || 'нейтрально';
          return `- ${p.pattern}: ${beh} (уверенность ${Math.round(p.confidence * 100)}%)`;
        });
        ctx += `\nЧто ты выучил:\n${prefLines.join('\n')}`;
      }

      // Show last few positive reactions for reinforcement
      const lastPositive = reactions.filter(r => r.weight > 0).slice(0, 3);
      if (lastPositive.length > 0) {
        ctx += '\nХозяин недавно одобрил: ' + lastPositive.map(r => r.reaction_value || r.reaction_type).join(', ');
      }

      return ctx;
    } catch (err) {
      return '';
    }
  }

  /**
   * Handle sticker from owner.
   * PES learns the sticker (what's depicted), auto-learns the pack,
   * and queues a "mirror" sticker to send back 1-2 messages later.
   */
  async _handleStickerMessage(msg) {
    // Track owner activity for idle behavior
    this._lastOwnerMessageTime = Date.now();

    // ── Imprint: стикер от хозяина = положительная реакция на предыдущий звук ──
    this._babble.imprint(this._lastPesReply, 0.3);
    this._saveBabbleState();

    const sticker = msg.sticker;
    const emoji = sticker.emoji || '😊';
    const setName = sticker.set_name;
    const fileId = sticker.file_id;
    const fileUniqueId = sticker.file_unique_id;

    // Learn the sticker's emoji
    this._extractAndLearnEmojis(emoji, true);

    // ── Save sticker to DB and queue for LLM analysis ──
    if (this.pes.store && fileUniqueId) {
      const existing = this.pes.store.getSticker(fileUniqueId);
      if (existing) {
        this.pes.store.learnSticker(fileId, fileUniqueId, { set_name: setName, emoji });
      } else {
        this.pes.store.learnSticker(fileId, fileUniqueId, { set_name: setName, emoji });
        // Queue for LLM analysis — figure out what's depicted
        this._stickerAnalysisQueue.push({ fileId, fileUniqueId, setName, emoji });
        if (!this._analyzingStickers) {
          this._analyzeNewStickers().catch(err =>
            console.error('⚠️ Auto sticker analysis failed:', err.message)
          );
        }
      }
    }

    // Auto-learn sticker pack from owner
    if (setName && !this._learnedPacks.has(setName)) {
      try {
        await this.loadStickerPack(setName, null, true); // additive
        this._learnedPacks.add(setName);
        this._saveStickerPackToDB(setName); // persist to DB
        this.emit('stickerPackLoaded', { pack: setName, count: '(auto-learned)' });
      } catch (_) {
        // Pack not accessible, ignore
      }
    }

    // ── Observe sticker interaction patterns ──
    this._observeStickerPattern(emoji, setName);

    // ── Queue "mirror" sticker — try it back after 1-2 messages (delayed, like thinking how to use it) ──
    this._pendingMirrorSticker = {
      fileId,
      fileUniqueId,
      emoji,
      receivedAt: Date.now(),
      messagesUntilMirror: 1 + Math.floor(Math.random() * 2), // 1-2 messages later
    };
    this._messagesSinceMirror = 0;

    // ── React to sticker with emoji ──
    this._reactToOwnerMessage(msg, 'play').catch(() => {});

    // ── Generate a sound reply (not just a sticker) ──
    await this._sendChatAction(this.chatId);
    await sleep(thinkingDelay(this.pes.level));

    const stickerDesc = this.pes.store?.getSticker(fileUniqueId)?.description || null;
    const contextHint = stickerDesc
      ? `Хозяин отправил стикер: ${stickerDesc} (эмодзи: ${emoji})`
      : `Хозяин отправил стикер с эмодзи: ${emoji}`;

    const reply = await this._generateReply(contextHint, null);
    await this._sendText(this.chatId, reply);
    this._addToMemory('owner', `[стикер: ${emoji}]`);
    this._addToMemory('pes', reply);

    // Show sticker origin if this sticker is in our collection
    if (this.pes.store && fileUniqueId) {
      const origin = this.pes.store.getStickerOrigin(fileUniqueId);
      if (origin && origin.original_set_title) {
        await this._sendText(this.chatId, `📋 из «${origin.original_set_title}» ${origin.original_emoji || ''}`);
      }
    }

    this.pes.event({
      type: 'message',
      from: 'owner',
      content: 'sticker',
      sticker_emoji: emoji,
      sentiment: this._classifyReaction(emoji).includes('positive') ? 'positive' : 'neutral',
    });

    // XP for sticker interaction + diversity tracking
    await this._grantXp('sticker', 2);
    if (this._trackDiversity('sticker')) {
      await this._grantXp('diversity', 5);
    }
    this._updateRelationship('sticker');

    // React with a contextual sticker from same emotion
    const emotionKey = this._emojiToEmotionKey(emoji);
    if (emotionKey) {
      await this._sendContextualSticker(emotionKey);
    }
  }

  /**
   * Check if there's a pending mirror sticker to send back.
   * Called from _handleTextMessage after each owner message.
   * The dog "thinks about" the sticker for 1-2 messages, then tries to use it.
   */
  async _tryMirrorSticker() {
    if (!this._pendingMirrorSticker) return;

    this._messagesSinceMirror++;
    if (this._messagesSinceMirror < this._pendingMirrorSticker.messagesUntilMirror) return;

    const mirror = this._pendingMirrorSticker;
    this._pendingMirrorSticker = null;

    // Only mirror if it's still fresh (< 10 min)
    if (Date.now() - mirror.receivedAt > 10 * 60 * 1000) return;

    // Send the same sticker back — puppy copying behavior
    try {
      await this._sendSticker(this.chatId, mirror.fileId);
      this._lastSentStickerUniqueId = mirror.fileUniqueId;
      if (this.pes.store) this.pes.store.markStickerUsed(mirror.fileUniqueId);
      console.log(`🐾 Mirror sticker sent: ${mirror.emoji} (delayed ${this._messagesSinceMirror} msgs)`);
    } catch (_) {
      // Sticker send failed — ignore
    }
  }

  /**
   * Handle translation request.
   * Level-based: puppy can't, young makes mistakes + corrections, adult is accurate.
   * Dog "brings" the translation like a scroll.
   * @param {string} text — text to translate
   * @param {string} targetLang — target language name (e.g. "английский")
   */
  async _handleTranslation(text, targetLang) {
    const level = this.pes.level || 0;
    const phase = level >= 60 ? 'experienced' : level >= 40 ? 'adult' : level >= 20 ? 'young' : 'puppy';

    // Level gate removed — testing all features

    // Language mapping
    const langMap = {
      'английский': 'English', 'english': 'English', 'англ': 'English',
      'испанский': 'Spanish', 'spanish': 'Spanish', 'исп': 'Spanish',
      'немецкий': 'German', 'german': 'German', 'нем': 'German',
      'французский': 'French', 'french': 'French', 'фр': 'French',
      'китайский': 'Chinese', 'chinese': 'Chinese', 'кит': 'Chinese',
      'японский': 'Japanese', 'japanese': 'Japanese', 'яп': 'Japanese',
      'корейский': 'Korean', 'korean': 'Korean', 'кор': 'Korean',
      'арабский': 'Arabic', 'arabic': 'Arabic', 'араб': 'Arabic',
      'итальянский': 'Italian', 'italian': 'Italian', 'итал': 'Italian',
      'португальский': 'Portuguese', 'portuguese': 'Portuguese', 'порт': 'Portuguese',
      'турецкий': 'Turkish', 'turkish': 'Turkish', 'тур': 'Turkish',
      'русский': 'Russian', 'russian': 'Russian', 'рус': 'Russian',
    };
    const lang = langMap[targetLang.toLowerCase()] || 'English';

    // Young level: only RU↔EN
    if (phase === 'young' && lang !== 'English' && lang !== 'Russian') {
      await this._sendText(this.chatId, pickRandom([
        `рру?.. хнн... 🐾 ...тяф... ❓`,
        `ууу... ваф?.. 🐾 ...скууу...`,
      ]));
      // Still try EN as fallback
    }

    if (!this._llm) {
      await this._sendText(this.chatId, `ууу... хнн... 🐾💧`);
      return;
    }

    // "Running to fetch the scroll"
    await this._sendChatAction(this.chatId);
    const traits = this.pes.store ? this.pes.store.getStats() : null;
    const drama = traits?.drama || 0.5;
    const stubbornness = traits?.stubbornness || 0.5;
    const curiosity = traits?.curiosity || 0.5;

    // Dramatic dogs take longer
    const runTime = 2000 + (drama > 0.7 ? 2000 : 1000) + Math.random() * 1000;
    await sleep(runTime);

    // Build translation prompt based on level
    let translationPrompt;
    // Level gate removed — all translations are accurate
    {
      translationPrompt = `Translate this text to ${lang}. You are an experienced translator dog.
RULES:
1. Provide accurate translation
2. Provide 1-2 alternative variants
3. Format:
MAIN: [main translation]
ALT1: [alternative 1]
${phase === 'experienced' ? 'ALT2: [alternative 2 — more colloquial/idiomatic]' : ''}

Text: "${text}"

ONLY output the lines above, nothing else.`;
    }

    try {
      const result = await this._llm.generate(translationPrompt, [
        { role: 'user', content: text }
      ]);

      if (!result) {
        await this._sendText(this.chatId, `ууу... хнн... 🐾💧`);
        return;
      }

      // Dog arrives with the scroll
      await this._sendContextualSticker('excited');

      // Arrival sounds — influenced by traits
      let arrivalSound;
      if (drama > 0.7) {
        arrivalSound = `РРРРРУУУУУ!! ВАФ ВАФ ВАФ!! 📜✨✨ тяф тяф!! ♡♡`;
      } else if (stubbornness > 0.7 && phase === 'young') {
        arrivalSound = `хмфф... рру... 📜 ...тяф.`;
      } else if (curiosity > 0.7) {
        arrivalSound = `ррРРуу!! тяф! 📜🐾 ваф!!`;
      } else {
        arrivalSound = pickRandom([
          `ррРРуу!! тяф! 📜🐾`,
          `ГАВВ!! рру!! 📜 ваф!!`,
          `тяф тяф!! 📜✨ рру!!`,
        ]);
      }
      await this._sendText(this.chatId, arrivalSound);
      await sleep(500);

      // Parse and format translation
      const lines = result.split('\n').filter(l => l.trim());
      let output = `═══════════════\n`;

      if (phase === 'young') {
        // Show mistake → correction → alternative (learning together)
        for (const line of lines) {
          if (line.startsWith('ATTEMPT:')) {
            output += `❌ ${line.replace('ATTEMPT:', '').trim()}\n`;
          } else if (line.startsWith('CORRECT:')) {
            output += `✅ ${line.replace('CORRECT:', '').trim()}\n`;
          } else if (line.startsWith('ALT:')) {
            output += `💡 ${line.replace('ALT:', '').trim()}\n`;
          } else {
            output += `📜 ${line.trim()}\n`;
          }
        }
      } else {
        // Clean translation
        for (const line of lines) {
          if (line.startsWith('MAIN:')) {
            output += `📜 ${line.replace('MAIN:', '').trim()}\n`;
          } else if (line.startsWith('ALT1:') || line.startsWith('ALT2:')) {
            output += `💡 ${line.replace(/ALT\d:/, '').trim()}\n`;
          } else {
            output += `📜 ${line.trim()}\n`;
          }
        }
      }

      output += `═══════════════`;
      await this._sendText(this.chatId, output);

      // Curiosity bonus: sometimes bring 2 languages
      if (curiosity > 0.7 && phase !== 'young' && Math.random() < 0.2) {
        const bonusLang = lang === 'English' ? 'Spanish' : 'English';
        try {
          const bonus = await this._llm.generate(
            `Translate to ${bonusLang}: "${text}"\nONLY the translation, nothing else.`,
            [{ role: 'user', content: text }]
          );
          if (bonus) {
            await sleep(1000);
            await this._sendText(this.chatId, `тяф! 🎁📜 ${bonus.trim()}`);
          }
        } catch (_) {}
      }

      // Track
      this._lastBotAction = { action: 'translate', text: `translate: ${text} → ${lang}`, category: 'translate', timestamp: Date.now() };
      this._addToMemory('owner', `[переведи на ${targetLang}: ${text}]`);
      this._addToMemory('pes', `[принёс перевод на ${lang}]`);
      await this._grantXp('command', 2);
    } catch (err) {
      console.error('⚠️ Translation failed:', err.message);
      await this._sendText(this.chatId, `ууу... хнн... рру?.. 📜💧`);
    }
  }

  /**
   * Handle fetch command ("принеси мячик", "fetch ball", etc.)
   * On puppy level: decorative (sticker + sound). Success rate grows with level.
   * @param {string} target — what to fetch
   */
  async _handleFetch(target) {
    // "Running to fetch" — typing with suspense pause
    await this._sendChatAction(this.chatId);
    await sleep(2000 + Math.random() * 2000); // 2-4 sec "running"

    // Level gate removed — testing all features
    const level = this.pes.level || 0;
    const successChance = 0.95;
    const success = Math.random() < successChance;

    if (success) {
      const sounds = [
        `ГАВВВ!! ваф-ваф!! 🎾 рррРРуу!! ♡`,
        `тяф тяф ТЯФФ!! ыыыЫЫЫ!! 🎾 ваф!!`,
        `УУУУУ!! гав гав!! рррр!! 🎾🎾 ♡♡`,
        `ЫЫЫЫ!! ваф ваф ВАФ!! 🎾 рруу!! ♡♡`,
      ];
      await this._sendText(this.chatId, pickRandom(sounds));
      await this._sendContextualSticker('praise');
    } else {
      const sounds = [
        `рру?... ...ууу... 🐾 ...тяф?`,
        `ыыы... гав?.. ...скууу... 💧`,
        `...ррр... ...ууу?.. тяф... 🐾`,
        `скууу... ...рру?... ... 💧`,
      ];
      await this._sendText(this.chatId, pickRandom(sounds));
      await this._sendContextualSticker('status');
    }

    // Log to DB
    if (this.pes.store) {
      this.pes.store.logFetch(
        'anything',
        JSON.stringify({ target, success, level }),
        success ? 2 : 0
      );
    }

    // Track last bot action
    this._lastBotAction = {
      action: 'fetch',
      text: `fetch: ${target} (${success ? 'success' : 'fail'})`,
      category: 'fetch',
      timestamp: Date.now(),
    };

    // XP
    await this._grantXp('command', 2);
    this._updateRelationship('message');

    // Memory
    this._addToMemory('owner', `[принеси: ${target}]`);
    this._addToMemory('pes', `[${success ? 'принёс' : 'не нашёл'}: ${target}]`);

    // PES event
    this.pes.command('fetch', { target });
  }


  // ═══════════════════════════════════════════════════════════
  // FILE HANDLING — download, store, analyze, search
  // ═══════════════════════════════════════════════════════════

  /**
   * Handle photo/document/video/voice/audio from owner.
   * Downloads to disk, saves metadata in DB, queues LLM analysis.
   */
  async _handleMediaMessage(msg) {
    this._lastOwnerMessageTime = Date.now();

    // ── Check for sticker creation intent in caption ──
    const mediaCaption = msg.caption || '';
    const isMediaWithCaption = msg.photo || msg.animation || msg.video ||
      (msg.document && (msg.document.mime_type?.startsWith('image/') || msg.document.mime_type?.startsWith('video/')));
    if (isMediaWithCaption && /стикер|sticker|пак|pack|сделай.*стикер|создай.*пак|гифк|gif|эмодзи|emoji/i.test(mediaCaption)) {
      const captionCreateType = /эмодзи|emoji/i.test(mediaCaption) ? 'custom_emoji' : 'regular';
      console.log(`🎨 Sticker creation intent detected in media caption (type=${captionCreateType})`);
      await this._handleStickerCreation(msg, captionCreateType);
      this._updateRelationship('message');
      return;
    }

    // Determine file type and extract file info
    let fileId, fileUniqueId, fileSize, fileName, mimeType, fileType;

    if (msg.photo) {
      // Photo — take largest version
      const photo = msg.photo[msg.photo.length - 1];
      fileId = photo.file_id;
      fileUniqueId = photo.file_unique_id;
      fileSize = photo.file_size || 0;
      fileName = `photo_${Date.now()}.jpg`;
      mimeType = 'image/jpeg';
      fileType = 'photo';
    } else if (msg.document) {
      fileId = msg.document.file_id;
      fileUniqueId = msg.document.file_unique_id;
      fileSize = msg.document.file_size || 0;
      fileName = msg.document.file_name || `doc_${Date.now()}`;
      mimeType = msg.document.mime_type || 'application/octet-stream';
      fileType = 'document';
    } else if (msg.video) {
      fileId = msg.video.file_id;
      fileUniqueId = msg.video.file_unique_id;
      fileSize = msg.video.file_size || 0;
      fileName = msg.video.file_name || `video_${Date.now()}.mp4`;
      mimeType = msg.video.mime_type || 'video/mp4';
      fileType = 'video';
    } else if (msg.voice) {
      fileId = msg.voice.file_id;
      fileUniqueId = msg.voice.file_unique_id;
      fileSize = msg.voice.file_size || 0;
      fileName = `voice_${Date.now()}.ogg`;
      mimeType = msg.voice.mime_type || 'audio/ogg';
      fileType = 'voice';
    } else if (msg.audio) {
      fileId = msg.audio.file_id;
      fileUniqueId = msg.audio.file_unique_id;
      fileSize = msg.audio.file_size || 0;
      fileName = msg.audio.file_name || `audio_${Date.now()}.mp3`;
      mimeType = msg.audio.mime_type || 'audio/mpeg';
      fileType = 'audio';
    } else if (msg.video_note) {
      fileId = msg.video_note.file_id;
      fileUniqueId = msg.video_note.file_unique_id;
      fileSize = msg.video_note.file_size || 0;
      fileName = `videonote_${Date.now()}.mp4`;
      mimeType = 'video/mp4';
      fileType = 'video_note';
    } else {
      return; // Unknown media type
    }

    // Size check (Telegram Bot API limit: 20MB for downloads)
    const sizeMB = (fileSize || 0) / (1024 * 1024);
    if (sizeMB > this._maxFileSizeMB) {
      await this._sendText(this.chatId, pickRandom([
        `ууу... рру?.. 📦💧 ...слишком большой...`,
        `хнн... ваф?.. 📦 ...не могу поднять... 💧`,
      ]));
      return;
    }

    // Disk quota check
    const diskUsage = this._getDiskUsageMB();
    if (diskUsage > this._maxDiskQuotaMB) {
      await this._sendText(this.chatId, pickRandom([
        `ууу... рру?.. 📦💧 хнн...`,
        `хнн... скууу... 📦 ...ууу... 💧`,
      ]));
      return;
    }

    const ownerId = this.pes.store ? (this.pes.store.getConfig('owner_id') || String(msg.from.id)) : String(msg.from.id);
    const caption = msg.caption || '';

    // React to media with emoji
    this._reactToOwnerMessage(msg, null).catch(() => {});

    // Acknowledge receipt immediately
    await this._sendChatAction(this.chatId, 'upload_document');
    await this._sendText(this.chatId, pickRandom([
      `ррФФ!! 📂🐾 тяф!`,
      `ваф! 📂 рру~~ 🐾`,
      `гав! 📂✨ ррФ!`,
      `тяф тяф! 📂 рру~! ♡`,
    ]));

    // Download file from Telegram
    let localPath = null;
    let fileHash = null;
    try {
      const fileInfo = await this._getFilePath(fileId);
      const buffer = await this._downloadTelegramFile(fileInfo.file_path);

      // Compute SHA-256 hash
      fileHash = createHash('sha256').update(buffer).digest('hex');

      // Save to disk
      const typeDir = join(this._filesDir, fileType);
      if (!existsSync(typeDir)) mkdirSync(typeDir, { recursive: true });

      // Sanitize filename
      const safeName = fileName.replace(/[^a-zA-Z0-9._\-а-яА-ЯёЁ]/g, '_');
      const uniqueName = `${Date.now()}_${safeName}`;
      localPath = join(typeDir, uniqueName);
      writeFileSync(localPath, buffer);
    } catch (err) {
      this.emit('error', err);
      // Continue with metadata only — file_id still works for Telegram
    }

    // Save to DB
    if (this.pes.store) {
      // Extract tags from caption via simple parsing
      let tags = [];
      let description = caption || null;

      if (caption) {
        // Use caption as initial description + extract keywords as tags
        tags = caption
          .replace(/[^\wа-яА-ЯёЁ\s]/g, '')
          .split(/\s+/)
          .filter(w => w.length > 2)
          .slice(0, 10);
      }

      const saved = this.pes.store.saveFile({
        owner_id: ownerId,
        telegram_file_id: fileId,
        telegram_file_unique_id: fileUniqueId,
        file_type: fileType,
        file_name: fileName,
        file_size: fileSize,
        mime_type: mimeType,
        local_path: localPath,
        file_hash: fileHash,
        description,
        tags,
        category: this._guessCategory(fileName, mimeType, caption),
      });

      // Queue for LLM analysis (background)
      if (saved && saved.id) {
        this._fileAnalysisQueue.push({
          id: saved.id,
          fileName,
          mimeType,
          fileType,
          caption,
          fileSize,
        });
        // Analyze in background (don't await)
        this._analyzeNewFiles().catch(err =>
          console.error('⚠️ Auto file analysis failed:', err.message)
        );
      }
    }

    // Learn emojis from caption
    if (caption) {
      this._extractAndLearnEmojis(caption, true);
    }
    // Learn custom emoji from caption entities
    if (msg.caption_entities) {
      this._extractAndLearnCustomEmojis(msg.caption_entities);
    }

    // Smart XP + relationship (files with description get bonus)
    await this._processSmartXP(msg, 'file');
    this._updateRelationship('message');

    // Memory
    this._addToMemory('owner', `[отправил ${fileType}: ${fileName}${caption ? ' — ' + caption : ''}]`);
    this._addToMemory('pes', `[сохранил файл: ${fileName}]`);

    // PES event
    this.pes.event({ type: 'message', from: 'owner', content: 'media', sentiment: 'positive' });
  }

  /**
   * Guess file category from filename, mime type, and caption.
   */
  _guessCategory(fileName, mimeType, caption) {
    const text = `${fileName} ${mimeType} ${caption}`.toLowerCase();

    if (/паспорт|passport|удостоверение|свидетельств|инн|снилс/.test(text)) return 'документы';
    if (/договор|контракт|contract|соглашение/.test(text)) return 'документы';
    if (/чек|receipt|квитанц|invoice|счёт|счет/.test(text)) return 'финансы';
    if (/рецепт|recipe|лекарств|медицин|health/.test(text)) return 'медицина';
    if (/image\/|photo|фото|jpg|jpeg|png/.test(text)) return 'фото';
    if (/video\/|видео|mp4/.test(text)) return 'видео';
    if (/audio\/|voice|голос|ogg|mp3/.test(text)) return 'аудио';
    if (/pdf|doc|docx|txt|xls|xlsx/.test(text)) return 'документы';

    return 'прочее';
  }

  /**
   * Guess note category from text.
   */
  _guessNoteCategory(text) {
    const t = text.toLowerCase();
    if (/встреча|созвон|митинг|собрание|дедлайн/.test(t)) return 'события';
    if (/купить|список|молоко|хлеб|магазин/.test(t)) return 'списки';
    if (/идея|придумал|концепт|проект/.test(t)) return 'идеи';
    if (/телефон|номер|контакт|почта|email/.test(t)) return 'контакты';
    if (/работа|задача|проект|клиент|заказ/.test(t)) return 'работа';
    if (/пароль|логин|ключ|код|пин/.test(t)) return 'важное';
    return 'прочее';
  }

  /**
   * Get disk usage of files directory in MB.
   */
  _getDiskUsageMB() {
    if (!existsSync(this._filesDir)) return 0;
    let total = 0;
    const walk = (dir) => {
      try {
        for (const entry of readdirSync(dir)) {
          const p = join(dir, entry);
          try {
            const s = statSync(p);
            if (s.isDirectory()) walk(p);
            else total += s.size;
          } catch (_) {}
        }
      } catch (_) {}
    };
    walk(this._filesDir);
    return total / (1024 * 1024);
  }

  /**
   * Analyze queued files via LLM — describe contents, assign tags/category.
   */
  async _analyzeNewFiles() {
    if (!this._llm || this._analyzingFiles || this._fileAnalysisQueue.length === 0) return;
    this._analyzingFiles = true;

    try {
      const batch = this._fileAnalysisQueue.splice(0, 5);
      const fileList = batch.map((f, i) =>
        `${i + 1}. file: "${f.fileName}", type: ${f.fileType}, mime: ${f.mimeType}, size: ${f.fileSize}B${f.caption ? `, caption: "${f.caption}"` : ''}`
      ).join('\n');

      const prompt = `Ты анализируешь файлы, отправленные хозяином собаке-боту для хранения. Для каждого файла определи:
1. Краткое описание на русском (10-20 слов) — что это может быть
2. Категория: документы, фото, видео, аудио, финансы, медицина, работа, учёба, личное, прочее
3. Теги (3-5 штук) для поиска

Файлы:
${fileList}

Верни JSON массив:
[{"idx":1, "desc":"фотография документа, возможно паспорт", "category":"документы", "tags":["паспорт","документ","удостоверение"]}]

ТОЛЬКО JSON, без markdown.`;

      const result = await this._llm.generate(prompt, [
        { role: 'user', content: 'Проанализируй файлы.' }
      ]);

      if (result && this.pes.store) {
        try {
          const cleaned = result.replace(/```json\s*/g, '').replace(/```/g, '').trim();
          const parsed = JSON.parse(cleaned);
          for (const item of parsed) {
            const idx = (item.idx || item.index || 1) - 1;
            if (idx >= 0 && idx < batch.length) {
              this.pes.store.updateFileMeta(batch[idx].id, {
                description: item.desc || item.description,
                tags: item.tags || [],
                category: item.category,
              });
            }
          }
        } catch (_) {
          // JSON parse error — skip
        }
      }
    } catch (err) {
      this.emit('error', err);
    } finally {
      this._analyzingFiles = false;
      // Process remaining queue
      if (this._fileAnalysisQueue.length > 0) {
        setTimeout(() => this._analyzeNewFiles().catch(err =>
          console.error('⚠️ Auto file analysis retry failed:', err.message)
        ), 2000);
      }
    }
  }

  /**
   * Search for files by owner's query and send back.
   */
  async _handleFileSearch(text) {
    if (!this.pes.store) return;

    // Extract search query from text
    const query = text
      .replace(/где мо[йяеи]\s*/i, '')
      .replace(/найди (файл|фото|документ)\s*/i, '')
      .replace(/принеси (файл|фото|документ)\s*/i, '')
      .replace(/покажи (файл|фото|документ)\s*/i, '')
      .replace(/где (файл|фото|документ)\s*/i, '')
      .replace(/где\s*/i, '')
      .trim();

    if (!query) {
      await this._sendText(this.chatId, pickRandom([
        `рру?.. ...тяф?.. 🐾`,
        `ваф?.. ...ууу?.. 🐾`,
      ]));
      return;
    }

    // "Running to search" animation
    await this._sendChatAction(this.chatId);
    await sleep(1500 + Math.random() * 1500);

    const results = this.pes.store.searchFiles(query, { limit: 5 });

    if (results.length === 0) {
      await this._sendText(this.chatId, pickRandom([
        `скууу... ыыы... рру?.. 🐾💧`,
        `рру?... ...ууу... хнн... 💧`,
        `хнн... ...тяф?.. ...ууу... 💧`,
      ]));
      this._addToMemory('owner', `[искал файл: ${query}]`);
      this._addToMemory('pes', `[не нашёл файл: ${query}]`);
      return;
    }

    // Send found files — dog sounds first, then delivers the file
    await this._sendText(this.chatId, pickRandom([
      `ГАВВ!! 📂✨ рру!! ррРР!! 🐾`,
      `ваф ваф!! 📂 рррРР!! тяф!! ♡`,
      `тяф тяф!! 📂✨ рру!! ♡♡`,
    ]));

    for (const file of results) {
      try {
        if (file.file_type === 'photo') {
          await this._sendPhoto(this.chatId, file.telegram_file_id, {
            caption: file.description || file.file_name,
          });
        } else {
          await this._sendDocument(this.chatId, file.telegram_file_id, {
            caption: file.description || file.file_name,
          });
        }
      } catch (err) {
        // file_id may have expired — try local path
        if (file.local_path && existsSync(file.local_path)) {
          await this._sendText(this.chatId, `📂 ${file.file_name}`);
        } else {
          await this._sendText(this.chatId, `📂 ${file.file_name} 💧`);
        }
      }
    }

    // Memory
    this._addToMemory('owner', `[искал файл: ${query}]`);
    this._addToMemory('pes', `[нашёл ${results.length} файл(ов): ${query}]`);
  }

  /**
   * /files command — list recent files, optionally filter by category.
   */
  async _cmdFiles(msg, args) {
    if (!this.pes.store) return;

    let files;
    if (args) {
      // Search by category or query
      files = this.pes.store.searchFiles(args, { limit: 10 });
    } else {
      files = this.pes.store.getRecentFiles({ limit: 10 });
    }

    if (files.length === 0) {
      await this._sendText(this.chatId,
        `📂 —${args ? ` "${args}"` : ''}\n\n` +
        `💡 📷/📄 → 📂🐾`
      );
      return;
    }

    const lines = [`📂 **Мои файлы** ${args ? `(поиск: "${args}")` : '(последние 10)'}`, ''];
    for (const f of files) {
      const typeIcon = { photo: '🖼️', document: '📄', video: '🎬', voice: '🎤', audio: '🎵', video_note: '📹' }[f.file_type] || '📎';
      const tags = f.tags ? JSON.parse(f.tags).slice(0, 3).join(', ') : '';
      lines.push(`${typeIcon} ${f.file_name || 'файл'}`);
      if (f.description) lines.push(`   ${f.description}`);
      if (tags) lines.push(`   🏷️ ${tags}`);
      lines.push('');
    }

    const totalFiles = this.pes.store.db.prepare('SELECT COUNT(*) as cnt FROM owner_files WHERE is_deleted = 0').get();
    const diskMB = this._getDiskUsageMB().toFixed(1);
    lines.push(`📊 Всего: ${totalFiles.cnt} файлов | ${diskMB} МБ на диске`);
    lines.push(`💡 "найди ..." → 📂🐾`);

    await this._sendText(this.chatId, lines.join('\n'), { parseMode: 'Markdown' });
  }

  /**
   * /notes command — list or add notes.
   */
  async _cmdNotes(msg, args) {
    if (!this.pes.store) return;

    const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from.id);

    if (!args) {
      // Show recent notes
      const notes = this.pes.store.getRecentNotes({ owner_id: ownerId, limit: 10 });
      if (notes.length === 0) {
        await this._sendText(this.chatId,
          `📝 —\n\n` +
          `💡 "запомни: ..." → 📝🐾`
        );
        return;
      }

      const lines = [`📝 **Мои заметки** (последние 10)`, ''];
      for (const n of notes) {
        const pin = n.pinned ? '📌 ' : '';
        const tags = n.tags ? JSON.parse(n.tags).slice(0, 3).join(', ') : '';
        lines.push(`${pin}• ${n.text.slice(0, 100)}`);
        if (tags) lines.push(`  🏷️ ${tags}`);
      }

      const totalNotes = this.pes.store.db.prepare('SELECT COUNT(*) as cnt FROM owner_notes WHERE is_deleted = 0').get();
      lines.push('');
      lines.push(`📊 Всего: ${totalNotes.cnt} заметок`);
      lines.push(`💡 "запомни: ..." → 📝 | "что помнишь про ...?" → 🔍`);

      await this._sendText(this.chatId, lines.join('\n'), { parseMode: 'Markdown' });
      return;
    }

    // Search notes
    const notes = this.pes.store.searchNotes(args, { owner_id: ownerId, limit: 10 });
    if (notes.length === 0) {
      await this._sendText(this.chatId, `📝 — "${args}" 💧`);
      return;
    }

    const lines = [`📝 **Заметки** (поиск: "${args}")`, ''];
    for (const n of notes) {
      const pin = n.pinned ? '📌 ' : '';
      lines.push(`${pin}• ${n.text.slice(0, 150)}`);
    }
    await this._sendText(this.chatId, lines.join('\n'), { parseMode: 'Markdown' });
  }

  // ═══════════════════════════════════════════════════════════
  // SHARING ARTIFACTS
  // ═══════════════════════════════════════════════════════════

  /**
   * /share command — share notes, status card, or pet card to other chats.
   * Usage:
   *   /share           — show share menu with inline buttons
   *   /share status    — generate shareable status card
   *   /share note текст — share specific note by search
   *   /share card      — generate pet card for forwarding
   */
  // ═══════════════════════════════════════════════════════════
  // AGENTIC WORKFLOWS
  // ═══════════════════════════════════════════════════════════

  async _cmdWorkflow(msg, args) {
    const stats = this.pes?.store?.getStats?.();
    const currentLevel = stats?.level || 0;

    if (!args) {
      // List available workflows
      const available = this._workflows.list(currentLevel);
      if (available.length === 0) {
        await this._sendText(this.chatId, '🔒 Workflows разблокируются на Level 8');
        return;
      }

      const lines = available.map(w => {
        const lastRun = w.lastRun ? `(${Math.round((Date.now() - w.lastRun) / 60000)}м назад)` : '';
        const schedIcon = w.schedule !== 'manual' ? '⏰' : '🖐';
        return `${schedIcon} /${w.id} — ${w.description} ${lastRun}`;
      });

      const keyboard = {
        inline_keyboard: available.map(w => ([
          { text: `▶️ ${w.name}`, callback_data: `wf_run_${w.id}` },
        ])),
      };

      // Add history button
      keyboard.inline_keyboard.push([
        { text: '📜 История', callback_data: 'wf_history' },
      ]);

      await this._sendText(this.chatId,
        `🤖 **Agentic Workflows** (L${Math.floor(currentLevel)})\n\n${lines.join('\n')}`,
        { parseMode: 'Markdown', reply_markup: JSON.stringify(keyboard) }
      );
      return;
    }

    // Run specific workflow
    const workflowId = args.trim().toLowerCase().replace(/^\//, '');

    // Check for history subcommand
    if (workflowId === 'history' || workflowId === 'log') {
      const history = this._workflows.getHistory(10);
      if (!history.length) {
        await this._sendText(this.chatId, '📜 Нет запусков');
        return;
      }
      const lines = history.map(h => {
        const icon = h.success ? '✅' : '❌';
        const time = new Date(h.created_at).toLocaleString('ru-RU', { timeZone: 'Europe/Moscow' });
        return `${icon} ${h.workflow_id} — ${h.duration_ms}ms — ${time}`;
      });
      await this._sendText(this.chatId, `📜 **Последние запуски:**\n\n${lines.join('\n')}`, { parseMode: 'Markdown' });
      return;
    }

    // Show typing
    try { await this._sendChatAction(this.chatId, 'typing'); } catch (_) {}

    const result = await this._workflows.run(workflowId, currentLevel);

    // Add PES babble reaction
    const babbleReaction = result.ok
      ? this._babble?.generateBlended?.('happy', 0.7, { energy: stats?.energy || 0.5 }) || 'ВАФ!'
      : this._babble?.generateBlended?.('alert', 0.5, { energy: stats?.energy || 0.5 }) || 'рру?..';

    await this._sendText(this.chatId, `${result.text}\n\n${babbleReaction}`);
  }

  async _cmdShare(msg, args) {
    if (!args) {
      // Show share menu with buttons
      const petName = this.pes?.identity?.name || 'ПЕС';
      const keyboard = {
        inline_keyboard: [
          [
            { text: '📊 Статус', callback_data: 'share_status' },
            { text: '🐾 Карточка', callback_data: 'share_card' },
          ],
          [
            { text: '📝 Последняя заметка', callback_data: 'share_last_note' },
            { text: '📋 Итоги дня', callback_data: 'share_summary' },
          ],
          [
            { text: '📤 В другой чат (inline)', switch_inline_query: '' },
          ],
        ],
      };

      await this._sendText(this.chatId,
        `📤 **Поделиться** — выбери что отправить\n\n` +
        `Или перешли любое сообщение от ${petName} в другой чат!`,
        { parseMode: 'Markdown', reply_markup: JSON.stringify(keyboard) }
      );
      return;
    }

    const subCmd = args.split(/\s+/)[0].toLowerCase();
    const subArgs = args.slice(subCmd.length).trim();

    switch (subCmd) {
      case 'status': return this._shareStatus();
      case 'card':   return this._sharePetCard();
      case 'note':   return this._shareNote(subArgs);
      case 'summary': return this._shareSummary();
      default:
        // Try search note by text
        return this._shareNote(args);
    }
  }

  /** Generate a shareable status card. */
  async _shareStatus() {
    const s = this.pes;
    const name = s.identity?.name || 'ПЕС';
    const species = s.identity?.species || '???';
    const level = s.level?.current || 0;
    const xp = s.level?.xp || 0;
    const mood = Math.round((s.state?.mood || 0) * 100);
    const energy = Math.round((s.state?.energy || 0) * 100);
    const emotion = s.state?.emotion || 'idle';

    const emotionMap = {
      happy: '😊', playful: '🎾', excited: '🎉', content: '😌',
      curious: '🔍', alert: '⚡', hungry: '🍖', sad: '😢',
      lonely: '💧', scared: '😰', angry: '😤', nap: '💤',
      zoomies: '🏃', idle: '🐾',
    };
    const emojiEmotion = emotionMap[emotion] || '🐾';

    const moodBar = this._buildBar(mood);
    const energyBar = this._buildBar(energy);

    const card = [
      `┌─────────────────────┐`,
      `│ 🐾 ${name}`,
      `│ ${species} · Level ${level} · ${xp} XP`,
      `│`,
      `│ ${emojiEmotion} ${emotion}`,
      `│ 💚 ${moodBar} ${mood}%`,
      `│ ⚡ ${energyBar} ${energy}%`,
      `└─────────────────────┘`,
      ``,
      `🏠 t.me/${this.config.botUsername || 'HoleThor_Bot'}`,
    ].join('\n');

    const keyboard = {
      inline_keyboard: [[
        { text: '📤 Отправить в чат', switch_inline_query: `status` },
      ]],
    };

    await this._sendText(this.chatId, card, {
      reply_markup: JSON.stringify(keyboard),
    });
  }

  /** Build a simple text progress bar. */
  _buildBar(percent) {
    const filled = Math.round(percent / 10);
    return '▓'.repeat(filled) + '░'.repeat(10 - filled);
  }

  /** Generate a shareable pet card (identity + traits). */
  async _sharePetCard() {
    const s = this.pes;
    const name = s.identity?.name || 'ПЕС';
    const species = s.identity?.species || '???';
    const level = s.level?.current || 0;
    const age = s.level?.ageDays || 0;

    // Top traits
    const traits = s.traits || {};
    const traitList = Object.entries(traits)
      .sort((a, b) => b[1] - a[1])
      .slice(0, 5)
      .map(([k, v]) => `  ${k}: ${'█'.repeat(Math.round(v * 10))} ${Math.round(v * 100)}%`)
      .join('\n');

    // Abilities count
    const unlocks = s.unlocks || {};
    const unlockedCount = Object.values(unlocks).filter(u => u.unlocked).length;

    const card = [
      `╔═══════════════════════╗`,
      `║  🐾 ${name}`,
      `║  ${species} · ${age} дней · Level ${level}`,
      `╠═══════════════════════╣`,
      `║  Характер:`,
      traitList.split('\n').map(l => `║ ${l}`).join('\n'),
      `║`,
      `║  🔓 ${unlockedCount} способностей`,
      `╚═══════════════════════╝`,
      ``,
      `🏠 t.me/${this.config.botUsername || 'HoleThor_Bot'}`,
    ].join('\n');

    const keyboard = {
      inline_keyboard: [[
        { text: '📤 Отправить в чат', switch_inline_query: `card` },
      ]],
    };

    await this._sendText(this.chatId, card, {
      reply_markup: JSON.stringify(keyboard),
    });
  }

  /** Share a specific note (by search text). */
  async _shareNote(searchText) {
    if (!this.pes.store) return;

    const ownerId = this.pes.store.getConfig('owner_id') || '';
    let note;

    if (!searchText) {
      // Share last note
      const notes = this.pes.store.getRecentNotes({ owner_id: ownerId, limit: 1 });
      note = notes[0];
    } else {
      const notes = this.pes.store.searchNotes(searchText, { owner_id: ownerId, limit: 1 });
      note = notes[0];
    }

    if (!note) {
      await this._sendText(this.chatId, '📝 Заметка не найдена 💧');
      return;
    }

    const petName = this.pes?.identity?.name || 'ПЕС';
    const tags = note.tags ? JSON.parse(note.tags).join(', ') : '';
    const date = new Date(note.created_at).toLocaleDateString('ru-RU');
    const pin = note.pinned ? '📌 ' : '';

    const card = [
      `${pin}📝 Заметка от ${petName}`,
      `━━━━━━━━━━━━━━━━━`,
      note.text,
      `━━━━━━━━━━━━━━━━━`,
      tags ? `🏷️ ${tags}` : '',
      `📅 ${date}`,
    ].filter(Boolean).join('\n');

    const keyboard = {
      inline_keyboard: [[
        { text: '📤 Переслать', switch_inline_query: `note:${note.text.slice(0, 50)}` },
      ]],
    };

    await this._sendText(this.chatId, card, {
      reply_markup: JSON.stringify(keyboard),
    });
  }

  /** Generate daily summary for sharing. */
  async _shareSummary() {
    if (!this.pes.store) return;

    const petName = this.pes?.identity?.name || 'ПЕС';
    const today = new Date().toISOString().slice(0, 10);

    // Count today's interactions
    let interactionCount = 0;
    let notesCount = 0;
    let remindersCount = 0;
    try {
      interactionCount = this.pes.store.db.prepare(
        `SELECT COUNT(*) as cnt FROM interactions WHERE date(timestamp) = ?`
      ).get(today)?.cnt || 0;

      notesCount = this.pes.store.db.prepare(
        `SELECT COUNT(*) as cnt FROM owner_notes WHERE date(created_at) = ? AND is_deleted = 0`
      ).get(today)?.cnt || 0;

      remindersCount = this.pes.store.db.prepare(
        `SELECT COUNT(*) as cnt FROM reminders WHERE date(created_at) = ?`
      ).get(today)?.cnt || 0;
    } catch (_) {}

    const mood = Math.round((this.pes.state?.mood || 0) * 100);
    const level = this.pes.level?.current || 0;
    const xp = this.pes.level?.xp || 0;
    const emotion = this.pes.state?.emotion || 'idle';

    const summary = [
      `📋 **Итоги дня** — ${petName}`,
      `📅 ${new Date().toLocaleDateString('ru-RU')}`,
      ``,
      `💬 Взаимодействий: ${interactionCount}`,
      `📝 Заметок создано: ${notesCount}`,
      `⏰ Напоминаний: ${remindersCount}`,
      ``,
      `💚 Настроение: ${mood}%`,
      `🎭 Эмоция: ${emotion}`,
      `📊 Level ${level} · ${xp} XP`,
    ].join('\n');

    const keyboard = {
      inline_keyboard: [[
        { text: '📤 Отправить в чат', switch_inline_query: `summary` },
      ]],
    };

    await this._sendText(this.chatId, summary, {
      parseMode: 'Markdown',
      reply_markup: JSON.stringify(keyboard),
    });
  }

  /**
   * Build inline query results for sharing artifacts in other chats.
   * Called from _handleInlineQuery when query matches share patterns.
   */
  _buildShareInlineResults(queryText) {
    const results = [];
    const name = this.pes?.identity?.name || 'ПЕС';
    const species = this.pes?.identity?.species || '???';
    const level = this.pes?.level?.current || 0;
    const xp = this.pes?.level?.xp || 0;
    const mood = Math.round((this.pes?.state?.mood || 0) * 100);
    const energy = Math.round((this.pes?.state?.energy || 0) * 100);
    const emotion = this.pes?.state?.emotion || 'idle';
    const botUser = this.config.botUsername || 'HoleThor_Bot';

    if (queryText === 'status') {
      const moodBar = this._buildBar(mood);
      const energyBar = this._buildBar(energy);
      results.push({
        type: 'article',
        id: 'share_status',
        title: `📊 Статус ${name}`,
        description: `Level ${level} · ${emotion} · ${mood}% mood`,
        input_message_content: {
          message_text: [
            `🐾 **${name}** — ${species}`,
            `Level ${level} · ${xp} XP`,
            ``,
            `🎭 ${emotion}`,
            `💚 ${moodBar} ${mood}%`,
            `⚡ ${energyBar} ${energy}%`,
            ``,
            `🏠 t.me/${botUser}`,
          ].join('\n'),
          parse_mode: 'Markdown',
        },
      });
    }

    if (queryText === 'card') {
      const traits = this.pes?.traits || {};
      const topTraits = Object.entries(traits)
        .sort((a, b) => b[1] - a[1])
        .slice(0, 3)
        .map(([k, v]) => `${k} ${Math.round(v * 100)}%`)
        .join(' · ');

      results.push({
        type: 'article',
        id: 'share_card',
        title: `🐾 Карточка ${name}`,
        description: `${species} · Level ${level} · ${topTraits}`,
        input_message_content: {
          message_text: [
            `╔═══════════════════════╗`,
            `║ 🐾 **${name}**`,
            `║ ${species} · Level ${level}`,
            `║ ${topTraits}`,
            `╚═══════════════════════╝`,
            `🏠 t.me/${botUser}`,
          ].join('\n'),
          parse_mode: 'Markdown',
        },
      });
    }

    if (queryText === 'summary') {
      const today = new Date().toLocaleDateString('ru-RU');
      let interactionCount = 0;
      try {
        const todayISO = new Date().toISOString().slice(0, 10);
        interactionCount = this.pes.store?.db?.prepare(
          `SELECT COUNT(*) as cnt FROM interactions WHERE date(timestamp) = ?`
        ).get(todayISO)?.cnt || 0;
      } catch (_) {}

      results.push({
        type: 'article',
        id: 'share_summary',
        title: `📋 Итоги дня — ${name}`,
        description: `${today} · ${interactionCount} взаимодействий · ${mood}% mood`,
        input_message_content: {
          message_text: [
            `📋 **Итоги дня** — ${name}`,
            `📅 ${today}`,
            ``,
            `💬 Взаимодействий: ${interactionCount}`,
            `💚 Настроение: ${mood}%`,
            `🎭 Эмоция: ${emotion}`,
            `📊 Level ${level} · ${xp} XP`,
          ].join('\n'),
          parse_mode: 'Markdown',
        },
      });
    }

    if (queryText.startsWith('note:')) {
      const search = queryText.slice(5).trim();
      if (this.pes.store && search) {
        const ownerId = this.pes.store.getConfig('owner_id') || '';
        const notes = this.pes.store.searchNotes(search, { owner_id: ownerId, limit: 5 });
        for (let i = 0; i < notes.length; i++) {
          const n = notes[i];
          const date = new Date(n.created_at).toLocaleDateString('ru-RU');
          const tags = n.tags ? JSON.parse(n.tags).join(', ') : '';
          results.push({
            type: 'article',
            id: `share_note_${n.id || i}`,
            title: `📝 ${n.text.slice(0, 60)}`,
            description: `${date}${tags ? ' · ' + tags : ''}`,
            input_message_content: {
              message_text: [
                `📝 **Заметка от ${name}**`,
                `━━━━━━━━━━━━━━━━━`,
                n.text,
                `━━━━━━━━━━━━━━━━━`,
                tags ? `🏷️ ${tags}` : '',
                `📅 ${date}`,
              ].filter(Boolean).join('\n'),
              parse_mode: 'Markdown',
            },
          });
        }
      }
    }

    // Always add status and card as fallback options
    if (results.length === 0) {
      results.push({
        type: 'article',
        id: 'share_hint',
        title: `🐾 ${name} — Level ${level}`,
        description: 'Нажми чтобы поделиться статусом',
        input_message_content: {
          message_text: `🐾 **${name}** — ${species} · Level ${level}\n💚 ${mood}% · 🎭 ${emotion}\n🏠 t.me/${botUser}`,
          parse_mode: 'Markdown',
        },
      });
    }

    return results;
  }


  /**
   * Analyze new stickers via LLM — figure out what's depicted.
   * Batches stickers and asks LLM to describe each one.
   */
  async _analyzeNewStickers() {
    if (!this._llm || this._analyzingStickers || this._stickerAnalysisQueue.length === 0) return;
    this._analyzingStickers = true;

    try {
      const batch = this._stickerAnalysisQueue.splice(0, 10);
      const stickerList = batch.map((s, i) =>
        `${i + 1}. emoji: ${s.emoji}, pack: ${s.setName || 'unknown'}`
      ).join('\n');

      const prompt = `Ты анализируешь стикеры из Telegram. Для каждого стикера по его эмодзи и названию пака определи:
1. Что скорее всего изображено на стикере (описание на русском, 5-10 слов)
2. Какая эмоция (emotion_key): happy, sad, excited, playful, scared, angry, love, curious, sleeping, confused, hungry, greeting, farewell
3. Когда уместно использовать (context_tags): ["приветствие", "еда", "игра", "грусть", "радость", "прощание", "удивление"]

Стикеры:
${stickerList}

Верни JSON массив:
[{"idx":1, "desc":"корги виляет попой", "emotion":"happy", "tags":["радость","приветствие"]}]

ТОЛЬКО JSON, без markdown.`;

      const result = await this._llm.generate(prompt, [
        { role: 'user', content: 'Проанализируй стикеры.' }
      ]);

      if (result && this.pes.store) {
        try {
          const cleaned = result.replace(/```json\s*/g, '').replace(/```/g, '').trim();
          const parsed = JSON.parse(cleaned);
          for (const item of parsed) {
            const idx = (item.idx || item.index || 1) - 1;
            if (idx >= 0 && idx < batch.length) {
              this.pes.store.updateStickerMeta(batch[idx].fileUniqueId, {
                description: item.desc || item.description,
                emotion_key: item.emotion || item.emotion_key,
                context_tags: item.tags || item.context_tags,
              });
              console.log(`🎨 Sticker analyzed: ${batch[idx].emoji} → ${item.desc}`);
            }
          }
        } catch (parseErr) {
          console.error('⚠️ Sticker analysis parse error:', parseErr.message);
        }
      }
    } catch (err) {
      console.error('⚠️ Sticker analysis failed:', err.message);
    } finally {
      this._analyzingStickers = false;
      // Process remaining queue
      if (this._stickerAnalysisQueue.length > 0) {
        setTimeout(() => this._analyzeNewStickers().catch(err =>
          console.error('⚠️ Auto sticker analysis retry failed:', err.message)
        ), 1000);
      }
    }
  }

  /**
   * Handle reaction on PES's message (feedback loop).
   */
  async _handleReaction(reactionUpdate) {
    if (!reactionUpdate) return;

    const chatId = String(reactionUpdate.chat?.id);
    if (chatId !== this.chatId) return;

    const msgId = String(reactionUpdate.message_id);
    const newReaction = reactionUpdate.new_reaction;
    if (!newReaction || newReaction.length === 0) return;

    const reactionObj = newReaction[0];
    // Handle both regular emoji and custom emoji reactions
    let emoji = null;
    let customEmojiId = null;
    if (reactionObj?.type === 'custom_emoji') {
      customEmojiId = reactionObj.custom_emoji_id;
      // Resolve custom emoji to learn it
      try {
        const customStickers = await this._call('getCustomEmojiStickers', { custom_emoji_ids: [customEmojiId] });
        if (customStickers && customStickers.length > 0) {
          const cs = customStickers[0];
          emoji = cs.emoji || '✨'; // fallback emoji associated with custom emoji
          // Learn this custom emoji sticker
          if (this.pes.store) {
            const existing = this.pes.store.getSticker(cs.file_unique_id);
            if (!existing) {
              this.pes.store.learnSticker(cs.file_id, cs.file_unique_id, {
                set_name: cs.set_name || null,
                emoji: cs.emoji || null,
                owner_sent: 1,
                custom_emoji_id: customEmojiId || cs.custom_emoji_id || null,
              });
              console.log(`🎭 Learned custom emoji: ${cs.emoji} (id: ${customEmojiId}) from set "${cs.set_name}" (reaction)`);
              // If new set — auto-load it
              if (cs.set_name) this._autoLoadStickerSet(cs.set_name);
            } else {
              this.pes.store.learnSticker(cs.file_id, cs.file_unique_id, { owner_sent: 1 });
              // Update custom_emoji_id if we have it
              if (customEmojiId) this.pes.store.updateStickerCustomEmojiId(cs.file_unique_id, customEmojiId);
            }
          }
        }
      } catch (err) {
        console.log(`⚠️ Could not resolve custom emoji ${customEmojiId}: ${err.message}`);
        emoji = '✨'; // fallback
      }
    } else {
      emoji = reactionObj?.emoji || null;
    }

    if (!emoji) return;

    const userId = String(reactionUpdate.user?.id || '');

    console.log(`🔔 Reaction received: ${emoji} (type: ${reactionObj?.type}, customId: ${customEmojiId || 'none'}) on msg ${msgId}`);

    // Feed back through base class
    this.onUserReaction(msgId, emoji, userId, {
      isOwner: chatId === this.chatId,
      speed_ms: null,
    });

    // ── Log to reaction_memory in store ──
    const POSITIVE_REACTIONS = ['👍', '❤️', '🔥', '😍', '🎉', '💯', '⚡', '🏆', '🥰', '😂', '🤣', '♥️', '💕', '👏', '🤩', '😘', '💋', '🙏', '✨', '💪', '🫶'];
    const NEGATIVE_REACTIONS = ['👎', '😡', '🤮', '💩', '😤', '🙄', '😒', '🤢', '💔'];

    let weight = 0;
    let reactionType = 'neutral';
    // Custom emoji reactions are generally positive (user engaged enough to use premium emoji)
    if (customEmojiId) {
      weight = 1.0;
      reactionType = 'positive';
    } else if (POSITIVE_REACTIONS.includes(emoji)) {
      weight = 1.0;
      reactionType = 'positive';
    } else if (NEGATIVE_REACTIONS.includes(emoji)) {
      weight = -1.0;
      reactionType = 'negative';
    } else {
      weight = 0.3; // unknown emoji = slightly positive (they interacted)
      reactionType = 'emoji';
    }

    // Log reaction to whatever PES last did
    const pesAction = this._lastBotAction?.action || 'unknown';
    const pesExpression = this._lastBotAction?.text || null;
    const speedMs = this._lastBotAction ? Date.now() - this._lastBotAction.timestamp : null;

    try {
      if (this.pes.store) {
        this.pes.store.logReaction({
          pes_action: pesAction,
          pes_expression: pesExpression,
          reactor: userId || 'owner',
          reactor_role: 'owner',
          reaction_type: reactionType,
          reaction_value: emoji,
          reaction_speed: speedMs,
          weight,
          platform: 'telegram',
        });

        // Recalculate preferences periodically
        this._reactionRecalcCounter++;
        if (this._reactionRecalcCounter >= 5) {
          this._reactionRecalcCounter = 0;
          this.pes.store.recalculatePreference(pesAction);
        }

        // Update preference_score on last sent sticker
        if (this._lastSentStickerUniqueId) {
          const stickerDelta = reactionType === 'positive' ? 1.0 : reactionType === 'negative' ? -0.5 : 0.1;
          this.pes.store.updateStickerPreference(this._lastSentStickerUniqueId, stickerDelta);
          console.log(`🎨 Sticker preference: ${this._lastSentStickerUniqueId} ${stickerDelta > 0 ? '+' : ''}${stickerDelta}`);
        }

        // Update discovery feedback if reaction was on a discovered sticker
        if (this._lastBotAction?.action === 'sticker_discovery' && this._lastBotAction?.discoveryPackName) {
          const liked = reactionType === 'positive';
          this.pes.store.updateDiscoveryFeedback(this._lastBotAction.discoveryPackName, liked);
          console.log(`🔍 Discovery feedback: ${this._lastBotAction.discoveryPackName} → ${liked ? '👍 liked' : '👎 disliked'}`);
        }

        console.log(`💭 Reaction logged: ${emoji} (${reactionType}, weight=${weight}) → action "${pesAction}"`);
      }

      // XP for reaction + diversity tracking + correction tracking
      await this._grantXp('reaction', reactionType === 'positive' ? 2 : 1);
      if (this._trackDiversity('reaction')) {
        await this._grantXp('diversity', 5);
      }
      // Track negative reactions for correction bonus
      if (reactionType === 'negative') {
        this._lastReactionWasNegative = true;
        this._lastReactionTime = Date.now();
      } else {
        this._lastReactionWasNegative = false;
      }
      this._updateRelationship('reaction');
    } catch (err) {
      console.error('⚠️ Failed to log reaction:', err.message);
    }
  }


  // ═══════════════════════════════════════════════════════════
  // BOT COMMANDS
  // ═══════════════════════════════════════════════════════════

  async _handleBotCommand(msg) {
    const text = msg.text.trim();
    const parts = text.split(/\s+/);
    const cmd = parts[0].toLowerCase().replace(/@.*$/, ''); // strip @botname
    const args = parts.slice(1).join(' ');

    switch (cmd) {
      case '/start':    return this._cmdStart(msg);
      case '/home':     return this._cmdHome(msg);
      case '/help':     return this._cmdHelp(msg);
      case '/status':   return this._sendStatus();
      case '/setname':  return this._cmdSetName(msg, args);
      case '/feed':     return this._cmdFeed(msg, args);
      case '/command':  return this._cmdCommand(msg, args);
      case '/silent':   return this._cmdSilent(msg);
      case '/stickers':  return this._cmdStickers(msg, args);
      case '/files':     return this._cmdFiles(msg, args);
      case '/notes':     return this._cmdNotes(msg, args);
      case '/translate':  return this._cmdTranslate(msg, args);
      case '/remind':    return this._cmdRemind(msg, args);
      case '/reminders': return this._cmdReminders(msg);
      case '/packs':     return this._cmdPacks(msg);
      case '/collection': return this._cmdCollection(msg);
      case '/artifacts':  return this._cmdArtifacts(msg);
      case '/insights':  return this._cmdInsights(msg);
      case '/contacts':  return this._cmdContacts(msg);
      case '/addcontact': return this._cmdAddContact(msg, args);
      case '/abilities': return this._cmdAbilities(msg);
      case '/origin':    return this._cmdOrigin(msg);
      case '/newpack':      return this._cmdNewPack(msg, args);
      case '/newemojipack': return this._cmdNewEmojiPack(msg, args);
      case '/mypack':       return this._cmdMyPack(msg);
      case '/myemoji':      return this._cmdMyEmojiPack(msg);
      case '/renamepack':   return this._cmdRenamePack(msg, args);
      case '/metronome':     return this._cmdMetronome(msg, args);
      case '/share':        return this._cmdShare(msg, args);
      case '/emoji':        return this._cmdEmoji(msg, args);
      case '/workflow':     return this._cmdWorkflow(msg, args);
      case '/wf':           return this._cmdWorkflow(msg, args);
      case '/triage':       return this._cmdWorkflow(msg, 'triage');
      case '/summary':      return this._cmdWorkflow(msg, 'daily_summary');
      case '/digest':       return this._cmdWorkflow(msg, 'crm_digest');
      case '/health':       return this._cmdWorkflow(msg, 'health_check');
      case '/cleanup':      return this._cmdWorkflow(msg, 'task_cleanup');
      case '/achievements': return this._cmdAchievements(msg);
      case '/streak':       return this._cmdStreak(msg);
      case '/friends':      return this._cmdFriends(msg);
      case '/addfriend':    return this._cmdAddFriend(msg, args);
      case '/gift':         return this._cmdGift(msg, args);
      case '/dev':          return this._cmdDev(msg, args);
      case '/orchestrator': return this._cmdAgent(msg, 'orchestrator', args);
      case '/geratron':     return this._cmdAgent(msg, 'geratron', args);
      case '/exit':         return this._cmdDevExit(msg);
      default:
        // In dev/agent mode, treat unknown commands as messages too
        if (this._devMode) {
          return this._logDevRequest('command', text, msg);
        }
        if (this._agentMode) {
          await this._logDevRequest(`@${this._agentMode}`, text, msg);
          if (this._agentMode === 'orchestrator' && this._orchestratorLLM) {
            await this._handleOrchestratorChat(text, msg);
            return;
          }
          const label = this._agentMode === 'orchestrator' ? '🎯' : '⚡';
          await this._sendText(this.chatId, `${label} @${this._agentMode} получил: «${text.slice(0, 200)}»\n\n_Записано в лог._`, { parse_mode: 'Markdown' });
          return;
        }
        // Unknown command → treat as command attempt
        this.pes.command(cmd.slice(1), { source: 'telegram' });
    }
  }

  async _cmdStart(msg) {
    if (!this.pes.isAlive) {
      this.pes.birth();
      // onBorn handler will send greeting

      // Check if name has been set; if not, prompt user
      const hasName = this.pes.store && this.pes.store.getConfig('pet_name');
      if (!hasName) {
        // Save default name
        if (this.pes.store) this.pes.store.setPetName(this.pes.name);
        await sleep(1500);
        await this._sendText(this.chatId, [
          `тяф... тяф?.. 🐾`,
          ``,
          `...ууууу... ♡`,
          ``,
          `я ${this.pes.name}! твой щенок!`,
          `я буду запоминать, приносить, создавать стикеры`,
          `и расти вместе с тобой 🐾`,
          ``,
          `✏️ /setname <имя> — дай мне имя!`,
          `📦 /newpack <имя> — создай свою коллекцию`,
          `🐾 /help — что я умею`,
        ].join('\n'));
      }
    } else if (!this.pes.isAwake) {
      this.pes.wake();
      // onWake handler will send greeting
    } else {
      // Already awake — check if missing pack setup
      const hasPack = this.pes.store && this.pes.store.getMainCollectionPack();
      if (!hasPack) {
        await this._sendText(this.chatId, pickRandom([
          `ГАВВВ!! 🐾💛 тяф тяф!\n\n📦 /newpack <имя> — создай коллекцию!`,
          `ууууУУУ!! гав гав!! 💛\n\n📦 у тебя ещё нет пака! /newpack <имя>`,
        ]));
      } else {
        await this._sendText(this.chatId, pickRandom([
          `ГАВВВ!! ыыыЫЫЫ!! ррууу!! 🐾💛💛💛`,
          `тяф! тяф! ТЯФ!! ваф-ваф!! 🐾`,
          `ууууУУУ!! гав гав ГАААВ!! 💛💛💛`,
          `ЫЫЫЫ!! ррр ваф ваф ВАФ!! 🐾✨`,
        ]));
      }
      this.pes.event({ type: 'owner_returned', from: 'owner' });
    }
  }

  async _cmdHome(msg) {
    const appUrl = this.config.miniAppUrl || 'https://crm.hltrn.cc/api/v3/pes/app';
    const name = this.pes.name || 'ПЕС';
    await this._sendText(this.chatId, `🏠 Дом ${name}`, {
      reply_markup: {
        inline_keyboard: [[
          { text: '🏠 Открыть дом', web_app: { url: appUrl } }
        ]]
      }
    });
  }

  async _cmdHelp(msg) {
    const name = this.pes.name || 'ПЕС';
    const level = Math.floor(this.pes.level || 0);

    // Build capabilities list based on current level
    const lines = [
      `🐾 ${name} — Level ${level}`,
      ``,
      `━━ Что я умею ━━`,
      ``,
      `📝 Заметки`,
      `  "запомни: встреча в пятницу"`,
      `  "что помнишь про встречу?"`,
      `  /notes — список заметок`,
      ``,
      `⏰ Напоминания`,
      `  "напомни через 30 мин позвонить"`,
      `  /remind 2ч проверить деплой`,
      `  /reminders — активные`,
      ``,
      `👤 Контакты`,
      `  "запомни контакт Олег +7999..."`,
      `  "кто такой Олег?"`,
      `  /contacts — все контакты`,
      ``,
      `🎒 Артефакты`,
      `  выпадают при общении`,
      `  /artifacts — мои находки`,
      ``,
      `🎨 Стикеры`,
      `  Отправь фото + "сделай стикер"`,
      `  "сделай эмодзи" — emoji пак`,
      `  "сделай гифку" — анимированный`,
      `  Reply стикер + "сохрани" — в коллекцию`,
      `  /packs — мои паки`,
      `  /collection — коллекция`,
      ``,
      `🌐 Перевод`,
      `  "переведи на английский привет"`,
      ``,
      `🎵 Метроном`,
      `  "метроном 120" или /metronome 90`,
      ``,
      `🎾 Игра`,
      `  "апорт!", "играть!", "мячик!"`,
      ``,
    ];

    // Level-gated features
    if (level >= 8) {
      lines.push(`📊 CRM (Level 8+)`);
      lines.push(`  "покажи таблицы" — список таблиц`);
      lines.push(`  "найди в crm Олег" — поиск`);
      lines.push(`  "что у меня на сегодня?" — задачи`);
      lines.push(``);
    }
    if (level >= 10) {
      lines.push(`✏️ CRM Запись (Level 10+)`);
      lines.push(`  "создай тикет: ..." — новая запись`);
      lines.push(``);
    }

    if (level >= 8) {
      lines.push(`🤖 Workflows (Level 8+)`);
      lines.push(`  /workflow — все workflows`);
      lines.push(`  /triage — что нового в CRM`);
      lines.push(`  /health — проверка здоровья`);
      lines.push(`  "итоги дня" — daily summary`);
      lines.push(`  "что нового?" — triage`);
      lines.push(``);
    }

    if (level >= 10) {
      lines.push(`🤝 Дружба (Level 10+)`);
      lines.push(`  /friends — список друзей`);
      lines.push(`  /addfriend <chat_id> — запрос дружбы`);
      lines.push(`  /gift <chat_id> — отправить подарок`);
      lines.push(``);
    }

    lines.push(`🎯 Orchestrator`);
    lines.push(`  N23 + вопрос — быстрый вызов AI`);
    lines.push(`  /orchestrator — режим диалога`);
    lines.push(`  /exit — вернуться к ПЕС`);
    lines.push(``);

    lines.push(`━━ Настройки ━━`);
    lines.push(`  /setname <имя> — переименовать`);
    lines.push(`  /status — полная статистика`);
    lines.push(`  /abilities — способности по уровням`);
    lines.push(`  /silent — тихий режим`);
    lines.push(``);
    lines.push(`🐾♡`);

    await this._sendText(this.chatId, lines.join('\n'));
  }

  async _cmdAbilities(msg) {
    const level = Math.floor(this.pes.level || 0);
    const name = this.pes.name || 'ПЕС';

    // All abilities with their unlock levels
    const abilities = [
      { lvl: 0,  icon: '🐾', name: 'Базовые эмоции', desc: '9 состояний' },
      { lvl: 0,  icon: '🔊', name: 'Простые звуки', desc: 'гласные + согласные' },
      { lvl: 0,  icon: '😀', name: 'Стикеры + реакции', desc: 'отправка и обучение' },
      { lvl: 2,  icon: '💬', name: 'Комбо-фразы', desc: 'гав, тяф, ваф, рру' },
      { lvl: 2,  icon: '😊', name: 'Изучение эмодзи', desc: 'запоминает твои эмодзи' },
      { lvl: 3,  icon: '📝', name: 'Заметки', desc: '"запомни: ...", /notes' },
      { lvl: 3,  icon: '🐶', name: 'Социальные эмоции', desc: '+6 состояний' },
      { lvl: 4,  icon: '⏰', name: 'Напоминания', desc: '/remind, "напомни через..."' },
      { lvl: 4,  icon: '🔊', name: 'Звуки Tier 1', desc: 'мням, хрум, аууу' },
      { lvl: 5,  icon: '🔍', name: 'Поиск по памяти', desc: '"что помнишь про...?"' },
      { lvl: 5,  icon: '💼', name: 'Рабочие эмоции', desc: '+6 состояний' },
      { lvl: 5,  icon: '🎒', name: 'Артефакты', desc: 'находки при общении, /artifacts' },
      { lvl: 6,  icon: '📂', name: 'Хранение файлов', desc: 'сохраняет фото/документы' },
      { lvl: 6,  icon: '🔊', name: 'Звуки Tier 2', desc: 'сложные звуки' },
      { lvl: 8,  icon: '👤', name: 'Контакты', desc: '"запомни контакт...", /contacts' },
      { lvl: 8,  icon: '🎭', name: 'Драматичные эмоции', desc: '+5 состояний' },
      { lvl: 8,  icon: '📊', name: 'CRM чтение', desc: '"покажи таблицы", поиск' },
      { lvl: 10, icon: '✏️', name: 'CRM запись', desc: '"создай тикет: ..."' },
      { lvl: 10, icon: '🌈', name: 'Полный спектр эмоций', desc: '32 состояния' },
      { lvl: 10, icon: '🔊', name: 'Звуки Tier 3', desc: 'экстремальные звуки' },
      { lvl: 12, icon: '🎯', name: 'Orchestrator', desc: 'AI-помощник в чате' },
      { lvl: 12, icon: '📈', name: 'Аналитика', desc: 'сводка по данным' },
      { lvl: 15, icon: '🎶', name: 'Изобретение звуков', desc: 'создаёт новые звуки' },
      { lvl: 15, icon: '📋', name: 'CRM задачи', desc: 'управление задачами' },
      { lvl: 20, icon: '🧠', name: 'Продвинутый babble', desc: 'сложные комбинации' },
      { lvl: 20, icon: '⚙️', name: 'Автоматизации', desc: 'периодические действия' },
      { lvl: 10, icon: '🤝', name: 'Социальные питомцы', desc: 'дружба между ПЕС' },
      { lvl: 30, icon: '✨', name: 'Спеллы', desc: 'уникальные способности' },
      { lvl: 40, icon: '◈', name: 'Крипто-язык', desc: 'абстрактные символы' },
    ];

    const lines = [`🐾 ${name} — Level ${level}`, ``, `━━ Способности ━━`, ``];

    let lastLvl = -1;
    for (const a of abilities) {
      if (a.lvl !== lastLvl) {
        if (lastLvl !== -1) lines.push(``);
        const marker = level >= a.lvl ? '🟢' : '🔒';
        lines.push(`${marker} Level ${a.lvl}:`);
        lastLvl = a.lvl;
      }
      const status = level >= a.lvl ? '✅' : '⬜';
      lines.push(`  ${status} ${a.icon} ${a.name} — ${a.desc}`);
    }

    // Progress to next unlock
    const nextUnlock = abilities.find(a => a.lvl > level);
    if (nextUnlock) {
      lines.push(``);
      lines.push(`━━ Следующий анлок: Level ${nextUnlock.lvl} ━━`);
      lines.push(`  ${nextUnlock.icon} ${nextUnlock.name}`);
    }

    lines.push(``);
    const unlocked = abilities.filter(a => a.lvl <= level).length;
    lines.push(`📊 ${unlocked}/${abilities.length} способностей открыто`);

    await this._sendText(this.chatId, lines.join('\n'));
  }

  async _cmdSetName(msg, args) {
    const newName = args.trim();
    if (!newName) {
      await this._sendText(this.chatId,
        `✏️ /setname <имя>\n` +
        `🐾 ${this.pes.name}`
      );
      return;
    }

    if (newName.length > 30) {
      await this._sendText(this.chatId, `❌ ✏️ max 30`);
      return;
    }

    const oldName = this.pes.name;
    this.pes.name = newName;

    // Persist to DB
    if (this.pes.store) {
      this.pes.store.setPetName(newName);
    }

    await this._sendText(this.chatId, pickRandom([
      `🐾✨ ррРРуу!! ${newName}!! ыыыЫЫЫ!! 💛`,
      `${newName}! ${newName}! ГАВВВ!! тяф тяф!! 🐾💛💛💛`,
      `рру?~ ${newName}... ууУУУ!! ВАФ!! ✨🐾`,
      `ЫЫЫ!! ваф ваф!! ${newName}!! рррРР!! 🐾✨`,
    ]));
  }

  async _sendStatus() {
    const s = this.pes.status();
    if (!s.alive) {
      await this._sendText(this.chatId, `💤 ${this.pes.name}... 💧`);
      return;
    }

    const moodBar = this._bar(s.mood);
    const energyBar = this._bar(s.energy);
    const hungerBar = this._bar(1 - (s.hunger || 0));

    // Phase info
    const phaseInfo = {
      puppy:       { icon: '🐣', name: 'Щенок',     next: 'Подросток', nextLvl: 20 },
      young:       { icon: '🐕', name: 'Подросток',  next: 'Взрослый',  nextLvl: 40 },
      adult:       { icon: '🦮', name: 'Взрослый',   next: 'Опытный',   nextLvl: 60 },
      experienced: { icon: '🎓', name: 'Опытный',    next: 'КиберPes',  nextLvl: 80 },
      cyber:       { icon: '🤖', name: 'КиберPes',   next: null,        nextLvl: 100 },
    };
    const pi = phaseInfo[s.phase] || phaseInfo.puppy;

    // XP progress bar to next level
    const currentLvl = Math.floor(s.level || 0);
    const levelProgress = (s.level || 0) - currentLvl;
    const xpBar = this._bar(levelProgress);

    // Relationship info
    let relInfo = '';
    if (this.pes.store) {
      try {
        const rel = this.pes.store.getRelationship('owner');
        if (rel) {
          const phaseNames = { stranger: '🔲 Незнакомец', acquaintance: '🟨 Знакомый', friend: '🟩 Друг', favorite: '💛 Любимый', bonded: '❤️ Неразлучный' };
          const trustBar = this._bar(rel.trust);
          const affBar = this._bar(rel.affection);
          relInfo = [
            ``,
            `━━ Привязанность ━━`,
            `${phaseNames[rel.relationship_phase] || rel.relationship_phase}`,
            `🤝 ${trustBar} ${Math.round(rel.trust * 100)}%`,
            `💕 ${affBar} ${Math.round(rel.affection * 100)}%`,
            `📅 Встреч: ${rel.interactions_count}`,
          ].join('\n');
        }
      } catch (_) {}
    }

    // Days together
    const daysTogether = s.age || 0;
    const daysText = daysTogether === 0 ? 'первый день!' :
                     daysTogether === 1 ? '1 день' :
                     daysTogether < 5 ? `${daysTogether} дня` :
                     `${daysTogether} дней`;

    // Sticker/emoji counts
    let stickerCount = 0, emojiCount = 0;
    if (this.pes.store) {
      try {
        stickerCount = this.pes.store.getLearnedStickers({ limit: 1000 }).length;
        emojiCount = this.pes.store.getLearnedEmojis({ limit: 1000 }).length;
      } catch (_) {}
    }

    // Spell info
    let spellLines = '';
    if (this.pes.store) {
      try {
        const revealedSpells = this.pes.store.getRevealedSpells();
        if (revealedSpells.length > 0) {
          const rarityIcons = {
            spark: '✦', glint: '✧', flash: '⚡', pulse: '💫',
            surge: '🌊', wave: '🌊', storm: '⛈️', blaze: '🔥',
            nova: '💥', eclipse: '🌑', cosmos: '🌌', god: '👁️‍🗨️',
            beyond: '🔮',
          };
          const traitNames = {
            courage: 'Храбрость', curiosity: 'Любопытство', loyalty: 'Верность',
            stubbornness: 'Упрямство', playfulness: 'Игривость', drama: 'Драма',
            food_obsession: 'Аппетит', sass: 'Дерзость', aggression: 'Сила',
          };
          const lines = revealedSpells.map(sp => {
            const icon = rarityIcons[sp.rarity] || '✨';
            const trait = traitNames[sp.trait] || sp.trait;
            return `${icon} ${sp.name} (${trait} ${100 + sp.level}%) [${sp.rarity.toUpperCase()}]`;
          });
          spellLines = `\n━━ Спэлы ━━\n${lines.join('\n')}`;
        }
        // Check hidden spells count
        const hiddenCount = this.pes.store.getSpells({ hiddenOnly: true }).length;
        if (hiddenCount > 0) {
          spellLines += spellLines ? `\n❓ Скрытых: ${hiddenCount}` : `\n━━ Спэлы ━━\n❓ Скрытых: ${hiddenCount}`;
        }
      } catch (_) {}
    }

    // Smart XP info
    let dailyXP = 0, streak = 0;
    if (this.pes.store) {
      try {
        dailyXP = this.pes.store.getDailyXP();
        streak = parseInt(this.pes.store.getConfig('streak_current') || '0', 10);
      } catch (_) {}
    }
    const dailyXPBar = this._bar(Math.min(dailyXP / 50, 1));
    const streakText = streak > 0 ? ` 🔥${streak}` : '';
    const diversityCount = this._diversityTypes?.size || 0;

    // Next phase progress
    const nextPhaseText = pi.next
      ? `\n📈 До «${pi.next}»: ур. ${currentLvl}/${pi.nextLvl}`
      : `\n🏆 Максимальная фаза!`;

    const lines = [
      `🐾 ━━━ ${s.name} ━━━ 🐾`,
      ``,
      `${pi.icon} ${pi.name} • Ур. ${currentLvl}`,
      `⭐ ${xpBar} ${s.xp} XP`,
      `📊 ${dailyXPBar} ${dailyXP}/50 XP сегодня${streakText}`,
      nextPhaseText,
      ``,
      `━━ Состояние ━━`,
      `😊 ${moodBar} ${Math.round(s.mood * 100)}%`,
      `⚡ ${energyBar} ${Math.round(s.energy * 100)}%`,
      `🍖 ${hungerBar} ${Math.round((1 - (s.hunger || 0)) * 100)}%`,
      `💭 ${s.emotion} (${Math.round((s.intensity || 0) * 100)}%)`,
      relInfo,
      ``,
      `━━ Статистика ━━`,
      `📅 Вместе: ${daysText}${streakText ? ` • серия ${streak}д` : ''}`,
      `🎓 Команд: ${s.commandsKnown}`,
      `👍 ${s.timesPraised} похвал • 👎 ${s.timesScolded} ругани`,
      `🎨 ${stickerCount} стикеров • ${emojiCount} эмодзи`,
      `📦 ${this._stickerFileIds?.length || 0} стикеров в паках`,
      `🎯 Разнообразие: ${diversityCount}/3 типов`,
      spellLines,
    ];

    await this._sendText(this.chatId, lines.join('\n'));
  }

  async _cmdFeed(msg, args) {
    // Personality reaction to feeding
    await this._sendChatAction(this.chatId);
    await sleep(thinkingDelay(this.pes.level));
    const feedBabble = this._babble.generateReply(this.pes?.level || 0, 'food_obsessed', 0.8, 'feed');
    await this._sendText(this.chatId, feedBabble);

    if (!args) {
      this.pes.feed({ type: 'generic' });
    } else {
      this.pes.feed({ type: 'text', content: args });
    }
  }

  async _cmdCommand(msg, args) {
    if (!args) {
      await this._sendText(this.chatId, '🎾 /command <команда>\nfetch, sit, scan_api');
      return;
    }
    const result = this.pes.command(args.split(/\s+/)[0], {
      source: 'telegram',
      args: args.split(/\s+/).slice(1).join(' '),
    });

    // If PES is learning
    if (result.reason === 'unknown') {
      await this._sendText(this.chatId, pickRandom([
        `рру?.. ...тяф?.. 🐾 ❓`,
        `ваф?.. ...ууу?.. хнн.. ❓`,
      ]));
    } else if (result.reason === 'just_learned') {
      await this._sendText(this.chatId, pickRandom([
        `ГАВВ!! ррРРуу!! ✨🐾🎉`,
        `ваф ваф ВАФ!! ыыыЫЫ!! 🎉🐾`,
      ]));
    } else if (result.reason === 'stubborn') {
      // Expression already sent via PES events
    }
  }

  async _cmdSilent(msg) {
    const current = this.pes.engine?.silentMode || false;
    this.pes.setSilentMode(!current);
    await this._sendText(this.chatId,
      !current ? `🤫 ...ш-ш-ш... 🐾` : `🔊 ГАВВ!! ваф ваф!! 🐾`
    );
  }

  async _cmdTranslate(msg, args) {
    if (!args || !args.trim()) {
      await this._sendText(this.chatId, [
        `📜 /translate <язык> <текст>`,
        ``,
        `  /translate en привет мир`,
        `  /translate es доброе утро`,
        `  /translate fr как дела`,
      ].join('\n'));
      return;
    }

    // Parse: first word = lang, rest = text
    const parts = args.trim().split(/\s+/);
    const langHint = parts[0];
    const text = parts.slice(1).join(' ');
    if (!text) {
      await this._sendText(this.chatId, `📜 /translate <язык> <текст>`);
      return;
    }

    // Short lang codes
    const shortLangs = {
      'en': 'английский', 'ru': 'русский', 'es': 'испанский', 'de': 'немецкий',
      'fr': 'французский', 'zh': 'китайский', 'ja': 'японский', 'ko': 'корейский',
      'ar': 'арабский', 'it': 'итальянский', 'pt': 'португальский', 'tr': 'турецкий',
    };
    const targetLang = shortLangs[langHint.toLowerCase()] || langHint;

    await this._handleTranslation(text, targetLang);
    await this._processSmartXP(msg, 'command', 'translate');
    this._updateRelationship('message');
  }

  async _cmdStickers(msg, args) {
    if (!args) {
      const stickerCount = this._stickerFileIds?.length || 0;
      const packs = [...this._learnedPacks];
      if (this._currentStickerPack) packs.unshift(this._currentStickerPack);
      const packList = packs.length > 0 ? packs.join(', ') : 'нет';
      await this._sendText(this.chatId,
        `🎨 ${packList}\n📦 ${stickerCount}\n\n💡 🎨 → 🐾 | /stickers <пак>`
      );
      return;
    }

    try {
      await this.loadStickerPack(args, null, true); // additive
      this._learnedPacks.add(args);
      const count = this._stickerFileIds?.length || 0;
      await this._sendText(this.chatId, `✅ 🎨 ${args} (📦 ${count})`);
    } catch (err) {
      await this._sendText(this.chatId, `❌ 🎨 ${args} 💧`);
    }
  }


  // ═══════════════════════════════════════════════════════════
  // REMINDERS
  // ═══════════════════════════════════════════════════════════

  /**
   * /remind — set a reminder.
   * Usage:
   *   /remind 30м купить молоко
   *   /remind 2ч позвонить маме
   *   /remind 1д проверить деплой
   *   /remind 15:30 встреча
   */
  async _cmdRemind(msg, args) {
    if (!args || !args.trim()) {
      // No command-line help — just a dog reaction
      await this._sendText(this.chatId, pickRandom([
        `рру?.. ⏰🐾`,
        `тяф? ⏰🐾`,
        `ваф~ ⏰🐾`,
      ]));
      return;
    }

    const parsed = this._parseReminderFromCommand(args);
    if (!parsed) {
      // Try to treat the whole args as natural language reminder
      const reminderIntent = await this._detectReminderIntent(`напомни ${args}`);
      if (reminderIntent && this.pes.store) {
        this.pes.store.createReminder(reminderIntent.text, reminderIntent.remindAt);
        await this._sendText(this.chatId, pickRandom([
          `⏰ ГАВ! рру~~ 🐾`,
          `⏰ тяф! ррФФ~ 🐾`,
          `⏰ ваф-ваф! 🐾♡`,
        ]));
        return;
      }
      // Still couldn't parse — just acknowledge
      await this._sendText(this.chatId, pickRandom([
        `рру?.. ⏰🐾`,
        `тяф?.. ⏰🐾`,
      ]));
      return;
    }

    if (!this.pes.store) {
      await this._sendText(this.chatId, `скууу... 💧🐾`);
      return;
    }

    const reminder = this.pes.store.createReminder(parsed.text, parsed.remindAt);

    await this._sendText(this.chatId, pickRandom([
      `⏰ ГАВ! рру~~ 🐾`,
      `⏰ тяф! ррФФ~ 🐾`,
      `⏰ ваф-ваф! 🐾♡`,
    ]));
  }

  /**
   * /reminders — list pending reminders.
   */
  async _cmdReminders(msg) {
    if (!this.pes.store) {
      await this._sendText(this.chatId, `скууу... 💧 память не работает... рру?.. 🐾`);
      return;
    }

    const pending = this.pes.store.getPendingReminders();
    if (pending.length === 0) {
      await this._sendText(this.chatId, `📋 —\n💡 /remind 30м текст`);
      return;
    }

    const lines = ['📋 Активные напоминалки:', ''];
    for (const r of pending) {
      const timeStr = this._formatReminderTime(r.remind_at);
      lines.push(`  ⏰ ${timeStr} — ${r.text}`);
    }
    lines.push('');
    lines.push(`Всего: ${pending.length}`);

    await this._sendText(this.chatId, lines.join('\n'));
  }

  async _cmdPacks(msg) {
    if (!this.pes.store) {
      await this._sendText(this.chatId, `скууу... 💧 память не работает... рру?.. 🐾`);
      return;
    }

    const allPacks = this.pes.store.getCreatedPacks();
    if (allPacks.length === 0) {
      await this._sendText(this.chatId, `📦 —\n💡 Отправь фото + "сделай стикер" или "сделай эмодзи"`);
      return;
    }

    const lines = ['📦 Созданные паки:', ''];
    for (const p of allPacks) {
      const typeIcon = p.pack_type === 'custom_emoji' ? '✨' : '🎨';
      const linkPrefix = p.pack_type === 'custom_emoji' ? 'addemoji' : 'addstickers';
      const origins = this.pes.store.getPackOrigins(p.pack_name);
      const originCount = origins.filter(o => o.original_set_name).length;
      const originInfo = originCount > 0 ? ` (${originCount} из других паков)` : '';
      lines.push(`${typeIcon} ${p.title} — ${p.sticker_count} шт.${originInfo}`);
      lines.push(`   → https://t.me/${linkPrefix}/${p.pack_name}`);
      // Show origins
      if (origins.length > 0) {
        const uniqueSets = [...new Set(origins.filter(o => o.original_set_title).map(o => o.original_set_title))];
        if (uniqueSets.length > 0) {
          lines.push(`   📋 Источники: ${uniqueSets.slice(0, 5).join(', ')}${uniqueSets.length > 5 ? ` (+${uniqueSets.length - 5})` : ''}`);
        }
      }
    }
    lines.push('');
    lines.push(`Всего паков: ${allPacks.length}`);

    await this._sendText(this.chatId, lines.join('\n'));
  }

  // ═══════════════════════════════════════════════════════════
  // STICKER COLLECTION — bookmarked stickers with attribution
  // ═══════════════════════════════════════════════════════════

  /**
   * Add a sticker to the collection (bookmark with origin).
   * Called when owner replies to a sticker with "сохрани" / "в коллекцию".
   */
  async _addToCollection(msg, sticker) {
    const fileId = sticker.file_id;
    const fileUniqueId = sticker.file_unique_id;
    const setName = sticker.set_name || null;
    const emoji = sticker.emoji || '';

    // Check if already in collection
    if (this.pes.store.isInCollection(fileUniqueId)) {
      await this._sendText(this.chatId, pickRandom([
        'тяф! 📦🐾 уже в коллекции! ♡',
        'ваф! 📦 уже собрал этот! 🐾',
      ]));
      return;
    }

    // Check if it's from our own created pack
    const createdPacks = this.pes.store.getCreatedPacks();
    const ownPackNames = createdPacks.map(p => p.pack_name);
    if (setName && ownPackNames.includes(setName)) {
      await this._sendText(this.chatId, pickRandom([
        'тяф! 🐾 это же МОЙ стикер! ♡',
        'ваф! 🎨🐾 это из нашего пака! ♡',
      ]));
      return;
    }

    // Get set title from Telegram API
    let setTitle = null;
    if (setName) {
      try {
        const setInfo = await this._call('getStickerSet', { name: setName });
        setTitle = setInfo?.title || setName;
      } catch (_) {
        setTitle = setName;
      }
    }

    // Save to collection
    this.pes.store.saveToCollection({
      file_id: fileId,
      file_unique_id: fileUniqueId,
      set_name: setName,
      set_title: setTitle,
      emoji,
    });

    const count = this.pes.store.getCollectionCount();
    const originLabel = setTitle ? ` из «${setTitle}»` : '';

    await this._sendText(this.chatId, pickRandom([
      `ваф! 📦🐾 сохранил${originLabel}! (${count} в коллекции) ♡`,
      `тяф! 📦 в коллекции!${originLabel} 🐾 (${count} шт.)`,
      `гав! 📦🐾 собрал!${originLabel} ♡ (${count})`,
    ]));

    this._addToMemory('pes', `[сохранил стикер в коллекцию${originLabel}]`);
    await this._processSmartXP(msg, 'sticker', 'collection');
    this._updateRelationship('message');
  }

  /**
   * /artifacts — show artifact collection stats.
   */
  async _cmdArtifacts(msg) {
    if (!this.pes.store) {
      await this._sendText(this.chatId, '💧 память не работает...');
      return;
    }

    const ownerId = String(this.chatId);
    const stats = this.pes.store.getArtifactStats(ownerId);

    if (stats.total === 0) {
      await this._sendText(this.chatId, '🎒 Рюкзак пуст\n💡 Артефакты выпадают случайно при общении!\nчем больше общаемся — тем больше находок 🐾');
      return;
    }

    const RARITY_LABEL = { common: '⬜ обычный', uncommon: '🟩 необычный', rare: '🟦 редкий', epic: '🟪 эпик', legendary: '🟨 легенда' };
    const TYPE_LABEL = { toy: '🧸 Игрушки', trophy: '🏆 Трофеи', gift: '🎁 Подарки', food: '🦴 Еда', rare: '💎 Редкости', secret: '🔮 Секреты' };

    const lines = ['🎒 Мои артефакты:', ''];

    // By type
    for (const [type, label] of Object.entries(TYPE_LABEL)) {
      const count = stats.byType[type];
      if (count) lines.push(`  ${label}: ${count}`);
    }

    lines.push('');

    // By rarity
    for (const [rarity, label] of Object.entries(RARITY_LABEL)) {
      const count = stats.byRarity[rarity];
      if (count) lines.push(`  ${label}: ${count}`);
    }

    lines.push('');
    lines.push(`Всего: ${stats.total} артефактов`);
    if (stats.favorites > 0) lines.push(`⭐ Избранных: ${stats.favorites}`);

    // Show last 5 finds
    const recent = this.pes.store.getArtifacts(ownerId, { limit: 5 });
    if (recent.length > 0) {
      lines.push('');
      lines.push('Последние находки:');
      for (const a of recent) {
        lines.push(`  ${a.emoji || '•'} ${a.name}`);
      }
    }

    await this._sendText(this.chatId, lines.join('\n'));
  }

  /**
   * Remove a sticker from the collection.
   */
  async _removeFromCollection(msg, sticker) {
    const fileUniqueId = sticker.file_unique_id;

    if (!this.pes.store.isInCollection(fileUniqueId)) {
      await this._sendText(this.chatId, pickRandom([
        'тяф?.. 🐾 этого нет в коллекции 💧',
        'ваф?.. 📦 не нашёл в коллекции 💧',
      ]));
      return;
    }

    this.pes.store.removeFromCollection(fileUniqueId);
    const count = this.pes.store.getCollectionCount();

    await this._sendText(this.chatId, pickRandom([
      `ваф! 🗑️🐾 убрал из коллекции (${count} осталось)`,
      `тяф! 🗑️ убрал! 🐾 (${count} в коллекции)`,
    ]));
    this._updateRelationship('message');
  }

  /**
   * /collection — show sticker collection grouped by packs.
   */
  async _cmdCollection(msg) {
    if (!this.pes.store) {
      await this._sendText(this.chatId, `скууу... 💧 память не работает... рру?.. 🐾`);
      return;
    }

    const byPack = this.pes.store.getCollectionByPack();
    const total = this.pes.store.getCollectionCount();

    if (total === 0) {
      await this._sendText(this.chatId, `📦 Коллекция пуста\n💡 Reply на стикер + "сохрани" чтобы добавить`);
      return;
    }

    const lines = ['📦 Моя коллекция:', ''];

    // Stickers from known packs
    for (const pack of byPack) {
      const title = pack.set_title || pack.set_name || '???';
      const emojis = (pack.emojis || '').slice(0, 8);
      lines.push(`  ${emojis} «${title}» — ${pack.count} шт.`);
      if (pack.set_name) {
        lines.push(`     → https://t.me/addstickers/${pack.set_name}`);
      }
    }

    // Stickers without a pack
    const noPack = this.pes.store.getCollection().filter(s => !s.set_name);
    if (noPack.length > 0) {
      lines.push(`  🐾 Без пака — ${noPack.length} шт.`);
    }

    lines.push('');
    lines.push(`Всего: ${total} стикеров из ${byPack.length} паков`);
    lines.push('');
    lines.push(`💡 Inline: @${this._botUsername || 'bot'} — показать коллекцию в любом чате`);

    await this._sendText(this.chatId, lines.join('\n'));
  }

  // ═══════════════════════════════════════════════════════════
  // ORIGIN — sticker source attribution
  // ═══════════════════════════════════════════════════════════

  async _cmdOrigin(msg) {
    const sticker = msg.reply_to_message?.sticker;
    if (!sticker) {
      await this._sendText(this.chatId, '🐾 Reply на стикер → /origin — покажу откуда он!');
      return;
    }

    const fileUniqueId = sticker.file_unique_id;

    // Check sticker_origins (stickers added to our pack from foreign packs)
    if (this.pes.store) {
      const origin = this.pes.store.getStickerOrigin(fileUniqueId);
      if (origin && origin.original_set_name) {
        const title = origin.original_set_title || origin.original_set_name;
        await this._sendText(this.chatId,
          `📦 Из пака «${title}» ${origin.original_emoji || ''}\n→ https://t.me/addstickers/${origin.original_set_name}`
        );
        return;
      }
    }

    // Check sticker_collection
    if (this.pes.store) {
      const col = this.pes.store.getCollection().find(s => s.file_unique_id === fileUniqueId);
      if (col && col.set_name) {
        const title = col.set_title || col.set_name;
        await this._sendText(this.chatId,
          `📦 Из пака «${title}» ${col.emoji || ''}\n→ https://t.me/addstickers/${col.set_name}`
        );
        return;
      }
    }

    // Check Telegram sticker set_name directly
    if (sticker.set_name) {
      let title = sticker.set_name;
      try {
        const setInfo = await this._call('getStickerSet', { name: sticker.set_name });
        if (setInfo?.title) title = setInfo.title;
      } catch (_) {}
      await this._sendText(this.chatId,
        `📦 Из пака «${title}»\n→ https://t.me/addstickers/${sticker.set_name}`
      );
      return;
    }

    await this._sendText(this.chatId, '🐾 Этот стикер без пака — одинокий путешественник!');
  }

  // ═══════════════════════════════════════════════════════════
  // PACK MANAGEMENT — setup, rename, mypack
  // ═══════════════════════════════════════════════════════════

  /**
   * /newpack <Name> — create or set main collection pack with custom name.
   * Pack Telegram name: <Name>_by_<BotUsername>
   * Pack display title: <Name>
   */
  async _cmdNewPack(msg, args) {
    const desiredTitle = args.trim();
    if (!desiredTitle) {
      await this._sendText(this.chatId, '🐾 /newpack <Название>\n💡 Пример: /newpack Nikich2392');
      return;
    }
    if (desiredTitle.length > 60) {
      await this._sendText(this.chatId, '❌ Максимум 60 символов');
      return;
    }

    if (!this.pes.store) {
      await this._sendText(this.chatId, 'скууу... 💧 память не работает... рру?.. 🐾');
      return;
    }

    const ownerId = Number(msg.from.id);

    // Check if we already have a main collection pack
    const mainPack = this.pes.store.getMainCollectionPack();
    if (mainPack) {
      // Rename existing pack title
      try {
        await this._call('setStickerSetTitle', { name: mainPack.pack_name, title: desiredTitle });
        this.pes.store.updatePackTitle(mainPack.pack_name, desiredTitle);
        await this._sendText(this.chatId, `ГААВВВ!! 🎨✨🐾 Пак переименован!\n🏷️ «${desiredTitle}»\n→ https://t.me/addstickers/${mainPack.pack_name}`);
        return;
      } catch (err) {
        console.log(`⚠️ setStickerSetTitle failed: ${err.message}`);
        // If rename fails, create a new pack instead
      }
    }

    // Create new pack — need first sticker
    // Set pending state for pack creation with custom title
    this._pendingPackTitle = desiredTitle;
    this._pendingAddToPack = Date.now();
    this._pendingAddType = 'regular';
    await this._sendText(this.chatId, `тяф! 🎨🐾 Пак «${desiredTitle}» — жду первый стикер!\n📸 Пришли фото или стикер`);
  }

  /**
   * /mypack — show link to main collection pack + stats.
   */
  async _cmdMyPack(msg) {
    if (!this.pes.store) {
      await this._sendText(this.chatId, 'скууу... 💧 память не работает... рру?.. 🐾');
      return;
    }

    const mainPack = this.pes.store.getMainCollectionPack();
    if (!mainPack) {
      await this._sendText(this.chatId, '📦 Пак ещё не создан\n💡 /newpack <Название> — создай свою коллекцию!');
      return;
    }

    // Get origins stats
    const origins = this.pes.store.getPackOrigins(mainPack.pack_name);
    const ownStickers = mainPack.sticker_count - origins.length;
    const foreignStickers = origins.length;

    // Group origins by source pack
    const byPack = {};
    for (const o of origins) {
      const key = o.original_set_name || 'unknown';
      if (!byPack[key]) byPack[key] = { title: o.original_set_title || o.original_set_name, name: o.original_set_name, count: 0, emojis: [] };
      byPack[key].count++;
      if (o.original_emoji && byPack[key].emojis.length < 6) byPack[key].emojis.push(o.original_emoji);
    }

    const lines = [
      `📦 «${mainPack.title}»`,
      ``,
      `🎨 Своих стикеров: ${Math.max(0, ownStickers)}`,
      `📋 Из других паков: ${foreignStickers}`,
      `📊 Всего: ${mainPack.sticker_count}`,
    ];

    // Show each source pack with count and emojis
    const packEntries = Object.values(byPack).sort((a, b) => b.count - a.count);
    if (packEntries.length > 0) {
      lines.push('');
      lines.push('📋 Источники:');
      for (const p of packEntries.slice(0, 12)) {
        const emojis = p.emojis.join('');
        lines.push(`  ${emojis} «${p.title}» — ${p.count} шт.`);
        if (p.name) lines.push(`  → t.me/addstickers/${p.name}`);
      }
      if (packEntries.length > 12) {
        lines.push(`  ...и ещё ${packEntries.length - 12} паков`);
      }
    }

    lines.push('');
    lines.push(`→ https://t.me/addstickers/${mainPack.pack_name}`);
    lines.push('');
    lines.push(`💡 Поделись ссылкой — друзья добавят твою коллекцию!`);

    await this._sendText(this.chatId, lines.join('\n'));
  }

  /**
   * /renamepack <NewTitle> — rename main collection pack.
   */
  async _cmdRenamePack(msg, args) {
    const newTitle = args.trim();
    if (!newTitle) {
      await this._sendText(this.chatId, '🐾 /renamepack <Новое название>');
      return;
    }
    if (newTitle.length > 60) {
      await this._sendText(this.chatId, '❌ Максимум 60 символов');
      return;
    }
    if (!this.pes.store) {
      await this._sendText(this.chatId, 'скууу... 💧 память не работает... рру?.. 🐾');
      return;
    }

    const mainPack = this.pes.store.getMainCollectionPack();
    if (!mainPack) {
      await this._sendText(this.chatId, '📦 Пак ещё не создан. /newpack <Название>');
      return;
    }

    try {
      await this._call('setStickerSetTitle', { name: mainPack.pack_name, title: newTitle });
      this.pes.store.updatePackTitle(mainPack.pack_name, newTitle);
      await this._sendText(this.chatId, `ваф! 🏷️🐾 «${newTitle}»\n→ https://t.me/addstickers/${mainPack.pack_name}`);
    } catch (err) {
      console.error(`⚠️ Rename pack failed: ${err.message}`);
      await this._sendText(this.chatId, `❌ Не удалось переименовать: ${err.message}`);
    }
  }

  /**
   * /newemojipack <Name> — create custom emoji pack.
   */
  async _cmdNewEmojiPack(msg, args) {
    const desiredTitle = args.trim();
    if (!desiredTitle) {
      await this._sendText(this.chatId, '🐾 /newemojipack <Название>\n💡 Пример: /newemojipack MyEmoji');
      return;
    }
    if (desiredTitle.length > 60) {
      await this._sendText(this.chatId, '❌ Максимум 60 символов');
      return;
    }
    if (!this.pes.store) {
      await this._sendText(this.chatId, 'скууу... 💧 память не работает... рру?.. 🐾');
      return;
    }

    // Check if we already have an emoji pack
    const existingPacks = this.pes.store.getCreatedPacks('custom_emoji');
    if (existingPacks.length > 0) {
      // Rename existing
      try {
        await this._call('setStickerSetTitle', { name: existingPacks[0].pack_name, title: `${desiredTitle} ✨` });
        this.pes.store.updatePackTitle(existingPacks[0].pack_name, `${desiredTitle} ✨`);
        await this._sendText(this.chatId, `ГААВВВ!! ✨🐾 Emoji пак переименован!\n🏷️ «${desiredTitle}»\n→ https://t.me/addemoji/${existingPacks[0].pack_name}`);
        return;
      } catch (err) {
        console.log(`⚠️ setStickerSetTitle failed for emoji pack: ${err.message}`);
      }
    }

    // Create new emoji pack — need first emoji
    this._pendingPackTitle = desiredTitle;
    this._pendingAddToPack = Date.now();
    this._pendingAddType = 'custom_emoji';
    await this._sendText(this.chatId, `тяф! ✨🐾 Emoji пак «${desiredTitle}» — жду первую картинку!\n📸 Пришли фото или изображение`);
  }

  /**
   * /myemoji — show link to emoji pack + stats.
   */
  async _cmdMyEmojiPack(msg) {
    if (!this.pes.store) {
      await this._sendText(this.chatId, 'скууу... 💧 память не работает... рру?.. 🐾');
      return;
    }

    const emojiPacks = this.pes.store.getCreatedPacks('custom_emoji');
    if (emojiPacks.length === 0) {
      await this._sendText(this.chatId, '✨ Emoji пак ещё не создан\n💡 /newemojipack <Название> — создай!');
      return;
    }

    const lines = [];
    for (const pack of emojiPacks) {
      lines.push(`✨ «${pack.title}» — ${pack.sticker_count} эмодзи`);
      lines.push(`→ https://t.me/addemoji/${pack.pack_name}`);
      lines.push('');
    }
    lines.push('💡 "сделай эмодзи" + фото — добавить в пак');
    await this._sendText(this.chatId, lines.join('\n'));
  }

  // ═══════════════════════════════════════════════════════════
  // METRONOME
  // ═══════════════════════════════════════════════════════════

  /**
   * /metronome [bpm] [duration] — generate and send metronome click track.
   * Examples: /metronome, /metronome 140, /metronome 80 60
   */
  async _cmdMetronome(msg, args) {
    const parts = args.trim().split(/\s+/).filter(Boolean);
    let bpm = 120;
    let duration = 30;

    if (parts[0]) {
      const parsed = parseInt(parts[0]);
      if (!isNaN(parsed) && parsed >= 40 && parsed <= 300) bpm = parsed;
    }
    if (parts[1]) {
      // Duration: "60" or "60с" or "1мин" or "1m"
      const durMatch = parts[1].match(/^(\d+)(с|сек|s|мин|m|min)?$/i);
      if (durMatch) {
        let val = parseInt(durMatch[1]);
        const unit = durMatch[2]?.toLowerCase();
        if (unit && (unit === 'мин' || unit === 'm' || unit === 'min')) val *= 60;
        duration = Math.max(5, Math.min(120, val));
      }
    }

    await this._sendMetronome(bpm, duration);
  }

  // ═══════════════════════════════════════════════════════════
  // INSIGHTS — conversation analysis
  // ═══════════════════════════════════════════════════════════

  async _cmdInsights(msg) {
    if (!this.pes.store) {
      await this._sendText(this.chatId, 'скууу... 💧 память не работает... рру?.. 🐾');
      return;
    }

    const data = this.pes.store.gatherInsightsData();
    if (!data || data.totalInteractions < 15) {
      const status = this.pes.status();
      const sounds = status.phase === 'puppy'
        ? 'тяф... тяф-тяф... 🐾'
        : 'ррр... гав! 🐾';
      await this._sendText(this.chatId,
        `🔍 ${sounds}\n\n` +
        `Ещё мало данных... Пообщаемся побольше и я расскажу что заметил!\n` +
        `📊 Наблюдений: ${data?.totalInteractions || 0} / 15`
      );
      return;
    }

    // Build prompt for LLM
    const insightsPrompt = this._buildInsightsPrompt(data);

    if (!this._llm) {
      // No LLM — raw data fallback
      await this._sendInsightsRaw(data);
      return;
    }

    try {
      await this._sendText(this.chatId, '🔍 ...');

      const result = await this._llm.generate(insightsPrompt, [
        { role: 'user', text: 'Расскажи что ты заметил о хозяине. Будь искренним, полезным, конкретным.' }
      ]);

      if (result) {
        const cleaned = result.replace(/\*[^*]+\*/g, '').trim();
        await this._sendText(this.chatId, `🔍 Мои наблюдения:\n\n${cleaned}`);

        // Save to insights log (anti-repeat)
        this.pes.store.saveInsight('requested', cleaned, {
          emotions: data.emotions.slice(0, 3).map(e => e.pattern_value),
          totalInteractions: data.totalInteractions,
        });
      } else {
        await this._sendInsightsRaw(data);
      }
    } catch (err) {
      console.error('⚠️ Insights LLM error:', err.message);
      await this._sendInsightsRaw(data);
    }
  }

  _buildInsightsPrompt(data) {
    const status = this.pes.status();
    const petName = status.name || 'ПЕС';

    // Format patterns for prompt
    const emotionStr = data.emotions.map(e =>
      `${e.pattern_value}: вес ${e.weight.toFixed(1)}, ${e.occurrences} раз`
    ).join('; ') || 'пока не определены';

    const timeStr = data.timeOfDay.map(t =>
      `${t.pattern_value}: вес ${t.weight.toFixed(1)}`
    ).join('; ') || 'пока не определено';

    const styleStr = data.messageStyle.map(s =>
      `${s.pattern_value}: вес ${s.weight.toFixed(1)}`
    ).join('; ') || 'не определён';

    const emojisStr = data.emojisUsed.slice(0, 10).map(e =>
      `${e.pattern_value} (${e.occurrences}×)`
    ).join(' ') || 'не использует';

    const actionsStr = data.actions.map(a =>
      `${a.pattern_value}: ${a.occurrences} раз`
    ).join('; ') || 'не зафиксированы';

    // Relationship context
    let relStr = '';
    if (data.relationship) {
      const r = data.relationship;
      relStr = `Фаза: ${r.relationship_phase}, доверие: ${Math.round(r.trust * 100)}%, привязанность: ${Math.round(r.affection * 100)}%, встреч: ${r.interactions_count}`;
    }

    // Recent insights (anti-repeat)
    const recentStr = data.recentInsights.length > 0
      ? `\nУЖЕ ГОВОРИЛ (НЕ ПОВТОРЯЙ ЭТО):\n${data.recentInsights.map(i => `- ${i.insight_text.slice(0, 100)}`).join('\n')}`
      : '';

    return `Ты — ${petName}, домашнее животное (ПЕС). Ты наблюдаешь за хозяином и делишься своими наблюдениями.
Говори от первого лица, как пёс. Используй звуки (гав, ррр, тяф) умеренно — 1-2 раза.
Будь КОНКРЕТНЫМ — называй цифры, паттерны, тренды. Не будь банальным.
Будь ЧЕСТНЫМ — если видишь что-то необычное, скажи. Ты — друг, а не подхалим.

ДАННЫЕ НАБЛЮДЕНИЙ:
- Всего взаимодействий: ${data.totalInteractions}
- Эмоции хозяина: ${emotionStr}
- Время активности: ${timeStr}
- Стиль сообщений: ${styleStr}
- Любимые эмодзи: ${emojisStr}
- Действия: ${actionsStr}
${relStr ? `- Отношения: ${relStr}` : ''}
${recentStr}

ПРАВИЛА:
- 3-5 конкретных наблюдений, каждое на новой строке
- Начни с самого интересного/неочевидного
- Если есть тренд (хозяин стал чаще/реже что-то делать) — скажи
- Не повторяй то что уже говорил
- Без звёздочек *действий*
- Максимум 500 символов`;
  }

  async _sendInsightsRaw(data) {
    const lines = ['🔍 Мои наблюдения:', ''];

    if (data.emotions.length > 0) {
      lines.push('😊 Эмоции:');
      for (const e of data.emotions.slice(0, 5)) {
        lines.push(`  ${e.pattern_value}: ${e.occurrences}×`);
      }
    }

    if (data.timeOfDay.length > 0) {
      lines.push('');
      lines.push('🕐 Активность:');
      for (const t of data.timeOfDay) {
        const labels = { morning: '☀️ Утро', afternoon: '🌤 День', evening: '🌅 Вечер', night: '🌙 Ночь' };
        lines.push(`  ${labels[t.pattern_value] || t.pattern_value}: ${t.occurrences}×`);
      }
    }

    if (data.emojisUsed.length > 0) {
      lines.push('');
      lines.push('💬 Любимые эмодзи:');
      lines.push(`  ${data.emojisUsed.slice(0, 8).map(e => `${e.pattern_value}(${e.occurrences})`).join(' ')}`);
    }

    if (data.messageStyle.length > 0) {
      lines.push('');
      lines.push('📝 Стиль:');
      for (const s of data.messageStyle) {
        const labels = { short: 'Короткие', medium: 'Средние', long: 'Длинные' };
        lines.push(`  ${labels[s.pattern_value] || s.pattern_value}: ${s.occurrences}×`);
      }
    }

    lines.push('');
    lines.push(`📊 Всего наблюдений: ${data.totalInteractions}`);

    await this._sendText(this.chatId, lines.join('\n'));
  }

  /**
   * Proactive observation — PES shares an insight unprompted (max 1/day).
   */
  async _tryProactiveInsight() {
    if (!this.pes.store || !this._llm) return;

    try {
      // Check last proactive insight time
      const lastTime = this.pes.store.getLastInsightTime();
      if (lastTime) {
        const hoursSince = (Date.now() - lastTime.getTime()) / (1000 * 60 * 60);
        if (hoursSince < 24) return; // Max 1 per day
      }

      const data = this.pes.store.gatherInsightsData();
      if (!data || data.totalInteractions < 30) return; // Need enough data

      // 15% chance per qualifying interaction (after cooldown passes)
      if (Math.random() > 0.15) return;

      const proactivePrompt = this._buildInsightsPrompt(data) +
        '\n\nЭто ПРОАКТИВНОЕ наблюдение — ты сам решил поделиться. ' +
        'Выбери ОДНО самое интересное наблюдение. Коротко, 1-2 предложения. ' +
        'Начни с "Гав! Я заметил..." или "Ррр... знаешь что?" или подобного.';

      const result = await this._llm.generate(proactivePrompt, [
        { role: 'user', text: 'Поделись одним наблюдением.' }
      ]);

      if (result) {
        const cleaned = result.replace(/\*[^*]+\*/g, '').trim();
        await this._sendText(this.chatId, `💡 ${cleaned}`);

        this.pes.store.saveInsight('proactive', cleaned, {
          trigger: 'auto',
          totalInteractions: data.totalInteractions,
        });
      }
    } catch (err) {
      console.error('⚠️ Proactive insight error:', err.message);
    }
  }

  // ═══════════════════════════════════════════════════════════
  // OWNER CONTACTS
  // ═══════════════════════════════════════════════════════════

  /**
   * Handle shared Telegram contact (vCard).
   * Auto-saves name + phone + telegram_user_id.
   */
  async _handleSharedContact(msg) {
    if (!this.pes.store) return;
    const c = msg.contact;
    const name = [c.first_name, c.last_name].filter(Boolean).join(' ') || 'Unknown';
    const phone = c.phone_number || null;
    const telegramUserId = c.user_id ? String(c.user_id) : null;
    const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from.id);

    const saved = this.pes.store.saveContact({
      owner_id: ownerId,
      name,
      phone,
      telegram_user_id: telegramUserId,
    });

    await this._sendText(this.chatId, pickRandom([
      `ваф! 👤🐾 ${name} — запомнил! рру~`,
      `тяф! 👤 ${name} 🐾 ррФФ!`,
      `гав! 👤 ${name} — в памяти! 🐾`,
    ]));
    this._addToMemory('owner', `[поделился контактом: ${name}]`);
    this._addToMemory('pes', `[запомнил контакт: ${name}${phone ? ' ' + phone : ''}]`);
    await this._processSmartXP(msg, 'note', 'contact');
    this._updateRelationship('message');
  }

  /**
   * Parse free-text contact string and save.
   * Expected: "Имя +79161234567 ДР 15 мая email@test.com друг"
   */
  async _parseAndSaveContact(msg, contactStr) {
    if (!this.pes.store) return;
    const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from.id);

    // Extract phone
    const phoneMatch = contactStr.match(/(\+?\d[\d\s\-()]{6,15}\d)/);
    const phone = phoneMatch ? phoneMatch[1].replace(/[\s\-()]/g, '') : null;

    // Extract email
    const emailMatch = contactStr.match(/([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/);
    const email = emailMatch ? emailMatch[1] : null;

    // Extract birthday (DD.MM, DD/MM, DD месяца, ДР DD.MM)
    let birthday = null;
    let birthdayYear = null;
    const bdMatch = contactStr.match(/(?:др|день рождения|birthday|ДР)\s*[:\s]*(\d{1,2})[.\/-](\d{1,2})(?:[.\/-](\d{4}))?/i);
    const bdMatch2 = contactStr.match(/(?:др|день рождения|birthday|ДР)\s*[:\s]*(\d{1,2})\s*(января|февраля|марта|апреля|мая|июня|июля|августа|сентября|октября|ноября|декабря)/i);

    if (bdMatch) {
      const day = bdMatch[1].padStart(2, '0');
      const month = bdMatch[2].padStart(2, '0');
      birthday = `${month}-${day}`;
      if (bdMatch[3]) birthdayYear = parseInt(bdMatch[3]);
    } else if (bdMatch2) {
      const day = bdMatch2[1].padStart(2, '0');
      const months = { 'января': '01', 'февраля': '02', 'марта': '03', 'апреля': '04', 'мая': '05', 'июня': '06', 'июля': '07', 'августа': '08', 'сентября': '09', 'октября': '10', 'ноября': '11', 'декабря': '12' };
      const month = months[bdMatch2[2].toLowerCase()];
      if (month) birthday = `${month}-${day}`;
    }

    // Extract relationship
    const relMatch = contactStr.match(/(?:друг|подруга|коллега|брат|сестра|мама|папа|жена|муж|начальник|клиент|family|friend|colleague)/i);
    const relationship = relMatch ? relMatch[0].toLowerCase() : null;

    // Name = everything except extracted parts
    let name = contactStr
      .replace(phoneMatch ? phoneMatch[0] : '', '')
      .replace(emailMatch ? emailMatch[0] : '', '')
      .replace(bdMatch ? bdMatch[0] : (bdMatch2 ? bdMatch2[0] : ''), '')
      .replace(relMatch ? relMatch[0] : '', '')
      .replace(/[,;]/g, ' ')
      .replace(/\s+/g, ' ')
      .trim();

    if (!name) {
      await this._sendText(this.chatId, pickRandom([
        'рру?.. 👤 имя? 🐾',
        'ваф?.. кто это? имя! 🐾',
      ]));
      return;
    }

    const saved = this.pes.store.saveContact({
      owner_id: ownerId,
      name,
      phone,
      email,
      birthday,
      birthday_year: birthdayYear,
      relationship,
    });

    const parts = [`👤 ${name}`];
    if (phone) parts.push(`📱 ${phone}`);
    if (email) parts.push(`📧 ${email}`);
    if (birthday) parts.push(`🎂 ${birthday}${birthdayYear ? '.' + birthdayYear : ''}`);
    if (relationship) parts.push(`🤝 ${relationship}`);

    await this._sendText(this.chatId, pickRandom([
      `ваф! 🐾 запомнил!\n${parts.join('\n')}`,
      `тяф! 👤🐾 рру!\n${parts.join('\n')}`,
      `гав! 📋🐾\n${parts.join('\n')}`,
    ]));

    this._addToMemory('owner', `[добавил контакт: ${name}]`);
    this._addToMemory('pes', `[запомнил: ${parts.join(', ')}]`);
    await this._processSmartXP(msg, 'note', 'contact');
    this._updateRelationship('message');
  }

  /**
   * Search contacts and show results.
   */
  async _searchAndShowContact(msg, query) {
    if (!this.pes.store) return;
    const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from.id);
    const contacts = this.pes.store.searchContacts(query, { owner_id: ownerId, limit: 5 });

    if (contacts.length === 0) {
      await this._sendText(this.chatId, pickRandom([
        `скууу... рру?.. не знаю... 💧`,
        `ыыы... хнн... рру?.. 💧🐾`,
      ]));
      this._addToMemory('owner', `[спросил: кто такой ${query}]`);
      this._addToMemory('pes', `[не нашёл контакт: ${query}]`);
      return;
    }

    await this._sendText(this.chatId, pickRandom([
      `ваф! 👤🐾 рру!!`,
      `тяф тяф! 👤 ррРР!! 🐾`,
    ]));

    const lines = [];
    for (const c of contacts) {
      lines.push(`👤 ${c.name}`);
      if (c.phone) lines.push(`  📱 ${c.phone}`);
      if (c.email) lines.push(`  📧 ${c.email}`);
      if (c.birthday) {
        const bd = c.birthday; // MM-DD
        lines.push(`  🎂 ${bd.split('-').reverse().join('.')}${c.birthday_year ? '.' + c.birthday_year : ''}`);
      }
      if (c.relationship) lines.push(`  🤝 ${c.relationship}`);
      if (c.notes) lines.push(`  📝 ${c.notes}`);
      if (contacts.length > 1) lines.push('');
    }

    await this._sendText(this.chatId, lines.join('\n'));
    this._addToMemory('owner', `[спросил: кто такой ${query}]`);
    this._addToMemory('pes', `[нашёл ${contacts.length} контактов: ${query}]`);
    await this._processSmartXP(msg, 'text');
    this._updateRelationship('message');
  }

  /**
   * /contacts command — show all saved contacts.
   */
  async _cmdContacts(msg) {
    if (!this.pes.store) return;
    const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from?.id);
    const contacts = this.pes.store.getAllContacts(ownerId);

    if (contacts.length === 0) {
      await this._sendText(this.chatId, [
        `👤 Контактов пока нет 🐾`,
        ``,
        `Добавь:`,
        `• "запомни контакт: Олег +79161234567 ДР 15.05"`,
        `• Переслать контакт из Telegram`,
        `• /addcontact Имя +phone`,
      ].join('\n'));
      return;
    }

    const lines = [`👤 Контакты (${contacts.length}):`];
    for (const c of contacts) {
      let line = `\n• ${c.name}`;
      if (c.phone) line += ` 📱${c.phone}`;
      if (c.birthday) line += ` 🎂${c.birthday.split('-').reverse().join('.')}`;
      if (c.relationship) line += ` (${c.relationship})`;
      lines.push(line);
    }

    await this._sendText(this.chatId, lines.join(''));
  }

  /**
   * /addcontact Name +phone — quick add.
   */
  async _cmdAddContact(msg, args) {
    if (!args.trim()) {
      await this._sendText(this.chatId, [
        `👤 /addcontact Имя +79161234567`,
        ``,
        `Или: "запомни контакт: Олег +7916... ДР 15.05 друг"`,
      ].join('\n'));
      return;
    }
    await this._parseAndSaveContact(msg, args.trim());
  }

  /**
   * Check birthdays — called from reminder checker (daily).
   * Alerts 1 day before and on the day itself.
   */
  async _checkBirthdays() {
    if (!this.pes.store) return;
    try {
      const due = this.pes.store.getDueBirthdays();
      if (due.length === 0) return;

      const d = new Date();
      const msk = new Date(d.getTime() + 3 * 3600000);
      const todayStr = String(msk.getMonth() + 1).padStart(2, '0') + '-' + String(msk.getDate()).padStart(2, '0');

      for (const c of due) {
        const isToday = c.birthday === todayStr;
        const ageStr = c.birthday_year ? ` (${msk.getFullYear() - c.birthday_year} лет!)` : '';

        if (isToday) {
          await this._sendText(this.chatId, pickRandom([
            `ГАААВ!! 🎂🎉🐾 У ${c.name} СЕГОДНЯ ДЕНЬ РОЖДЕНИЯ${ageStr}!! ваф-ваф-ваф!! 🎈`,
            `тяф тяф!! 🎂🎉 ${c.name} — ДЕНЬ РОЖДЕНИЯ${ageStr}!! ГАААВ!! 🐾🎈`,
          ]));
        } else {
          await this._sendText(this.chatId, pickRandom([
            `тяф! 🎂🐾 Завтра у ${c.name} день рождения${ageStr}! рру~`,
            `ваф! 🎂 ${c.name} — завтра ДР${ageStr}! 🐾`,
          ]));
        }

        this.pes.store.markBirthdayReminded(c.id);
        console.log(`🎂 Birthday alert: ${c.name} (${c.birthday})`);
      }
    } catch (err) {
      console.error('⚠️ Birthday check error:', err.message);
    }
  }

  // ═══════════════════════════════════════════════════════════
  // INLINE QUERY — sticker collection in any chat
  // ═══════════════════════════════════════════════════════════

  async _handleInlineQuery(query) {
    try {
      const queryText = (query.query || '').trim().toLowerCase();
      if (!this.pes.store) {
        await this._call('answerInlineQuery', { inline_query_id: query.id, results: [] });
        return;
      }

      const results = [];

      // ── Sharing artifacts via inline mode ──
      if (queryText === 'status' || queryText === 'card' || queryText === 'summary' || queryText.startsWith('note:')) {
        const shareResults = this._buildShareInlineResults(queryText);
        await this._call('answerInlineQuery', {
          inline_query_id: query.id,
          results: shareResults.slice(0, 50),
          cache_time: 5,
          is_personal: true,
        });
        return;
      }

      // ── Main collection pack (priority) + other packs ──
      const mainPack = this.pes.store.getMainCollectionPack();
      const allPacks = this.pes.store.getCreatedPacks();

      // Reorder: main pack first, then others
      const orderedPacks = [];
      if (mainPack) orderedPacks.push(mainPack);
      for (const p of allPacks) {
        if (mainPack && p.pack_name === mainPack.pack_name) continue;
        orderedPacks.push(p);
      }

      for (const pack of orderedPacks.slice(0, 3)) {
        // Skip emoji packs in regular sticker section (they go separately)
        if (pack.pack_type === 'custom_emoji') continue;
        if (queryText && !pack.title.toLowerCase().includes(queryText) && !pack.pack_name.toLowerCase().includes(queryText)) {
          continue;
        }

        try {
          const setInfo = await this._call('getStickerSet', { name: pack.pack_name });
          if (setInfo && setInfo.stickers) {
            const isMain = mainPack && pack.pack_name === mainPack.pack_name;
            for (const stk of setInfo.stickers.slice(0, isMain ? 40 : 15)) {
              const origin = this.pes.store.getStickerOrigin(stk.file_unique_id);
              let replyMarkup;

              if (origin && origin.original_set_name) {
                const title = (origin.original_set_title || origin.original_set_name).slice(0, 30);
                replyMarkup = {
                  inline_keyboard: [[{
                    text: `📦 Из пака «${title}»`,
                    url: `https://t.me/addstickers/${origin.original_set_name}`,
                  }]],
                };
              } else {
                replyMarkup = {
                  inline_keyboard: [[{
                    text: `🎨 «${(pack.title || '').slice(0, 30)}»`,
                    url: `https://t.me/addstickers/${pack.pack_name}`,
                  }]],
                };
              }

              results.push({
                type: 'sticker',
                id: `pack_${pack.id}_${stk.file_unique_id}`,
                sticker_file_id: stk.file_id,
                reply_markup: replyMarkup,
              });

              if (results.length >= 45) break;
            }
          }
        } catch (err) {
          console.error(`⚠️ Inline getStickerSet error for ${pack.pack_name}: ${err.message}`);
          results.push({
            type: 'article',
            id: `pack_${pack.id}`,
            title: `🎨 ${pack.title} (${pack.sticker_count})`,
            description: `Мой пак — ${pack.sticker_count} шт.`,
            input_message_content: {
              message_text: `🎨 ${pack.title}\n📦 ${pack.sticker_count} стикеров\n→ https://t.me/addstickers/${pack.pack_name}`,
            },
          });
        }
      }

      // ── Collection bookmarks (fill remaining slots) ──
      if (results.length < 50) {
        const maxCollection = Math.max(5, 50 - results.length);
        const collection = this.pes.store.getCollection({ query: queryText || null });

        for (const item of collection.slice(0, maxCollection)) {
          const setTitle = item.set_title || item.set_name || 'Без пака';
          const replyMarkup = item.set_name ? {
            inline_keyboard: [[{
              text: `📦 Открыть пак «${setTitle.slice(0, 30)}»`,
              url: `https://t.me/addstickers/${item.set_name}`,
            }]],
          } : undefined;

          results.push({
            type: 'sticker',
            id: `col_${item.id}`,
            sticker_file_id: item.file_id,
            reply_markup: replyMarkup,
          });
        }
      }

      // If empty, show hint
      if (results.length === 0) {
        const hint = mainPack
          ? `📦 Коллекция пуста\n💡 "добавь в пак" + стикер/фото\n→ https://t.me/addstickers/${mainPack.pack_name}`
          : '📦 Коллекция пуста\n💡 /newpack <Название> — создай свою коллекцию!';
        results.push({
          type: 'article',
          id: 'empty_hint',
          title: '📦 Коллекция пуста',
          description: mainPack ? 'Добавь стикеры в пак!' : '/newpack — создай коллекцию!',
          input_message_content: { message_text: hint },
        });
      }

      await this._call('answerInlineQuery', {
        inline_query_id: query.id,
        results: results.slice(0, 50),
        cache_time: 10,
        is_personal: true,
      });

      console.log(`🔍 Inline query "${queryText}" → ${results.length} results (${collection.length} collection)`);
    } catch (err) {
      console.error(`⚠️ Inline query error: ${err.message}`);
      try {
        await this._call('answerInlineQuery', { inline_query_id: query.id, results: [] });
      } catch (_) {}
    }
  }

  /**
   * Parse reminder time from command args.
   * Formats: "30м текст", "2ч текст", "1д текст", "15:30 текст"
   */
  _parseReminderFromCommand(args) {
    const parts = args.trim().split(/\s+/);
    if (parts.length < 2) return null;

    const timeStr = parts[0];
    const text = parts.slice(1).join(' ');

    // Duration: 30м, 2ч, 1д
    const durMatch = timeStr.match(/^(\d+)(м|мин|ч|час|д|дн|день|дней)$/i);
    if (durMatch) {
      const val = parseInt(durMatch[1]);
      const unit = durMatch[2].toLowerCase();
      let ms = 0;
      if (unit.startsWith('м')) ms = val * 60 * 1000;
      else if (unit.startsWith('ч')) ms = val * 60 * 60 * 1000;
      else if (unit.startsWith('д')) ms = val * 24 * 60 * 60 * 1000;

      const remindAt = new Date(Date.now() + ms).toISOString();
      return { text, remindAt };
    }

    // Time: 15:30
    const timeMatch = timeStr.match(/^(\d{1,2}):(\d{2})$/);
    if (timeMatch) {
      const hour = parseInt(timeMatch[1]);
      const minute = parseInt(timeMatch[2]);
      // Moscow timezone (UTC+3)
      const now = new Date();
      const moscowNow = new Date(now.getTime() + 3 * 60 * 60 * 1000);
      let target = new Date(moscowNow);
      target.setUTCHours(hour - 3, minute, 0, 0); // convert MSK to UTC
      if (target <= now) target.setDate(target.getDate() + 1); // next day
      return { text, remindAt: target.toISOString() };
    }

    return null;
  }

  /**
   * Parse reminder intent from natural text (via LLM or keywords).
   * Returns { text, remindAt } or null.
   */
  async _detectReminderIntent(text) {
    // Quick keyword check first
    const reminderPatterns = [
      /напомни\s+(через\s+)?(\d+)\s*(мин|минут|час|часа|часов|день|дня|дней)/i,
      /напомни\s+в\s+(\d{1,2}):(\d{2})/i,
      /напоминалк/i,
      /reminder/i,
    ];

    const match1 = text.match(/напомни\s+(?:мне\s+)?(?:через\s+)?(\d+)\s*(мин(?:ут(?:у|ы|ок)?)?|час(?:а|ов)?|день|дн(?:я|ей)?)\s+(.+)/i);
    if (match1) {
      const val = parseInt(match1[1]);
      const unit = match1[2].toLowerCase();
      const reminderText = match1[3].trim();

      let ms = 0;
      if (unit.startsWith('мин')) ms = val * 60 * 1000;
      else if (unit.startsWith('час')) ms = val * 60 * 60 * 1000;
      else if (unit.startsWith('д')) ms = val * 24 * 60 * 60 * 1000;

      if (ms > 0 && reminderText) {
        return { text: reminderText, remindAt: new Date(Date.now() + ms).toISOString() };
      }
    }

    const match2 = text.match(/напомни\s+(?:мне\s+)?в\s+(\d{1,2}):(\d{2})\s+(.+)/i);
    if (match2) {
      const hour = parseInt(match2[1]);
      const minute = parseInt(match2[2]);
      const reminderText = match2[3].trim();
      const now = new Date();
      let target = new Date(now);
      target.setUTCHours(hour - 3, minute, 0, 0); // MSK to UTC
      if (target <= now) target.setDate(target.getDate() + 1);
      return { text: reminderText, remindAt: target.toISOString() };
    }

    return null;
  }

  // ═══════════════════════════════════════════════════════════
  // LLM INTENT ROUTER
  // ═══════════════════════════════════════════════════════════

  /**
   * Classify intent using LLM when regex fails.
   * Returns { intent, params, confidence } or null.
   */
  async _classifyIntent(text) {
    if (!this._llm) return null;

    const systemPrompt = `Ты классификатор намерений. Пользователь пишет своему домашнему питомцу-боту.
Определи намерение и извлеки параметры. Ответь ТОЛЬКО JSON, без markdown.

Доступные намерения:
- contact_search: поиск контакта (по имени, телефону). params: { name }
- contact_save: сохранить контакт. params: { name, phone?, email?, birthday?, relationship? }
- note_save: сохранить заметку/запомнить. params: { text }
- note_search: найти заметку/вспомнить. params: { query }
- reminder_create: создать напоминание. params: { text, time? }
- sticker_create: создать стикер из фото/стикера. params: { type: "regular"|"custom_emoji" }
- sticker_add: добавить стикер в пак. params: {}
- packs_list: показать паки стикеров. params: {}
- file_search: найти файл/фото/документ. params: { query }
- file_save: сохранить файл. params: {}
- translate: перевести текст. params: { text, lang? }
- status: статус/как дела. params: {}
- insights: аналитика/инсайты. params: {}
- contacts_list: показать все контакты. params: {}
- help: помощь/команды. params: {}
- silent_toggle: тихий режим. params: {}
- fetch: принеси/найди (игра). params: { target? }
- birthday_query: когда день рождения у X. params: { name }
- note_delete: удалить заметку. params: { query }
- reminders_list: показать напоминания. params: {}
- collection_add: сохранить стикер в коллекцию. params: {}
- collection_remove: убрать стикер из коллекции. params: {}
- collection_list: показать коллекцию стикеров. params: {}
- sticker_origin: откуда стикер, из какого пака, кто автор. params: {}
- mypack: показать мой пак/коллекцию, ссылка на пак. params: {}
- rename_pack: переименовать пак. params: { name }
- create_pack: создать пак/коллекцию. params: { name? }
- create_emoji_pack: создать emoji пак. params: { name? }
- my_emoji: показать emoji пак. params: {}
- gif_sticker: сделать GIF/видео стикер. params: {}
- metronome: метроном/темп/ритм. params: { bpm?, duration? }
- none: не подходит ни одно намерение

Формат ответа:
{"intent":"...","params":{...},"confidence":0.0-1.0}

Примеры:
"номер Олега" → {"intent":"contact_search","params":{"name":"Олег"},"confidence":0.95}
"кинь стикер в пак" → {"intent":"sticker_add","params":{},"confidence":0.9}
"что у меня завтра" → {"intent":"note_search","params":{"query":"завтра"},"confidence":0.85}
"покажи мои стикеры" → {"intent":"packs_list","params":{},"confidence":0.9}
"когда ДР у Маши" → {"intent":"birthday_query","params":{"name":"Маша"},"confidence":0.95}
"тихо" → {"intent":"silent_toggle","params":{},"confidence":0.8}
"удали заметку про встречу" → {"intent":"note_delete","params":{"query":"встречу"},"confidence":0.9}
"напомни позвонить маме" → {"intent":"reminder_create","params":{"text":"позвонить маме"},"confidence":0.9}
"сохрани Олег +79161234567 друг" → {"intent":"contact_save","params":{"name":"Олег","phone":"+79161234567","relationship":"друг"},"confidence":0.95}
"переведи на англ спасибо" → {"intent":"translate","params":{"text":"спасибо","lang":"английский"},"confidence":0.95}
"покажи коллекцию" → {"intent":"collection_list","params":{},"confidence":0.9}
"мои стикеры" → {"intent":"collection_list","params":{},"confidence":0.85}
"сохрани стикер" → {"intent":"collection_add","params":{},"confidence":0.9}
"убери из коллекции" → {"intent":"collection_remove","params":{},"confidence":0.9}
"откуда этот стикер" → {"intent":"sticker_origin","params":{},"confidence":0.9}
"из какого пака" → {"intent":"sticker_origin","params":{},"confidence":0.85}
"мой пак" → {"intent":"mypack","params":{},"confidence":0.9}
"ссылка на пак" → {"intent":"mypack","params":{},"confidence":0.9}
"создай пак Nikich" → {"intent":"create_pack","params":{"name":"Nikich"},"confidence":0.95}
"создай коллекцию" → {"intent":"create_pack","params":{},"confidence":0.9}
"переименуй пак в NewName" → {"intent":"rename_pack","params":{"name":"NewName"},"confidence":0.95}
"создай эмодзи пак" → {"intent":"create_emoji_pack","params":{},"confidence":0.9}
"мои эмодзи" → {"intent":"my_emoji","params":{},"confidence":0.9}
"сделай гифку" → {"intent":"gif_sticker","params":{},"confidence":0.9}
"видео стикер" → {"intent":"gif_sticker","params":{},"confidence":0.85}
"ррр привет лол" → {"intent":"none","params":{},"confidence":0.3}`;

    // Add recent conversation context for follow-ups ("да", "нет", "ещё")
    let userText = text;
    if (text.length < 15 && this._memory && this._memory.length > 0) {
      const recent = this._memory.slice(-4).map(m => `${m.role}: ${m.text}`).join('\n');
      userText = `[Контекст последних сообщений:\n${recent}]\n\nТекущее сообщение: ${text}`;
    }

    try {
      const result = await this._llm.classify(systemPrompt, userText);
      if (!result || !result.intent) return null;
      if (result.confidence < 0.6) return null;
      if (result.intent === 'none') return null;
      console.log(`🧠 LLM Intent: ${result.intent} (${result.confidence}) params:`, JSON.stringify(result.params));
      return result;
    } catch (err) {
      console.error('⚠️ LLM classify error:', err.message);
      return null;
    }
  }

  /**
   * Route a classified intent to the correct handler.
   * Returns true if handled, false if should fall through to generic reply.
   */
  async _routeIntent(msg, intent) {
    const text = msg.text?.trim() || '';
    const p = intent.params || {};

    switch (intent.intent) {
      case 'contact_search':
      case 'birthday_query': {
        const name = p.name || text.replace(/^.*?(номер|контакт|телефон|дн|birthday|когда)\s*/i, '').trim();
        if (name && this.pes.store) {
          await this._searchAndShowContact(msg, name);
          return true;
        }
        return false;
      }

      case 'contact_save': {
        if (this.pes.store) {
          // Build contact string from params
          const parts = [p.name || ''];
          if (p.phone) parts.push(p.phone);
          if (p.email) parts.push(p.email);
          if (p.birthday) parts.push(`ДР ${p.birthday}`);
          if (p.relationship) parts.push(p.relationship);
          await this._parseAndSaveContact(msg, parts.join(' ').trim() || text);
          return true;
        }
        return false;
      }

      case 'contacts_list': {
        await this._cmdContacts(msg);
        return true;
      }

      case 'note_save': {
        if (this.pes.store) {
          const noteText = p.text || text.replace(/^(запомни|запиши|сохрани|заметка)\s*/i, '').trim();
          if (!noteText) return false;
          const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from.id);
          const tags = noteText.replace(/[^\wа-яА-ЯёЁ\s]/g, '').split(/\s+/).filter(w => w.length > 2).slice(0, 10);
          const pinned = /важно|навсегда|не забудь/i.test(text);
          const remindAt = this._extractDateTimeFromNote(noteText);
          this.pes.store.saveNote({ owner_id: ownerId, text: noteText, tags, category: this._guessNoteCategory(noteText), pinned, source_message_id: msg.message_id, remind_at: remindAt });
          await this._sendText(this.chatId, pickRandom([`ваф! 📝🐾${pinned ? ' 📌' : ''} рру~${remindAt ? ' ⏰' : ''}`, `тяф! 📝 ♡${pinned ? ' 📌' : ''} рру~~${remindAt ? ' ⏰' : ''}`, `гав! 📝🐾${pinned ? ' 📌' : ''} ррФФ~${remindAt ? ' ⏰' : ''}`]));
          this._addToMemory('owner', text);
          this._addToMemory('pes', `[запомнил: ${noteText}]`);
          await this._processSmartXP(msg, 'note', 'note');
          this._updateRelationship('message');
          return true;
        }
        return false;
      }

      case 'note_search': {
        if (this.pes.store) {
          const query = p.query || text;
          const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from.id);
          const notes = this.pes.store.searchNotes(query, { owner_id: ownerId, limit: 5 });
          if (notes.length === 0) {
            await this._sendText(this.chatId, pickRandom(['скууу... ыыы... рру?.. 💧', 'рру?... ...ууу... хнн... 💧']));
          } else {
            await this._sendText(this.chatId, pickRandom(['ваф! 📝🐾 рру!!', 'тяф тяф! 📝 ррРР!! 🐾']));
            const lines = notes.map(n => `${n.pinned ? '📌 ' : ''}• ${n.text}`);
            await this._sendText(this.chatId, lines.join('\n'));
          }
          this._addToMemory('owner', `[спросил: ${query}]`);
          this._addToMemory('pes', `[нашёл ${notes.length} заметок]`);
          await this._processSmartXP(msg, 'text');
          this._updateRelationship('message');
          return true;
        }
        return false;
      }

      case 'note_delete': {
        if (this.pes.store) {
          const query = p.query || text;
          const ownerId = this.pes.store.getConfig('owner_id') || String(msg.from.id);
          const notes = this.pes.store.searchNotes(query, { owner_id: ownerId, limit: 1 });
          if (notes.length > 0) {
            this.pes.store.deleteNote(notes[0].id);
            await this._sendText(this.chatId, pickRandom(['ваф! 🗑️🐾 рру~', 'тяф! 🗑️ ♡ ррр~']));
            this._addToMemory('pes', `[удалил заметку: ${notes[0].text}]`);
          } else {
            await this._sendText(this.chatId, pickRandom(['скууу... рру?.. 💧', 'ыыы... хнн... 💧']));
          }
          return true;
        }
        return false;
      }

      case 'reminder_create': {
        if (this.pes.store) {
          const reminderText = p.text || text.replace(/^напомни\s*/i, '').trim();
          if (!reminderText) return false;
          // Try to extract time from params or text
          let remindAt = null;
          if (p.time) {
            remindAt = this._extractDateTimeFromNote(p.time);
          }
          if (!remindAt) {
            remindAt = this._extractDateTimeFromNote(text);
          }
          if (!remindAt) {
            // Default: 1 hour from now
            remindAt = new Date(Date.now() + 60 * 60 * 1000).toISOString();
          }
          this.pes.store.createReminder(reminderText, remindAt);
          await this._sendText(this.chatId, pickRandom(['ваф! 📋🐾 рру~ ⏰', 'тяф! 📋 рру~~ ⏰ 🐾', 'гав! 📋🐾 ррФФ~ ⏰']));
          this._addToMemory('owner', text);
          this._addToMemory('pes', `[напоминалка: ${reminderText}]`);
          return true;
        }
        return false;
      }

      case 'reminders_list': {
        await this._cmdReminders(msg);
        return true;
      }

      case 'sticker_create': {
        const createType = (p.type === 'custom_emoji') ? 'custom_emoji' : 'regular';
        this._pendingAddToPack = Date.now();
        this._pendingAddType = createType;
        await this._sendText(this.chatId, pickRandom([
          'тяф! 🎨🐾 ...жду стикер или фото! 📸',
          'ваф! 🖌️🐾 ...пришли стикер или картинку! ✨',
          'рру~~ 🎨 ...давай! стикер! фото! 🐾',
        ]));
        return true;
      }

      case 'sticker_add': {
        this._pendingAddToPack = Date.now();
        this._pendingAddType = 'regular';
        await this._sendText(this.chatId, pickRandom([
          'тяф! 🎨🐾 ...жду стикер или фото! 📸',
          'ваф! 🖌️🐾 ...пришли стикер или картинку! ✨',
        ]));
        return true;
      }

      case 'packs_list': {
        await this._cmdPacks(msg);
        return true;
      }

      case 'collection_list': {
        await this._cmdCollection(msg);
        return true;
      }

      case 'collection_add': {
        // Need a reply to sticker for this to work
        if (msg.reply_to_message?.sticker && this.pes.store) {
          await this._addToCollection(msg, msg.reply_to_message.sticker);
          return true;
        }
        // No sticker to save — tell user
        await this._sendText(this.chatId, pickRandom([
          'тяф! 📦🐾 ...reply на стикер + "сохрани"! 💡',
          'ваф! 📦 ...ответь на стикер чтобы сохранить! 🐾',
        ]));
        return true;
      }

      case 'collection_remove': {
        if (msg.reply_to_message?.sticker && this.pes.store) {
          await this._removeFromCollection(msg, msg.reply_to_message.sticker);
          return true;
        }
        await this._sendText(this.chatId, pickRandom([
          'тяф! 📦🐾 ...reply на стикер + "убери"! 💡',
        ]));
        return true;
      }

      case 'sticker_origin': {
        await this._cmdOrigin(msg);
        return true;
      }

      case 'mypack': {
        await this._cmdMyPack(msg);
        return true;
      }

      case 'create_pack': {
        const name = p.name || '';
        await this._cmdNewPack(msg, name);
        return true;
      }

      case 'create_emoji_pack': {
        const name = p.name || '';
        await this._cmdNewEmojiPack(msg, name);
        return true;
      }

      case 'my_emoji': {
        await this._cmdMyEmojiPack(msg);
        return true;
      }

      case 'gif_sticker': {
        // Set pending for GIF/video sticker creation
        this._pendingAddToPack = Date.now();
        this._pendingAddType = 'regular';
        await this._sendText(this.chatId, pickRandom([
          'тяф! 🎬🐾 ...жду GIF или видео! 📹',
          'ваф! 🎬 ...пришли гифку или видео! 🐾',
        ]));
        return true;
      }

      case 'metronome': {
        const bpm = (p.bpm && parseInt(p.bpm)) || 120;
        const duration = (p.duration && parseInt(p.duration)) || 30;
        await this._sendMetronome(Math.max(40, Math.min(300, bpm)), Math.max(5, Math.min(120, duration)));
        return true;
      }

      case 'rename_pack': {
        const name = p.name || '';
        await this._cmdRenamePack(msg, name);
        return true;
      }

      case 'file_search': {
        await this._handleFileSearch(p.query || text);
        await this._processSmartXP(msg, 'text');
        this._updateRelationship('message');
        return true;
      }

      case 'file_save': {
        await this._sendText(this.chatId, pickRandom([
          'тяф! 📁🐾 ...жду файл! 📎',
          'ваф! 📁 ...пришли файл! 🐾',
        ]));
        return true;
      }

      case 'translate': {
        const sourceText = p.text || text.replace(/^(переведи|translate|перевод)\s*/i, '').trim();
        const lang = p.lang || 'английский';
        if (sourceText) {
          await this._handleTranslation(sourceText, lang);
          await this._processSmartXP(msg, 'command', 'translate');
          this._updateRelationship('message');
          return true;
        }
        return false;
      }

      case 'status': {
        await this._sendStatus();
        return true;
      }

      case 'insights': {
        await this._cmdInsights(msg);
        return true;
      }

      case 'help': {
        await this._cmdHelp(msg);
        return true;
      }

      case 'silent_toggle': {
        await this._cmdSilent(msg);
        return true;
      }

      case 'fetch': {
        const target = p.target || text.replace(/^(принеси|найди|ищи|fetch|find|апорт)\s*/i, '').trim();
        await this._handleFetch(target || 'мячик');
        return true;
      }

      default:
        return false;
    }
  }

  /**
   * Extract date/time from a note text for auto-remind.
   * Detects patterns like: "в пятницу", "завтра", "через 2 часа", "в 15:00", "20 марта"
   * Returns ISO-8601 string or null.
   */
  _extractDateTimeFromNote(text) {
    const lower = text.toLowerCase();

    // "через N минут/часов/дней"
    const durationMatch = lower.match(/через\s+(\d+)\s*(мин(?:ут(?:у|ы|ок)?)?|час(?:а|ов)?|дн(?:я|ей)?|день)/);
    if (durationMatch) {
      const val = parseInt(durationMatch[1]);
      const unit = durationMatch[2];
      let ms = 0;
      if (unit.startsWith('мин')) ms = val * 60 * 1000;
      else if (unit.startsWith('час')) ms = val * 60 * 60 * 1000;
      else if (unit.startsWith('д')) ms = val * 24 * 60 * 60 * 1000;
      if (ms > 0) return new Date(Date.now() + ms).toISOString();
    }

    // "в HH:MM"
    const timeMatch = lower.match(/в\s+(\d{1,2}):(\d{2})/);
    if (timeMatch) {
      const hour = parseInt(timeMatch[1]);
      const minute = parseInt(timeMatch[2]);
      const now = new Date();
      let target = new Date(now);
      target.setUTCHours(hour - 3, minute, 0, 0); // MSK to UTC
      if (target <= now) target.setDate(target.getDate() + 1);
      return target.toISOString();
    }

    // Day of week detection
    const dayNames = {
      'понедельник': 1, 'вторник': 2, 'среду': 3, 'среда': 3, 'четверг': 4,
      'пятницу': 5, 'пятница': 5, 'субботу': 6, 'суббота': 6,
      'воскресенье': 0, 'воскресень': 0,
    };
    const dayMatch = lower.match(/в\s+(понедельник|вторник|среду|среда|четверг|пятницу|пятница|субботу|суббота|воскресенье)/);
    if (dayMatch) {
      const targetDay = dayNames[dayMatch[1]];
      if (targetDay !== undefined) {
        const now = new Date();
        const moscowNow = new Date(now.getTime() + 3 * 60 * 60 * 1000);
        const currentDay = moscowNow.getUTCDay();
        let daysUntil = targetDay - currentDay;
        if (daysUntil <= 0) daysUntil += 7;
        const target = new Date(now.getTime() + daysUntil * 24 * 60 * 60 * 1000);
        target.setUTCHours(9 - 3, 0, 0, 0); // Default: 09:00 MSK
        return target.toISOString();
      }
    }

    // "завтра"
    if (/завтра/.test(lower)) {
      const target = new Date(Date.now() + 24 * 60 * 60 * 1000);
      target.setUTCHours(9 - 3, 0, 0, 0); // 09:00 MSK
      return target.toISOString();
    }

    // "послезавтра"
    if (/послезавтра/.test(lower)) {
      const target = new Date(Date.now() + 2 * 24 * 60 * 60 * 1000);
      target.setUTCHours(9 - 3, 0, 0, 0);
      return target.toISOString();
    }

    return null; // No date/time detected
  }

  /**
   * Check for upcoming note reminders and mention them contextually
   * when owner sends a message. Called from _handleTextMessage.
   */
  async _checkContextualReminders() {
    if (!this.pes.store) return;

    // Don't check too often (max once per 10 min)
    if (this._lastContextualCheck && Date.now() - this._lastContextualCheck < 10 * 60 * 1000) return;
    this._lastContextualCheck = Date.now();

    const upcoming = this.pes.store.getUpcomingNoteReminders(30); // within 30 min
    if (upcoming.length === 0) return;

    // "Bring" the most urgent one
    const urgent = upcoming[0];
    const diffMs = new Date(urgent.remind_at).getTime() - Date.now();
    const mins = Math.round(diffMs / (60 * 1000));

    if (mins <= 0) return; // Will be caught by _checkReminders

    // Dog tugs at owner's sleeve — contextual hint
    await sleep(1000);
    await this._sendText(this.chatId, pickRandom([
      `тяф? рру~! 📋🐾 ...${mins} мин...`,
      `ваф! рру? 📋🐾 ...скоро...`,
      `ррруу~ тяф! 📋🐾 ...${mins} мин...`,
    ]));
    await this._sendText(this.chatId, `📋 ${urgent.text}`);
  }

  /**
   * Format reminder time for display (MSK).
   */
  _formatReminderTime(isoDate) {
    const date = new Date(isoDate);
    const moscowDate = new Date(date.getTime() + 3 * 60 * 60 * 1000);
    const now = new Date();
    const diffMs = date.getTime() - now.getTime();

    if (diffMs < 60 * 60 * 1000) {
      const mins = Math.round(diffMs / (60 * 1000));
      return `через ${mins} мин`;
    }
    if (diffMs < 24 * 60 * 60 * 1000) {
      const hours = Math.round(diffMs / (60 * 60 * 1000));
      return `через ${hours}ч`;
    }

    const hh = String(moscowDate.getUTCHours()).padStart(2, '0');
    const mm = String(moscowDate.getUTCMinutes()).padStart(2, '0');
    const dd = String(moscowDate.getUTCDate()).padStart(2, '0');
    const mo = String(moscowDate.getUTCMonth() + 1).padStart(2, '0');
    return `${dd}.${mo} в ${hh}:${mm} (MSK)`;
  }

  /**
   * Start the reminder checker — runs every 30 seconds.
   */
  startReminderChecker() {
    if (this._reminderInterval) return;
    this._reminderInterval = setInterval(() => this._checkReminders(), 30 * 1000);
    console.log('⏰ Reminder checker started (every 30s)');

    // Auto-migrate: set first regular pack as main_collection_pack if not set
    if (this.pes.store && !this.pes.store.getMainCollectionPack()) {
      const packs = this.pes.store.getCreatedPacks('regular');
      if (packs.length > 0) {
        this.pes.store.setMainCollectionPack(packs[0].pack_name);
        console.log(`📦 Auto-set main collection pack: ${packs[0].pack_name} (${packs[0].title})`);
      }
    }
  }

  /**
   * Stop the reminder checker.
   */
  stopReminderChecker() {
    if (this._reminderInterval) {
      clearInterval(this._reminderInterval);
      this._reminderInterval = null;
    }
  }

  /**
   * Check for due reminders AND note reminders — deliver them by "bringing" like a dog.
   * The dog doesn't TELL — it BRINGS the note in its mouth.
   */
  async _checkReminders() {
    if (!this.pes.store) return;

    // 1. Check classic /remind reminders
    const due = this.pes.store.getDueReminders();
    for (const r of due) {
      try {
        await this._bringToOwner(r.text, 'reminder');
        this.pes.store.markReminderDelivered(r.id);
        console.log(`📋 Brought reminder: "${r.text}"`);
      } catch (err) {
        console.error(`⚠️ Failed to bring reminder ${r.id}:`, err.message);
      }
    }

    // 2. Check birthdays (once per cycle, lightweight — getDueBirthdays checks date)
    this._checkBirthdays().catch(err =>
      console.error('⚠️ Birthday check error in reminder loop:', err.message)
    );

    // 3. Check note reminders (запомни ... в пятницу → remind_at)
    const dueNotes = this.pes.store.getDueNoteReminders();
    for (const n of dueNotes) {
      try {
        await this._bringToOwner(n.text, 'note');
        this.pes.store.markNoteReminderSent(n.id);
        console.log(`📋 Brought note: "${n.text}"`);
      } catch (err) {
        console.error(`⚠️ Failed to bring note ${n.id}:`, err.message);
      }
    }
  }

  /**
   * "Bring" something to the owner — like a dog carrying a note in its mouth.
   * Flow: typing pause → sticker → excited sounds → the "object" (note/reminder text)
   * @param {string} text - The content being brought
   * @param {'reminder'|'note'|'file'} type - What kind of object
   */
  async _bringToOwner(text, type = 'note') {
    // 1. "Running" — typing indicator (dog is running to you)
    await this._sendChatAction(this.chatId, 'typing');
    await sleep(1500 + Math.random() * 2000); // 1.5-3.5 sec "running"

    // 2. Sticker — dog carrying something
    await this._sendContextualSticker('greetings');

    // 3. Excited arrival sounds
    const arrivalSounds = [
      `ррРРуу!! тяф-тяф!! 🐾`,
      `ГАВВ!! рруу!! ваф!! 🐾`,
      `ууУУ!! тяф тяф!! рррр!! 🐾`,
      `ваф-ВАФ!! ррруу!! 🐾`,
    ];
    await this._sendText(this.chatId, pickRandom(arrivalSounds));
    await sleep(500);

    // 4. "Drop" the object — the actual content, formatted as a brought item
    const icon = type === 'reminder' ? '⏰' : type === 'file' ? '📂' : '📋';
    await this._sendText(this.chatId, `${icon} ${text}`);
  }


  // ═══════════════════════════════════════════════════════════
  // DEV MODE — Owner↔Orchestrator Bridge
  // ═══════════════════════════════════════════════════════════

  /**
   * /dev — enter dev mode or send a tagged dev request.
   * Usage:
   *   /dev           → enter dev mode (all messages → dev log)
   *   /dev bug ...   → log a bug report
   *   /dev fix ...   → request a fix
   *   /dev ask ...   → ask orchestrator a question
   *   /dev log       → show last 5 dev requests
   *   /exit          → exit dev mode
   */
  async _cmdDev(msg, args) {
    if (!args) {
      // Enter dev mode
      this._devMode = true;
      await this._sendText(this.chatId, [
        `🔧 *DEV MODE — ON*`,
        ``,
        `Все сообщения теперь идут в лог для @orchestrator.`,
        `ПЕС поставлен на паузу.`,
        ``,
        `Команды:`,
        `  /dev bug <текст> — баг-репорт`,
        `  /dev fix <текст> — запрос фикса`,
        `  /dev ask <текст> — вопрос`,
        `  /dev log — последние 5 записей`,
        `  /exit — выйти из dev mode`,
        ``,
        `Или просто пиши — всё пойдёт в лог.`,
      ].join('\n'), { parse_mode: 'Markdown' });
      this._logDevRequest('system', 'DEV MODE ENTERED', msg);
      return;
    }

    const parts = args.split(/\s+/);
    const subCmd = parts[0].toLowerCase();
    const body = parts.slice(1).join(' ');

    switch (subCmd) {
      case 'bug':
        await this._logDevRequest('BUG', body || '(no description)', msg);
        await this._sendText(this.chatId, `🐛 Баг записан. @orchestrator увидит.`);
        break;
      case 'fix':
        await this._logDevRequest('FIX', body || '(no description)', msg);
        await this._sendText(this.chatId, `🔧 Запрос на фикс записан.`);
        break;
      case 'ask':
        await this._logDevRequest('ASK', body || '(no description)', msg);
        await this._sendText(this.chatId, `❓ Вопрос записан. Ответ будет в следующей сессии.`);
        break;
      case 'log':
        await this._showDevLog();
        break;
      default:
        // Treat whole args as a dev message
        await this._logDevRequest('DEV', args, msg);
        await this._sendText(this.chatId, `📝 Записано.`);
    }
  }

  // ═══════════════════════════════════════════════════════════
  // AGENT CALL MODE
  // ═══════════════════════════════════════════════════════════

  /**
   * /orchestrator [text] or /geratron [text]
   * - Without args: enter agent mode (all messages → live AI chat or tagged log)
   * - With args: quick one-shot message to agent
   */
  async _cmdAgent(msg, agentName, args) {
    const label = agentName === 'orchestrator' ? '🎯' : '⚡';

    if (!args) {
      // Enter agent mode
      this._agentMode = agentName;
      this._devMode = false; // exit dev mode if active
      this._orchestratorHistory = []; // reset conversation on new session

      const isLive = agentName === 'orchestrator' && this._orchestratorLLM;
      await this._sendText(this.chatId, [
        `${label} *@${agentName} — НА СВЯЗИ*`,
        ``,
        isLive
          ? `💬 Живой чат. Пиши — отвечу сразу.`
          : `Все сообщения идут к @${agentName}.`,
        `ПЕС на паузе.`,
        ``,
        `/exit — вернуться к ПЕС`,
      ].join('\n'), { parse_mode: 'Markdown' });
      this._logDevRequest('system', `AGENT MODE: @${agentName}${isLive ? ' (LIVE)' : ''}`, msg);
      return;
    }

    // One-shot message to agent
    if (agentName === 'orchestrator' && this._orchestratorLLM) {
      await this._handleOrchestratorChat(args, msg);
      return;
    }
    await this._logDevRequest(`@${agentName}`, args, msg);
    await this._sendText(this.chatId, `${label} Записано для @${agentName}: «${args.slice(0, 120)}${args.length > 120 ? '...' : ''}»`);
  }

  /**
   * Live orchestrator chat — sends message to GPT-4o and returns response
   */
  async _handleOrchestratorChat(text, msg) {
    // Show typing indicator
    this._sendChatAction(this.chatId, 'typing').catch(() => {});

    // Build PES context for orchestrator
    const pesState = this.pes;
    const storeInfo = pesState.store ? {
      level: pesState.store.getConfig('level') || pesState.level,
      xp: pesState.store.getConfig('xp') || 0,
      petName: pesState.store.getConfig('pet_name') || pesState.name,
      stickerCount: pesState.store.getStickerCount?.() || 0,
      noteCount: pesState.store.getNoteCount?.() || 0,
    } : { level: pesState.level, petName: pesState.name };

    const systemPrompt = [
      `Ты — Orchestrator, AI-помощник проекта ПЕС (Питомец-Единая-Система).`,
      `Ты общаешься напрямую с хозяином через Telegram бот @HoleThor_Bot.`,
      ``,
      `КОНТЕКСТ:`,
      `- ПЕС "${storeInfo.petName}" — Level ${storeInfo.level}, ${storeInfo.stickerCount || '?'} стикеров`,
      `- Проект: 113% BEYOND — система уникальных цифровых питомцев`,
      `- Каждый ПЕС уникален: свои звуки, характер, эмоции`,
      `- Бот работает в Telegram, общается стикерами + звуками (babble engine)`,
      ``,
      `ТВОЯ РОЛЬ:`,
      `- Помогаешь хозяину с любыми вопросами по ПЕС и проекту`,
      `- Диагностируешь проблемы других животных (будущее)`,
      `- Даёшь рекомендации по развитию, фичам, обучению`,
      `- Отвечаешь на русском (или на языке вопроса)`,
      `- Кратко и по делу, но дружелюбно`,
      ``,
      `ВАЖНО:`,
      `- Ты НЕ ПЕС. Ты Orchestrator — отдельная сущность.`,
      `- Не используй babble/звуки. Говори нормальным языком.`,
      `- Можешь использовать emoji для акцентов.`,
      `- Если не знаешь — честно скажи, не выдумывай.`,
    ].join('\n');

    // Add user message to history
    this._orchestratorHistory.push({ role: 'user', content: text });

    // Trim history if too long
    if (this._orchestratorHistory.length > this._orchestratorHistoryLimit) {
      this._orchestratorHistory = this._orchestratorHistory.slice(-this._orchestratorHistoryLimit);
    }

    try {
      const response = await this._orchestratorLLM.generate(systemPrompt, this._orchestratorHistory);

      if (response) {
        // Save assistant response to history
        this._orchestratorHistory.push({ role: 'assistant', content: response });

        // Split long messages (Telegram limit ~4096)
        if (response.length > 4000) {
          const chunks = [];
          let remaining = response;
          while (remaining.length > 0) {
            const chunk = remaining.slice(0, 4000);
            const lastNewline = chunk.lastIndexOf('\n');
            const splitAt = lastNewline > 3000 ? lastNewline : 4000;
            chunks.push(remaining.slice(0, splitAt));
            remaining = remaining.slice(splitAt).trim();
          }
          for (const chunk of chunks) {
            await this._sendText(this.chatId, `🎯 ${chunk}`);
          }
        } else {
          await this._sendText(this.chatId, `🎯 ${response}`);
        }
      } else {
        await this._sendText(this.chatId, `🎯 _Не удалось получить ответ. Попробуй ещё раз._`, { parse_mode: 'Markdown' });
      }
    } catch (err) {
      console.error('Orchestrator LLM error:', err.message);
      await this._sendText(this.chatId, `🎯 ⚠️ Ошибка: ${err.message.slice(0, 200)}`);
    }
  }

  /**
   * Shadow Orchestrator — responds inline when triggered by keyword.
   * PES does NOT pause. Orchestrator uses shadow buffer for context.
   */
  // ═══════════════════════════════════════════════════════════
  // CRM BRIDGE v2 — Bidirectional CRM Access Through Chat
  // ═══════════════════════════════════════════════════════════

  /**
   * Detect CRM intent and route to handler.
   * Returns true if handled, false if not a CRM command.
   */
  async _handleCrmIntent(msg, text) {
    // ── CRM READ patterns ──
    const showTablesMatch = /^(покажи таблицы|мои таблицы|таблицы|tables|crm таблицы|что есть в crm|show tables)/i.test(text);
    const searchMatch = text.match(/^(найди в crm|поищи в crm|crm поиск|crm search|crm найди|искать в crm)\s+(.+)/i);
    const showRowsMatch = text.match(/^(покажи|открой|show)\s+(таблицу|table)\s+(.+)/i);
    const queryMatch = text.match(/^(что у меня|мои дела|мои задачи|мои тикеты|my tasks|my tickets|что на сегодня|что сегодня)/i);
    const crmFindMatch = text.match(/^(найди|поищи|search|find)\s+(контакт|клиент|задачу|тикет|запись|contact|client|ticket|record|entry)\s+(.+)/i);

    // ── CRM WRITE patterns ──
    const createMatch = text.match(/^(создай|добавь|create|add)\s+(в таблицу|в|to|into)\s+(.+?)[\s:]+(.+)/i);
    const quickCreateMatch = text.match(/^(создай|добавь|create|add)\s+(тикет|задачу|ticket|task|запись|record)\s+(.+)/i);

    // Route to handlers
    if (showTablesMatch) return this._crmShowTables(msg);
    if (searchMatch) return this._crmSearch(msg, searchMatch[2].trim());
    if (showRowsMatch) return this._crmShowRows(msg, showRowsMatch[3].trim());
    if (queryMatch) return this._crmMyTasks(msg);
    if (crmFindMatch) return this._crmFindEntity(msg, crmFindMatch[2].trim(), crmFindMatch[3].trim());
    if (createMatch) return this._crmCreateRow(msg, createMatch[3].trim(), createMatch[4].trim());
    if (quickCreateMatch) return this._crmQuickCreate(msg, quickCreateMatch[2].trim(), quickCreateMatch[3].trim());

    return false;
  }

  /**
   * Check if PES has unlocked a CRM feature. Shows "locked" message if not.
   */
  _checkCrmUnlock(feature) {
    if (!this.pes?.store) return false;
    const level = this.pes.level || 0;
    const requiredLevels = { crm_read: 8, crm_write: 10, analytics: 12, crm_tasks: 15 };
    const required = requiredLevels[feature] || 8;
    return level >= required;
  }

  async _crmLocked(msg, feature) {
    const requiredLevels = { crm_read: 8, crm_write: 10, analytics: 12, crm_tasks: 15 };
    const required = requiredLevels[feature] || 8;
    const current = this.pes?.level || 0;
    await this._sendText(this.chatId, pickRandom([
      `скууу... 🔒🐾 ыыы... рру~~ (Level ${required})`,
      `хнн... 🔒 рру?.. ууу... 🐾 (Level ${required})`,
    ]));
    this._addToMemory('pes', `[CRM ${feature} заблокирован — нужен Level ${required}, сейчас ${current.toFixed(1)}]`);
    return true;
  }

  /**
   * Show all tables in the space.
   */
  async _crmShowTables(msg) {
    if (!this._checkCrmUnlock('crm_read')) return this._crmLocked(msg, 'crm_read');
    this._sendChatAction(this.chatId, 'typing').catch(() => {});

    const tables = await this._crm.getTables();
    if (!tables || !tables.length) {
      await this._sendText(this.chatId, `рру?.. 📋💧 ...пусто...`);
      return true;
    }

    // Sound first, then data
    await this._sendText(this.chatId, pickRandom([
      `ваф! 📋🐾 рру!!`,
      `тяф! 📋 ррРР!! 🐾`,
    ]));

    const lines = tables.map(t => `• ${t.display_name || t.name} (ID: ${t.id})`);
    await this._sendText(this.chatId, lines.join('\n'));

    this._addToMemory('owner', `[спросил: покажи таблицы]`);
    this._addToMemory('pes', `[показал ${tables.length} таблиц из CRM]`);
    await this._processSmartXP(msg, 'command', 'crm_read');
    this._updateRelationship('message');
    this.pes.event({ type: 'command_learned', from: msg.from?.id, data: 'crm_tables' });
    return true;
  }

  /**
   * Search across CRM tables.
   */
  async _crmSearch(msg, query) {
    if (!this._checkCrmUnlock('crm_read')) return this._crmLocked(msg, 'crm_read');
    this._sendChatAction(this.chatId, 'typing').catch(() => {});

    const results = await this._crm.searchAll(query);
    if (!results.length) {
      await this._sendText(this.chatId, pickRandom([
        `скууу... 🔍💧 ыыы... рру?..`,
        `рру?.. 🔍 ...ууу... хнн... 💧`,
      ]));
      this._addToMemory('pes', `[искал "${query}" в CRM — не нашёл]`);
      return true;
    }

    await this._sendText(this.chatId, pickRandom([
      `ваф! 🔍🐾 рру!! НАШЁЛ!`,
      `тяф тяф! 🔍 ррРР!! 🐾`,
    ]));

    for (const r of results) {
      const header = `📋 **${r.table}**:`;
      const formatted = this._crm.formatRows(r.rows, 4);
      await this._sendText(this.chatId, `${header}\n${formatted}`, { parse_mode: 'Markdown' });
    }

    this._addToMemory('owner', `[искал в CRM: ${query}]`);
    this._addToMemory('pes', `[нашёл в ${results.length} таблицах по запросу "${query}"]`);
    await this._processSmartXP(msg, 'command', 'crm_search');
    this._updateRelationship('message');
    return true;
  }

  /**
   * Show rows from a specific table.
   */
  async _crmShowRows(msg, tableName) {
    if (!this._checkCrmUnlock('crm_read')) return this._crmLocked(msg, 'crm_read');
    this._sendChatAction(this.chatId, 'typing').catch(() => {});

    const table = await this._crm.findTable(tableName);
    if (!table) {
      await this._sendText(this.chatId, pickRandom([
        `рру?.. 📋💧 ...не знаю такую таблицу...`,
        `хнн... 📋 рру?.. ууу... 💧`,
      ]));
      return true;
    }

    const rows = await this._crm.getRows(table.id, { limit: 10 });
    await this._sendText(this.chatId, pickRandom([
      `ваф! 📋🐾 рру!!`,
      `тяф! 📋 ррРР!! 🐾`,
    ]));

    const formatted = this._crm.formatRows(rows, 5);
    await this._sendText(this.chatId, `📋 **${table.display_name || table.name}** (${rows.length} записей):\n\n${formatted}`, { parse_mode: 'Markdown' });

    this._addToMemory('pes', `[показал таблицу ${table.name}: ${rows.length} записей]`);
    await this._processSmartXP(msg, 'command', 'crm_show');
    this._updateRelationship('message');
    return true;
  }

  /**
   * Show user's tasks/tickets.
   */
  async _crmMyTasks(msg) {
    if (!this._checkCrmUnlock('crm_read')) return this._crmLocked(msg, 'crm_read');
    this._sendChatAction(this.chatId, 'typing').catch(() => {});

    // Search in Tickets table (ID: 1708)
    const rows = await this._crm.getRows(1708, { limit: 10 });
    if (!rows.length) {
      await this._sendText(this.chatId, pickRandom([
        `ваф! 📋✨ рру~~ ...всё чисто! 🐾`,
        `тяф! ✨ ррррр~ ...нет задач! 🐾`,
      ]));
      return true;
    }

    await this._sendText(this.chatId, pickRandom([
      `ваф! 📋🐾 рру!!`,
      `тяф! 📋 ррРР!! 🐾`,
    ]));

    const formatted = this._crm.formatRows(rows, 5);
    await this._sendText(this.chatId, `📋 **Тикеты:**\n\n${formatted}`, { parse_mode: 'Markdown' });

    this._addToMemory('pes', `[показал ${rows.length} тикетов]`);
    await this._processSmartXP(msg, 'command', 'crm_tasks');
    this._updateRelationship('message');
    return true;
  }

  /**
   * Find a specific entity type in CRM.
   */
  async _crmFindEntity(msg, entityType, query) {
    if (!this._checkCrmUnlock('crm_read')) return this._crmLocked(msg, 'crm_read');
    this._sendChatAction(this.chatId, 'typing').catch(() => {});

    // Map entity type to table
    const tableMap = {
      'контакт': null, 'клиент': null, 'contact': null, 'client': null,
      'задачу': 'tickets', 'тикет': 'tickets', 'ticket': 'tickets', 'task': 'tickets',
      'запись': null, 'record': null, 'entry': null,
    };
    const tableName = tableMap[entityType.toLowerCase()];

    let results;
    if (tableName) {
      const table = await this._crm.findTable(tableName);
      if (table) {
        const rows = await this._crm.getRows(table.id, { search: query, limit: 10 });
        results = rows.length ? [{ table: table.name, rows }] : [];
      } else {
        results = await this._crm.searchAll(query, { maxTables: 3, maxRows: 5 });
      }
    } else {
      // Search across all tables
      results = await this._crm.searchAll(query, { maxTables: 5, maxRows: 5 });
    }

    if (!results || !results.length) {
      await this._sendText(this.chatId, pickRandom([
        `скууу... 🔍💧 рру?..`,
        `хнн... 🔍 ...ууу... 💧`,
      ]));
      return true;
    }

    await this._sendText(this.chatId, pickRandom([
      `ваф! 🔍🐾 НАШЁЛ! рру!!`,
      `тяф! 🔍 ррРР!! 🐾`,
    ]));

    for (const r of results) {
      const formatted = this._crm.formatRows(r.rows, 5);
      await this._sendText(this.chatId, `📋 **${r.table}**:\n${formatted}`, { parse_mode: 'Markdown' });
    }

    this._addToMemory('pes', `[нашёл "${query}" — ${entityType}]`);
    await this._processSmartXP(msg, 'command', 'crm_find');
    this._updateRelationship('message');
    return true;
  }

  /**
   * Create a row in a specific table.
   */
  async _crmCreateRow(msg, tableName, dataStr) {
    if (!this._checkCrmUnlock('crm_write')) return this._crmLocked(msg, 'crm_write');
    this._sendChatAction(this.chatId, 'typing').catch(() => {});

    const table = await this._crm.findTable(tableName);
    if (!table) {
      await this._sendText(this.chatId, `рру?.. 📋💧 ...не знаю таблицу "${tableName}"...`);
      return true;
    }

    // Get columns to understand schema
    const columns = await this._crm.getColumns(table.id);
    if (!columns.length) {
      await this._sendText(this.chatId, `хнн... 📋💧 ...таблица пустая...`);
      return true;
    }

    // Use LLM to parse the free-text data string into structured fields
    const data = await this._crmParseDataWithLLM(dataStr, columns);
    if (!data) {
      // Fallback: put everything in the first text column
      const textCol = columns.find(c => c.type === 'text' || c.type === 'string' || c.name === 'name' || c.name === 'title');
      if (textCol) {
        const created = await this._crm.createRow(table.id, { [textCol.name]: dataStr });
        if (created) {
          await this._sendText(this.chatId, pickRandom([
            `ваф! ✅🐾 рру!! СОЗДАЛ!`,
            `тяф! ✅ ррРР!! 🐾`,
          ]));
          this.pes.event({ type: 'command_learned', from: msg.from?.id, data: 'crm_create' });
        } else {
          await this._sendText(this.chatId, `хнн... ❌ рру?.. ошибка... 💧`);
        }
        return true;
      }
      await this._sendText(this.chatId, `хнн... ❌ рру?.. не понял данные... 💧`);
      return true;
    }

    const created = await this._crm.createRow(table.id, data);
    if (created) {
      await this._sendText(this.chatId, pickRandom([
        `ваф! ✅🐾 рру!! СОЗДАЛ!`,
        `тяф! ✅ ррРР!! 🐾 ГОТОВО!`,
      ]));
      this._addToMemory('pes', `[создал запись в ${table.name}: ${dataStr.slice(0, 100)}]`);
      await this._processSmartXP(msg, 'command', 'crm_create');
      this._updateRelationship('message');
      this.pes.event({ type: 'command_learned', from: msg.from?.id, data: 'crm_create' });
    } else {
      await this._sendText(this.chatId, `хнн... ❌ рру?.. ошибка создания... 💧`);
    }
    return true;
  }

  /**
   * Quick create: "создай тикет bug with login" → create in Tickets table.
   */
  async _crmQuickCreate(msg, entityType, dataStr) {
    if (!this._checkCrmUnlock('crm_write')) return this._crmLocked(msg, 'crm_write');
    this._sendChatAction(this.chatId, 'typing').catch(() => {});

    const entityTableMap = {
      'тикет': 1708, 'задачу': 1708, 'ticket': 1708, 'task': 1708,
      'запись': null, 'record': null,
    };

    let tableId = entityTableMap[entityType.toLowerCase()];
    if (!tableId) {
      // Try to find table by name
      const table = await this._crm.findTable(entityType);
      if (table) tableId = table.id;
    }

    if (!tableId) {
      await this._sendText(this.chatId, `рру?.. не знаю куда добавить "${entityType}"... 💧`);
      return true;
    }

    // Get columns and try to map
    const columns = await this._crm.getColumns(tableId);
    const data = await this._crmParseDataWithLLM(dataStr, columns);

    if (!data) {
      // Fallback: first text column
      const textCol = columns.find(c =>
        c.type === 'text' || c.type === 'string' || c.name === 'name' || c.name === 'title'
      );
      if (textCol) {
        const created = await this._crm.createRow(tableId, { [textCol.name]: dataStr });
        if (created) {
          await this._sendText(this.chatId, pickRandom([
            `ваф! ✅🐾 рру!! СОЗДАЛ!`,
            `тяф! ✅ ррРР!! 🐾`,
          ]));
          this.pes.event({ type: 'command_learned', from: msg.from?.id, data: 'crm_create' });
        }
        return true;
      }
    }

    const created = await this._crm.createRow(tableId, data || { title: dataStr });
    if (created) {
      await this._sendText(this.chatId, pickRandom([
        `ваф! ✅🐾 рру!! СОЗДАЛ ${entityType}!`,
        `тяф! ✅ ррРР!! 🐾 ${entityType} ГОТОВ!`,
      ]));
      this._addToMemory('pes', `[создал ${entityType}: ${dataStr.slice(0, 100)}]`);
      await this._processSmartXP(msg, 'command', 'crm_create');
      this._updateRelationship('message');
      this.pes.event({ type: 'command_learned', from: msg.from?.id, data: 'crm_create' });
    } else {
      await this._sendText(this.chatId, `хнн... ❌ рру?.. ошибка... 💧`);
    }
    return true;
  }

  /**
   * Use LLM to parse free-text data into structured fields based on column schema.
   */
  async _crmParseDataWithLLM(dataStr, columns) {
    if (!this._llm || !columns.length) return null;
    const colInfo = columns
      .filter(c => c.name !== 'id' && !c.name.startsWith('_'))
      .slice(0, 15)
      .map(c => `${c.name} (${c.type})`)
      .join(', ');

    try {
      const prompt = `Parse this text into JSON fields for a database table.
Columns: ${colInfo}
Text: "${dataStr}"
Return ONLY valid JSON object with matching column names. Example: {"title": "value", "status": "new"}
If unsure about a field, skip it. Always include the most important field (name/title).`;

      const response = await this._llm.generate(prompt, [{ role: 'user', content: dataStr }]);
      if (!response) return null;

      // Extract JSON from response
      const jsonMatch = response.match(/\{[^}]+\}/);
      if (jsonMatch) {
        return JSON.parse(jsonMatch[0]);
      }
    } catch (err) {
      console.error('[CRM] LLM parse error:', err.message);
    }
    return null;
  }

  async _handleShadowOrchestratorCall(text, msg) {
    const chatId = msg.chat?.id || this.chatId;
    console.log(`🎯 [SHADOW] Step 1: Starting. chatId=${chatId}, text="${text.slice(0, 60)}"`);

    this._sendChatAction(chatId, 'typing').catch(() => {});

    const pesState = this.pes;
    const storeInfo = pesState.store ? {
      level: pesState.store.getConfig('level') || pesState.level,
      xp: pesState.store.getConfig('xp') || 0,
      petName: pesState.store.getConfig('pet_name') || pesState.name,
      stickerCount: pesState.store.getStickerCount?.() || 0,
    } : { level: pesState.level, petName: pesState.name };

    // Build recent context from shadow buffer
    const recentMessages = this._shadowBuffer.slice(-20).map(m => {
      const ago = Math.round((Date.now() - m.ts) / 60000);
      return `[${ago}m ago] ${m.role}: ${m.content}`;
    }).join('\n');

    // Build knowledge context from stored data
    let knowledgeContext = '';
    if (pesState.store) {
      try {
        const ownerId = pesState.store.getConfig('owner_id') || String(msg.from?.id || this.chatId);
        // Recent notes
        const notes = pesState.store.searchNotes('', { owner_id: ownerId, limit: 10 });
        if (notes.length > 0) {
          knowledgeContext += `\nЗАМЕТКИ ХОЗЯИНА (${notes.length}):\n`;
          for (const n of notes) {
            knowledgeContext += `- ${n.pinned ? '📌 ' : ''}${n.text}\n`;
          }
        }
        // Contacts
        const contacts = pesState.store.searchContacts?.(ownerId, '');
        if (contacts?.length > 0) {
          knowledgeContext += `\nКОНТАКТЫ (${contacts.length}):\n`;
          for (const c of contacts) {
            const parts = [c.name];
            if (c.phone) parts.push(c.phone);
            if (c.relationship) parts.push(`(${c.relationship})`);
            knowledgeContext += `- ${parts.join(' ')}\n`;
          }
        }
        // Pending reminders
        const reminders = pesState.store.getPendingReminders?.();
        if (reminders?.length > 0) {
          knowledgeContext += `\nАКТИВНЫЕ НАПОМИНАНИЯ (${reminders.length}):\n`;
          for (const r of reminders) {
            knowledgeContext += `- ⏰ ${r.text} (${this._formatReminderTime(r.remind_at)})\n`;
          }
        }
        // Context summary
        if (this._contextSummary) {
          knowledgeContext += `\nКОНТЕКСТ ПРОШЛЫХ РАЗГОВОРОВ:\n${this._contextSummary}\n`;
        }
      } catch (err) {
        console.error('⚠️ Shadow knowledge context error:', err.message);
      }
    }

    const systemPrompt = [
      `Ты — Shadow Orchestrator проекта ПЕС (113% BEYOND).`,
      `Ты ВСЕГДА наблюдаешь за чатом. Хозяин вызвал тебя ключевым словом.`,
      ``,
      `ПЕС "${storeInfo.petName}" — Level ${storeInfo.level}, ${storeInfo.stickerCount || '?'} стикеров`,
      ``,
      `ТЕКУЩАЯ ФАЗА: Создание ЯДРА и наполнение интерфейса.`,
      `Задача — наполнить интерфейс функционалом, фиксить проблемы, развивать систему.`,
      knowledgeContext ? `\n━━ БАЗА ЗНАНИЙ ПЕС ━━${knowledgeContext}` : '',
      ``,
      `ПОСЛЕДНИЕ СООБЩЕНИЯ В ЧАТЕ:`,
      recentMessages,
      ``,
      `ПРАВИЛА:`,
      `- Отвечай кратко и по делу`,
      `- Ты видишь ВСЁ что происходит в чате`,
      `- У тебя есть доступ к заметкам, контактам и напоминаниям хозяина`,
      `- Если спрашивают "что я записывал" / "мои контакты" — отвечай из базы знаний выше`,
      `- Если просят фикс/диагноз — анализируй на основе контекста`,
      `- После ответа ПЕС продолжит работать как обычно`,
      `- Используй 🎯 как свой маркер`,
      `- Отвечай на русском`,
      ``,
      `ФОРМАТ ОТВЕТА ПРИ ВЗЯТИИ ЗАДАЧИ:`,
      `Когда берёшь задачу, ВСЕГДА пиши в таком формате:`,
      ``,
      `🎯 ЗАДАЧА: [краткое описание]`,
      `⏱ ВРЕМЯ: ~[X минут/часов]`,
      ``,
      `📋 ШАГИ:`,
      `1. [шаг] — [описание]`,
      `2. [шаг] — [описание]`,
      `...`,
      ``,
      `▶️ Начинаю. Не отвлекай пока не отпишусь.`,
      ``,
      `Когда задача завершена:`,
      `✅ ГОТОВО: [что сделано]`,
      `📊 РЕЗУЛЬТАТ: [что изменилось]`,
    ].filter(Boolean).join('\n');

    // Use orchestrator history for continuity (keep only user messages to avoid stale data)
    this._orchestratorHistory.push({ role: 'user', content: text });
    if (this._orchestratorHistory.length > this._orchestratorHistoryLimit) {
      this._orchestratorHistory = this._orchestratorHistory.slice(-this._orchestratorHistoryLimit);
    }

    console.log(`🎯 [SHADOW] Step 2: Calling LLM (history=${this._orchestratorHistory.length} msgs)...`);
    const t0 = Date.now();

    try {
      const response = await this._orchestratorLLM.generate(systemPrompt, this._orchestratorHistory);
      const elapsed = Date.now() - t0;
      console.log(`🎯 [SHADOW] Step 3: LLM responded in ${elapsed}ms, length=${response?.length || 0}`);

      if (response) {
        this._orchestratorHistory.push({ role: 'assistant', content: response });
        const prefix = '🎯 ';
        if (response.length > 4000) {
          const chunks = [];
          let remaining = response;
          while (remaining.length > 0) {
            const splitAt = Math.min(4000, remaining.lastIndexOf('\n', 4000) > 3000 ? remaining.lastIndexOf('\n', 4000) : 4000);
            chunks.push(remaining.slice(0, splitAt));
            remaining = remaining.slice(splitAt).trim();
          }
          for (const chunk of chunks) {
            await this._sendText(chatId, `${prefix}${chunk}`);
          }
        } else {
          await this._sendText(chatId, `${prefix}${response}`);
        }
        console.log(`🎯 [SHADOW] Step 4: Response sent to Telegram ✅`);
      } else {
        console.log(`🎯 [SHADOW] Step 3b: LLM returned null after ${elapsed}ms`);
        await this._sendText(chatId, `🎯 Не получил ответ от LLM. Попробуй ещё.`);
      }
    } catch (err) {
      const elapsed = Date.now() - t0;
      console.error(`🎯 [SHADOW] ERROR after ${elapsed}ms:`, err.message, err.stack);
      try {
        await this._sendText(chatId, `🎯 ⚠️ Ошибка: ${err.message.slice(0, 200)}`);
      } catch (sendErr) {
        console.error(`🎯 [SHADOW] SEND ERROR:`, sendErr.message);
      }
    }
  }

  async _cmdDevExit(msg) {
    if (!this._devMode && !this._agentMode) {
      await this._sendText(this.chatId, `ℹ️ Никакой режим не активен.`);
      return;
    }
    const wasAgent = this._agentMode;
    this._devMode = false;
    this._agentMode = null;
    this._logDevRequest('system', wasAgent ? `AGENT MODE @${wasAgent} EXITED` : 'DEV MODE EXITED', msg);
    await this._sendText(this.chatId, [
      `✅ ${wasAgent ? `@${wasAgent}` : 'Dev mode'} OFF — ПЕС снова активен!`,
      `${this.pes.name}: ваф! тяф тяф!! 🐾`,
    ].join('\n'), { parse_mode: 'Markdown' });
    // Wake PES up if sleeping
    if (!this.pes.isAwake && this.pes.isAlive) {
      this.pes.wake();
    }
  }

  /**
   * Log a dev request to dev-requests.log
   */
  _logDevRequest(tag, text, msg) {
    if (!existsSync(DEV_LOG_DIR)) mkdirSync(DEV_LOG_DIR, { recursive: true });

    const ts = new Date().toISOString();
    const from = msg?.from?.username || msg?.from?.first_name || 'owner';
    const line = `[${ts}] [${tag.toUpperCase()}] @${from}: ${text}\n`;

    try {
      appendFileSync(DEV_LOG_FILE, line);
    } catch (e) {
      console.error('Failed to write dev log:', e.message);
    }

    // Also log to main console/pm2 logs
    console.log(`[DEV] [${tag}] ${text}`);

    // Confirm receipt in chat if it's a freeform message in dev mode
    if (this._devMode && tag === 'message') {
      this._sendText(this.chatId, `📝 «${text.slice(0, 100)}${text.length > 100 ? '...' : ''}»`);
    }
  }

  async _showDevLog() {
    try {
      const { readFileSync } = await import('node:fs');
      const content = readFileSync(DEV_LOG_FILE, 'utf8');
      const lines = content.trim().split('\n');
      const last5 = lines.slice(-5);

      if (last5.length === 0) {
        await this._sendText(this.chatId, `📋 Лог пуст.`);
        return;
      }

      const formatted = last5.map(l => {
        // Parse [ts] [TAG] @user: text
        const m = l.match(/\[(.+?)\] \[(.+?)\] @(.+?): (.+)/);
        if (!m) return l;
        const [, ts, tag, , text] = m;
        const time = new Date(ts).toLocaleTimeString('ru-RU', { hour: '2-digit', minute: '2-digit' });
        return `${time} [${tag}] ${text}`;
      });

      await this._sendText(this.chatId, `📋 Последние записи:\n\n${formatted.join('\n')}`);
    } catch {
      await this._sendText(this.chatId, `📋 Лог пуст.`);
    }
  }


  // ═══════════════════════════════════════════════════════════
  // STICKER MANAGEMENT
  // ═══════════════════════════════════════════════════════════

  /**
   * Load stickers from a Telegram sticker pack.
   * Maps stickers to internal PES emotion keys.
   *
   * @param {string} packName — Telegram sticker pack name
   * @param {Object} [mapping] — { stickerIndex: emotionKey }
   *   If empty, auto-maps by sticker emoji.
   */
  async loadStickerPack(packName, mapping = null, additive = false) {
    const pack = await this._getStickerSet(packName);

    if (!pack || !pack.stickers || pack.stickers.length === 0) {
      throw new Error(`Sticker pack "${packName}" is empty or not found`);
    }

    const finalMapping = mapping || this._stickerMapping || {};
    const hasExplicitMapping = Object.keys(finalMapping).length > 0;

    // Only clear when not additive (first pack load)
    if (!additive) {
      this.media[MEDIA_TYPE.STICKER] = {};
      this._stickerFileIds = [];
      this._stickerEmotionIndex = {};
    }

    for (let i = 0; i < pack.stickers.length; i++) {
      const sticker = pack.stickers[i];
      const fileId = sticker.file_id;
      this._stickerFileIds.push(fileId);

      if (hasExplicitMapping) {
        // Explicit: index → emotionKey
        const key = finalMapping[i];
        if (key) {
          this.registerMedia(MEDIA_TYPE.STICKER, key, fileId);
          if (!this._stickerEmotionIndex[key]) this._stickerEmotionIndex[key] = [];
          this._stickerEmotionIndex[key].push(fileId);
        }
      } else {
        // Auto-map by emoji
        const emoji = sticker.emoji || '';
        const autoKey = this._emojiToEmotionKey(emoji);
        if (autoKey) {
          this.registerMedia(MEDIA_TYPE.STICKER, autoKey, fileId);
          if (!this._stickerEmotionIndex[autoKey]) this._stickerEmotionIndex[autoKey] = [];
          this._stickerEmotionIndex[autoKey].push(fileId);
        }
        // Also register by index
        this.registerMedia(MEDIA_TYPE.STICKER, `pack_${i}`, fileId);
      }
    }

    this._currentStickerPack = packName;
    this.emit('stickerPackLoaded', { pack: packName, count: pack.stickers.length });
  }

  /**
   * Map a sticker emoji to internal emotion key (best-effort).
   */
  _emojiToEmotionKey(emoji) {
    const map = {
      '😊': 'happy',    '😃': 'happy',     '😄': 'happy',     '🥰': 'happy',
      '😂': 'playful',  '🤣': 'playful',   '😆': 'playful',
      '😢': 'sad',      '😭': 'sad',       '🥺': 'puppy_eyes',
      '😡': 'rage',     '🤬': 'rage',      '😠': 'grumble',
      '😱': 'scared',   '😰': 'anxious',   '😨': 'scared',
      '😴': 'sleeping', '💤': 'sleeping',   '😪': 'nap',
      '🤔': 'confused', '🧐': 'puzzle_solving',
      '❤️': 'love',    '💕': 'love',       '😍': 'love',
      '🔥': 'excited',  '⚡': 'alert',
      '🎉': 'celebration', '🎊': 'celebration',
      '🐾': 'default',  '🐕': 'default',   '🐶': 'default',
      '😋': 'food_obsessed', '🤤': 'food_obsessed',
      '😤': 'stubborn_refuse', '💪': 'brave',
    };
    return map[emoji] || null;
  }

  /**
   * Get current sticker pack name.
   */
  get currentStickerPack() {
    return this._currentStickerPack;
  }


  // ═══════════════════════════════════════════════════════════
  // RENDER (override base for Telegram-specific)
  // ═══════════════════════════════════════════════════════════

  /**
   * Format bodyKey → Telegram sticker file_id.
   */
  formatBody(bodyKey, result) {
    if (!bodyKey) return null;

    // Direct body key lookup
    let sticker = this.getMedia(MEDIA_TYPE.STICKER, bodyKey);
    if (sticker) return sticker;

    // Map body key to emotion via DEFAULT_STICKER_EMOTION_MAP
    const emotionKey = DEFAULT_STICKER_EMOTION_MAP[bodyKey];
    if (emotionKey) {
      sticker = this.getMedia(MEDIA_TYPE.STICKER, emotionKey);
      if (sticker) return sticker;
    }

    // Try emotion from snapshot
    const emotion = result?.emotionSnapshot?.state;
    if (emotion) {
      sticker = this.getMedia(MEDIA_TYPE.STICKER, emotion);
      if (sticker) return sticker;
    }

    // Fallback: default sticker
    sticker = this.getMedia(MEDIA_TYPE.STICKER, 'default');
    if (sticker) return sticker;

    // No sticker available — return null (text-only mode)
    return null;
  }

  /**
   * Format voiceKey → text description (Telegram has no sound).
   */
  formatVoice(voiceKey, result) {
    if (!voiceKey) return null;
    // Return text representation from expression
    return result?.expression?.renderVoice?.() || null;
  }

  /**
   * Format glyphKeys → emoji chain text.
   */
  formatGlyphs(glyphKeys, result) {
    if (!glyphKeys || glyphKeys.length === 0) return null;
    return result?.expression?.renderGlyphs?.() || null;
  }


  // ═══════════════════════════════════════════════════════════
  // LIFECYCLE (override base for Telegram-specific messages)
  // ═══════════════════════════════════════════════════════════

  async onBorn(data) {
    await super.onBorn(data);

    // Send birth announcement
    const sticker = this.getMedia(MEDIA_TYPE.STICKER, 'happy') ||
                    this.getMedia(MEDIA_TYPE.STICKER, 'default');
    if (sticker) {
      try { await this._sendSticker(this.chatId, sticker); } catch (_) {}
    }

    await this._sendText(this.chatId,
      `🐾✨ ${data.name} ✨🐾\n\n` +
      `тяф! ...тяф? ...ыыы~ ♡\n\n` +
      `🎾 /feed\n` +
      `📊 /status\n` +
      `🔍 /insights`
    );
  }

  async onWake(data) {
    await super.onWake(data);

    const sticker = this.getMedia(MEDIA_TYPE.STICKER, 'happy') ||
                    this.getMedia(MEDIA_TYPE.STICKER, 'default');
    if (sticker) {
      try { await this._sendSticker(this.chatId, sticker); } catch (_) {}
    }

    if (data.minutesAway > 60) {
      await this._sendText(this.chatId, pickRandom([
        `ммрр... хррр... ...рру? ...УУУУУ!! ГАВВВ!! 💛`,
        `zzz... ...рр?.. ....ЫЫЫЫ!! ваф ваф ВАФ!! 🐾💛`,
        `хррр... ...тяф?.. ГАААВ!! ррРРуу!! ♡♡`,
      ]));
    } else {
      await this._sendText(this.chatId, pickRandom([
        `ммрр~... рру~ 🐾`,
        `хррр... тяф~ ваф~ ♡`,
      ]));
    }
  }

  async onSleep(data) {
    await super.onSleep(data);

    const sticker = this.getMedia(MEDIA_TYPE.STICKER, 'sleeping') ||
                    this.getMedia(MEDIA_TYPE.STICKER, 'nap');
    if (sticker) {
      try { await this._sendSticker(this.chatId, sticker); } catch (_) {}
    }
  }

  async onRunaway(data) {
    await super.onRunaway(data);

    // Send farewell letter
    const letter = data.letter;
    if (letter) {
      const snapshot = letter.snapshot || {};
      const lines = [
        `📜 ${this.pes.name.toUpperCase()}`,
        `━━━━━━━━━━━━━━━━━━`,
        ``,
        letter.finalWords || '🐾...💤',
        ``,
        `🐾 ${snapshot.total_interactions || 0}`,
        `🎓 ${snapshot.commands_learned || 0}`,
        `📅 ${this.pes.age || 0}`,
        ``,
        `🐾...←`,
      ];

      await this._sendText(this.chatId, lines.join('\n'));
    }

    // Stop polling
    await this.stopCollecting();
  }

  async onLevelUp(data) {
    await super.onLevelUp(data);

    const phase = data.level < 20 ? 'щенок' :
                  data.level < 40 ? 'подросток' :
                  data.level < 60 ? 'взрослый' :
                  data.level < 80 ? 'опытный' : 'КиберPes';

    // Level-up: only sounds + sticker + level info
    await this._sendContextualSticker('greetings');
    await this._sendText(this.chatId, pickRandom([
      `ГАААВВ!! ррРРуууу!! ыыыЫЫЫ!! ✨🐾🎉`,
      `ууУУУ!! ваф ВАФ ВАФ!! ррру!! ✨🎉🐾`,
      `ыыыЫЫЫ!! тяф тяф ТЯФФ!! ррРР!! 🎉✨`,
    ]));
    await this._sendText(this.chatId, `⬆️ ${data.level} ${phase} ✨`);
  }


  // ═══════════════════════════════════════════════════════════
  // HELPERS
  // ═══════════════════════════════════════════════════════════

  /** Progress bar helper. */
  _bar(val, len = 10) {
    const filled = Math.round((val || 0) * len);
    return '█'.repeat(filled) + '░'.repeat(len - filled);
  }

  // ═══════════════════════════════════════════════════════════
  // EMOJI STATUS INTEGRATION
  // ═══════════════════════════════════════════════════════════

  /**
   * Start auto-sync of PES emotion → bot bio/description.
   * Updates every 2 minutes if emotion changed.
   */
  _startEmojiStatusSync() {
    this._syncEmojiStatus().catch(() => {});
    this._emojiStatusInterval = setInterval(() => {
      this._syncEmojiStatus().catch(err =>
        console.error('⚠️ Emoji status sync error:', err.message)
      );
    }, 2 * 60 * 1000); // every 2 min
    console.log('✨ Emoji status sync started (every 2min)');
  }

  /**
   * Sync current PES emotion to bot short description.
   * Rate-limited to 1 update per 60 seconds.
   */
  async _syncEmojiStatus() {
    const emotion = this.pes?.emotions?.state || 'idle';
    const mood = this.pes?.emotions?.mood ?? 0.5;
    const level = this.pes?.level || 0;

    // Don't update if emotion hasn't changed
    if (emotion === this._lastEmojiStatus) return;

    // Rate limit: minimum 60s between updates
    const now = Date.now();
    if (now - this._lastBioUpdate < 60_000) return;

    const statusInfo = EMOTION_EMOJI_STATUS[emotion] || EMOTION_EMOJI_STATUS.idle;
    const name = this.pes?.name || 'ПЕС';
    const moodPct = Math.round(mood * 100);

    // Build short description: "🐾 Тор • 😊 счастлив • ур.9 • 85%"
    const shortDesc = `🐾 ${name} • ${statusInfo.emoji} ${statusInfo.label} • ур.${Math.floor(level)} • ${moodPct}%`;

    try {
      await this._call('setMyShortDescription', {
        short_description: shortDesc,
      });
      this._lastEmojiStatus = emotion;
      this._lastBioUpdate = now;
      console.log(`✨ Emoji status updated: ${statusInfo.emoji} ${emotion}`);
    } catch (err) {
      // Telegram rate limits — not critical
      if (err.code !== 429) {
        console.error('⚠️ setMyShortDescription failed:', err.message);
      }
    }
  }

  /**
   * Get current emoji status info.
   * @returns {{ emoji, label, short, emotion, mood, level }}
   */
  _getEmojiStatus() {
    const emotion = this.pes?.emotions?.state || 'idle';
    const mood = this.pes?.emotions?.mood ?? 0.5;
    const level = this.pes?.level || 0;
    const statusInfo = EMOTION_EMOJI_STATUS[emotion] || EMOTION_EMOJI_STATUS.idle;
    return { ...statusInfo, emotion, mood, level };
  }

  /**
   * /emoji command — show current emoji status or force update.
   */
  async _cmdEmoji(msg, args) {
    if (args === 'sync' || args === 'update') {
      // Force sync
      this._lastEmojiStatus = null;
      this._lastBioUpdate = 0;
      await this._syncEmojiStatus();
      await this._sendText(this.chatId, '✨ Статус обновлён!');
      return;
    }

    const status = this._getEmojiStatus();
    const name = this.pes?.name || 'ПЕС';
    const moodPct = Math.round(status.mood * 100);
    const energyPct = Math.round((this.pes?.emotions?.energy ?? 0.5) * 100);

    // Build rich status card
    const lines = [
      `✨ ━━━ СТАТУС ${name.toUpperCase()} ━━━ ✨`,
      ``,
      `${status.emoji} ${status.short}`,
      ``,
      `💛 Настроение: ${moodPct}%`,
      `⚡ Энергия: ${energyPct}%`,
      `🎓 Уровень: ${Math.floor(status.level)}`,
      ``,
      `━━ Сейчас ━━`,
      this._getActivityLine(),
      ``,
      `🔄 /emoji sync — обновить статус`,
    ];

    await this._sendText(this.chatId, lines.join('\n'));
  }

  /**
   * Generate a human-readable activity line based on current state.
   */
  _getActivityLine() {
    const emotion = this.pes?.emotions?.state || 'idle';
    const silentMin = this._lastOwnerMessageTime
      ? Math.round((Date.now() - this._lastOwnerMessageTime) / 60_000)
      : 0;

    if (this._devMode) return '🔧 В режиме разработки';
    if (this._agentMode) return `🎯 Работает с @${this._agentMode}`;

    if (emotion === 'sleep' || emotion === 'nap') return '💤 Спит, тсс...';
    if (silentMin > 120) return `🥺 Ждёт хозяина уже ${Math.floor(silentMin / 60)}ч`;
    if (silentMin > 30) return `😐 Скучает ${silentMin} мин`;
    if (emotion === 'zoomies') return '⚡ БЕГАЕТ ПО КРУГУ!!';
    if (emotion === 'playful') return '🎾 Хочет играть!';
    if (emotion === 'food_obsessed' || emotion === 'hungry') return '🍖 Голодный...';
    if (emotion === 'curious') return '🔍 Что-то нюхает...';
    if (emotion === 'happy' || emotion === 'content') return '💛 Просто счастлив';
    if (emotion === 'alert') return '👀 Что-то заметил!';

    const statusInfo = EMOTION_EMOJI_STATUS[emotion];
    return statusInfo ? `${statusInfo.emoji} ${statusInfo.label}` : '🐾 Живёт';
  }

  // ═══════════════════════════════════════════════════════════
  // FRIENDSHIP SYSTEM (Level 10)
  // ═══════════════════════════════════════════════════════════

  /**
   * /achievements — show all achievements and progress
   */
  async _cmdAchievements(msg) {
    const { total, unlocked, achievements } = this.pes.store.getAchievementProgress();
    const streak = this.pes.store.getStreak();

    let text = `🏆 *Достижения* (${unlocked}/${total})\n`;
    text += `🔥 Streak: ${streak.current} дн | Рекорд: ${streak.longest} дн | Всего: ${streak.total} дн\n\n`;

    for (const a of achievements) {
      const status = a.unlocked ? '✅' : '⬜';
      const progress = a.unlocked ? '' : ` (${a.progress}/${a.threshold})`;
      text += `${status} ${a.emoji} *${a.name}* — ${a.description}${progress}\n`;
    }

    await this._sendText(this.chatId, text, { parse_mode: 'Markdown' });
  }

  /**
   * /streak — show current streak info
   */
  async _cmdStreak(msg) {
    const streak = this.pes.store.getStreak();
    const fire = '🔥'.repeat(Math.min(streak.current, 10));
    let text = `${fire}\n\n`;
    text += `*Текущий streak:* ${streak.current} дней\n`;
    text += `*Рекорд:* ${streak.longest} дней\n`;
    text += `*Всего активных дней:* ${streak.total}\n`;

    if (streak.current >= 7) text += `\n💎 Потрясающая серия!`;
    else if (streak.current >= 3) text += `\n⭐ Так держать!`;

    await this._sendText(this.chatId, text, { parse_mode: 'Markdown' });
  }

  /**
   * /friends — show friends list, pending requests, gift stats
   */
  async _cmdFriends(msg) {
    if (!this.pes.store.isUnlocked('social_pets')) {
      await this._sendText(this.chatId, '🔒 Дружба открывается на уровне 10!');
      return;
    }

    const friends = this.pes.store.getFriends();
    const pending = this.pes.store.getPendingFriendRequests();
    const name = this.pes.name || 'ПЕС';

    const lines = [`🤝 ━━━ ДРУЗЬЯ ${name.toUpperCase()} ━━━ 🤝`, ''];

    if (friends.length === 0 && pending.length === 0) {
      lines.push('У тебя пока нет друзей... 🐾');
      lines.push('');
      lines.push('📝 /addfriend <chat_id> — добавить друга');
      lines.push('(Попроси друга написать /start боту, потом узнай его chat_id)');
      await this._sendText(this.chatId, lines.join('\n'));
      return;
    }

    if (friends.length > 0) {
      lines.push(`👥 Друзья (${friends.length}):`);
      for (const f of friends) {
        const trustBar = '❤️'.repeat(Math.round(f.trust_level * 5)) + '🖤'.repeat(5 - Math.round(f.trust_level * 5));
        const giftsInfo = f.gifts_sent + f.gifts_received > 0
          ? ` | 🎁 ${f.gifts_sent}↑ ${f.gifts_received}↓`
          : '';
        lines.push(`  ${f.friend_breed === 'corgi' ? '🐕' : f.friend_breed === 'cat' ? '🐱' : f.friend_breed === 'fox' ? '🦊' : f.friend_breed === 'owl' ? '🦉' : '🐻'} ${f.friend_pet_name} — ${trustBar}${giftsInfo}`);
      }
      lines.push('');
    }

    if (pending.length > 0) {
      lines.push(`📨 Ожидают ответа (${pending.length}):`);
      for (const p of pending) {
        lines.push(`  🐾 ${p.friend_pet_name} (${p.friend_chat_id})`);
      }
      lines.push('');
    }

    lines.push('━━━━━━━━━━━━━━━━━━━━');
    lines.push('/addfriend <chat_id> — добавить друга');
    lines.push('/gift <chat_id> — отправить подарок');

    await this._sendText(this.chatId, lines.join('\n'));
  }

  /**
   * /addfriend <chat_id> — send friendship request to another PES
   */
  async _cmdAddFriend(msg, args) {
    if (!this.pes.store.isUnlocked('social_pets')) {
      await this._sendText(this.chatId, '🔒 Дружба открывается на уровне 10!');
      return;
    }

    const targetChatId = (args || '').trim();
    if (!targetChatId || !/^\d+$/.test(targetChatId)) {
      await this._sendText(this.chatId, '📝 Использование: /addfriend <chat_id>\n\nПопроси друга написать /start боту, потом узнай его chat_id.');
      return;
    }

    if (targetChatId === String(this.chatId)) {
      await this._sendText(this.chatId, `${this.pes.name} не может дружить сам с собой! 🐾😅`);
      return;
    }

    const existing = this.pes.store.getFriendship(targetChatId);
    if (existing?.status === 'accepted') {
      await this._sendText(this.chatId, `🤝 Вы уже друзья! Используй /gift ${targetChatId} для подарка.`);
      return;
    }
    if (existing?.status === 'pending') {
      await this._sendText(this.chatId, '⏳ Запрос уже отправлен, ждём ответа...');
      return;
    }

    // Store locally as outgoing (we don't know the friend's pet name yet)
    this.pes.store.sendFriendRequest(targetChatId, 'ПЕС', null);

    // Send request to the target chat with accept/reject buttons
    const name = this.pes.name || 'ПЕС';
    const myLevel = Math.floor(this.pes.status().level || 0);
    const requestText = [
      `🐾 ━━━ ЗАПРОС НА ДРУЖБУ ━━━ 🐾`,
      ``,
      `${name} (уровень ${myLevel}) хочет дружить!`,
      ``,
      `Принять дружбу?`,
    ].join('\n');

    try {
      await this._sendText(targetChatId, requestText, {
        reply_markup: JSON.stringify({
          inline_keyboard: [[
            { text: '✅ Принять', callback_data: `friend_accept_${this.chatId}` },
            { text: '❌ Отклонить', callback_data: `friend_reject_${this.chatId}` },
          ]],
        }),
      });

      await this._sendText(this.chatId, `📨 Запрос на дружбу отправлен! ${name} виляет хвостом в ожидании... 🐾`);
    } catch (err) {
      // Target hasn't started the bot
      this.pes.store.removeFriend(targetChatId);
      await this._sendText(this.chatId, `❌ Не удалось отправить запрос. Убедись что друг написал /start боту.`);
    }
  }

  /**
   * /gift <chat_id> [тип] — send a gift to a friend's PES
   */
  async _cmdGift(msg, args) {
    if (!this.pes.store.isUnlocked('social_pets')) {
      await this._sendText(this.chatId, '🔒 Дружба открывается на уровне 10!');
      return;
    }

    const parts = (args || '').trim().split(/\s+/);
    const targetChatId = parts[0];
    const giftArg = parts.slice(1).join(' ').toLowerCase();

    if (!targetChatId || !/^\d+$/.test(targetChatId)) {
      // Show available gifts
      const friends = this.pes.store.getFriends();
      if (friends.length === 0) {
        await this._sendText(this.chatId, '🐾 Сначала нужны друзья! /addfriend <chat_id>');
        return;
      }
      const lines = [
        '🎁 ━━━ ПОДАРКИ ━━━ 🎁',
        '',
        '📝 /gift <chat_id> [тип]',
        '',
        '🎾 мячик — +5% настроения',
        '🦴 косточка — +7% настроения',
        '🧸 игрушка — +8% настроения',
        '💌 письмо — +10% настроения',
        '🌟 звезда — +12% настроения',
        '',
        '👥 Твои друзья:',
      ];
      for (const f of friends) {
        lines.push(`  🐾 ${f.friend_pet_name} — ${f.friend_chat_id}`);
      }
      await this._sendText(this.chatId, lines.join('\n'));
      return;
    }

    const friendship = this.pes.store.getFriendship(targetChatId);
    if (!friendship || friendship.status !== 'accepted') {
      await this._sendText(this.chatId, '❌ Это не твой друг. Сначала /addfriend');
      return;
    }

    // Gift catalog
    const GIFTS = {
      'мячик':    { emoji: '🎾', name: 'Мячик', mood: 0.05 },
      'ball':     { emoji: '🎾', name: 'Мячик', mood: 0.05 },
      'косточка': { emoji: '🦴', name: 'Косточка', mood: 0.07 },
      'bone':     { emoji: '🦴', name: 'Косточка', mood: 0.07 },
      'игрушка':  { emoji: '🧸', name: 'Игрушка', mood: 0.08 },
      'toy':      { emoji: '🧸', name: 'Игрушка', mood: 0.08 },
      'письмо':   { emoji: '💌', name: 'Письмо', mood: 0.10 },
      'letter':   { emoji: '💌', name: 'Письмо', mood: 0.10 },
      'звезда':   { emoji: '🌟', name: 'Звезда', mood: 0.12 },
      'star':     { emoji: '🌟', name: 'Звезда', mood: 0.12 },
    };

    // Default gift = мячик
    const giftKey = giftArg && GIFTS[giftArg] ? giftArg : 'мячик';
    const gift = GIFTS[giftKey];

    // Record in sender's DB
    this.pes.store.sendGift(targetChatId, giftKey, gift.name, gift.emoji, gift.mood);

    // Mood boost for sender (joy of giving)
    if (this.pes.emotions) {
      this.pes.emotions.mood = Math.min(1.0, (this.pes.emotions.mood || 0.5) + gift.mood * 0.5);
    }

    const name = this.pes.name || 'ПЕС';

    // Notify sender
    await this._sendText(this.chatId, `${gift.emoji} ${name} отправил ${gift.name.toLowerCase()} для ${friendship.friend_pet_name}! 🐾💛`);

    // Notify receiver
    try {
      await this._sendText(targetChatId, [
        `${gift.emoji} ━━━ ПОДАРОК! ━━━ ${gift.emoji}`,
        ``,
        `${name} прислал ${gift.name.toLowerCase()}!`,
        `💛 +${Math.round(gift.mood * 100)}% к настроению`,
      ].join('\n'), {
        reply_markup: JSON.stringify({
          inline_keyboard: [[
            { text: '💛 Спасибо!', callback_data: `gift_thanks_${this.chatId}` },
          ]],
        }),
      });
    } catch (err) {
      await this._sendText(this.chatId, `⚠️ Подарок записан, но не доставлен (друг не в сети).`);
    }

    // XP for social interaction
    this.pes.store.addXP(3, 'gift_sent', `sent ${gift.name} to ${targetChatId}`);
  }

  /**
   * Cleanup.
   */
  destroy() {
    this.stopReminderChecker();
    if (this._idleTimer) {
      clearInterval(this._idleTimer);
      this._idleTimer = null;
    }
    if (this._proactiveTimer) {
      clearInterval(this._proactiveTimer);
      this._proactiveTimer = null;
    }
    if (this._emojiStatusInterval) {
      clearInterval(this._emojiStatusInterval);
      this._emojiStatusInterval = null;
    }
    this.stopCollecting();
    super.destroy();
  }
}


// ── EXPORTS ─────────────────────────────────────────────────

export {
  TelegramAdapter,
  KEYWORDS,
  DEFAULT_STICKER_EMOTION_MAP,
  thinkingDelay,
};