autoreg-skills-max: initial public release (restored, redacted, hardened)

2026-10-20 02:16:32 +03:00
commit f58eafeb48
565 changed files with 60064 additions and 0 deletions
--- a/skills/telegram-automation/SKILL.md
+++ b/skills/telegram-automation/SKILL.md
@@ -0,0 +1,374 @@
+---
+name: telegram-automation
+description: Telethon-based Telegram automation — spam, join, leave, session repair, flood handling. Use when building Telegram bots, mass messaging, chat management, or fixing broken Telethon sessions.
+category: automation
+tags: [telegram, telethon, spam, flood, sessions, cron]
+triggers:
+  - рассылка
+  - спам
+  - Telegram spam
+  - telethon
+  - Telethon session
+  - session repair
+  - flood wait
+  - массовая рассылка
+  - выход из чатов
+  - join чаты
+  - авто-рассылка
+---
+
+# Telegram Automation — Telethon Patterns
+
+Repeatable patterns for Telegram mass-messaging, chat management, session repair, and flood-resilient cron loops.
+
+## Telethon Session Repair (SQLite Schema)
+
+Telethon sessions are SQLite databases. Version mismatches between Telethon and session files cause schema errors:
+
+### Symptom: `ValueError: too many values to unpack (expected 6)`
+
+Session has 7 columns but current Telethon expects 6. **Check actual columns first** — the 7-column schema varies:
+
+**Variant A: `number` column (Telethon v2, 2026+)**
+Columns: `dc_id, server_address, port, auth_key, takeout_id, tmp_auth_key, number`
+
+**Fix — drop `number` column:**
+
+```python
+import sqlite3, shutil
+fname = 'sessions/account.session'
+shutil.copy(fname, fname + '.bak7cols')
+db = sqlite3.connect(fname)
+db.execute('''
+    CREATE TABLE sessions_new (
+        dc_id INT PRIMARY KEY, server_address TEXT, port INT,
+        auth_key BLOB, takeout_id INTEGER, tmp_auth_key BLOB
+    )
+''')
+db.execute('INSERT INTO sessions_new SELECT dc_id, server_address, port, auth_key, takeout_id, tmp_auth_key FROM sessions')
+db.execute('DROP TABLE sessions')
+db.execute('ALTER TABLE sessions_new RENAME TO sessions')
+db.commit()
+db.close()
+```
+
+**Variant B: `auth_key_id` column (older)**
+Columns: `dc_id, server_address, port, auth_key, auth_key_id, takeout_id, tmp_auth_key`
+
+**Fix — drop `auth_key_id` column:**
+
+```python
+import sqlite3, shutil
+fname = 'sessions/account.session'
+shutil.copy(fname, fname + '.bak7cols')
+db = sqlite3.connect(fname)
+db.execute('''
+    CREATE TABLE sessions_new (
+        dc_id INT, server_address TEXT, port INT,
+        auth_key BLOB, takeout_id INTEGER, tmp_auth_key BLOB
+    )
+''')
+db.execute('INSERT INTO sessions_new SELECT dc_id, server_address, port, auth_key, takeout_id, tmp_auth_key FROM sessions')
+db.execute('DROP TABLE sessions')
+db.execute('ALTER TABLE sessions_new RENAME TO sessions')
+db.commit()
+db.close()
+```
+
+### Symptom: `ValueError: not enough values to unpack (expected 6, got 5)`
+
+Session has 5 columns (old schema, missing `auth_key_id` and `takeout_id`). Fix by recreating with correct 6-column schema.
+
+### Symptom: `TypeError: Strings must be encoded before hashing`
+
+Corrupted `auth_key` — session is dead. Mark as `bad_session` and skip.
+
+### Verification
+
+```python
+import sqlite3
+db = sqlite3.connect('session_file.session')
+cur = db.execute('PRAGMA table_info(sessions)')
+cols = [r[1] for r in cur.fetchall()]
+assert len(cols) == 6, f"Expected 6 cols, got {len(cols)}: {cols}"
+assert cols == ['dc_id', 'server_address', 'port', 'auth_key', 'auth_key_id', 'takeout_id']
+```
+
+## Session File Discovery & Priority
+
+When multiple session directories exist, prioritize by freshness:
+
+```python
+def find_sessions():
+    sessions = {}
+    # Priority: sessions5 > sessions_clean (first scanned wins)
+    for folder in ["sessions5", "sessions_clean"]:
+        for f in Path(folder).glob("*.session"):
+            if f.stem not in sessions:
+                sessions[f.stem] = f
+    return sessions
+```
+
+### Identifying unique accounts via auth key hash
+
+Different sessions may be the same account. Use auth key MD5 to deduplicate:
+
+```python
+import sqlite3, hashlib, os
+
+def get_key_hash(session_path):
+    db = sqlite3.connect(session_path)
+    row = db.execute('SELECT auth_key FROM sessions').fetchone()
+    db.close()
+    if row and row[0]:
+        return hashlib.md5(row[0]).hexdigest()[:12]
+    return None
+
+# Group sessions by account
+accounts = {}
+for f in Path("sessions5").glob("*.session"):
+    h = get_key_hash(str(f))
+    if h:
+        accounts.setdefault(h, []).append(f.name)
+
+for h, files in accounts.items():
+    print(f"Account {h}: {len(files)} session(s) — {', '.join(files)}")
+```
+
+### Quick authorization check
+
+28KB sessions are often deauthorized (session file exists but auth expired). 400KB+ sessions are typically active:
+
+```python
+async def is_authorized(session_path):
+    try:
+        c = TelegramClient(session_path, API_ID, API_HASH)
+        await asyncio.wait_for(c.connect(), timeout=5)
+        auth = await c.is_user_authorized()
+        await c.disconnect()
+        return auth
+    except:
+        return False
+```
+
+Rules:
+- `sessions5/` — primary, most recent
+- `sessions_clean/` — fallback, may have repaired sessions
+- `sessions_archive/`, `sessions_banned/`, `sessions_dead/` — do not use for active work
+- Always check session validity before connecting (`try/except` around `TelegramClient` init)
+
+## Bot Interaction — Inline Keyboard Navigation
+
+MCP tools (`maintg`, `[REDACTED-NAME]`) strip inline keyboard buttons from bot messages — they return empty `text` for bot replies with inline keyboards. **Always use Telethon directly** for bot interaction, never browser/playwright.
+
+### Reading bot menus
+
+```python
+from telethon import TelegramClient
+
+client = TelegramClient(session_path, API_ID, API_HASH)
+await client.connect()
+bot = await client.get_input_entity("BotUsername")
+
+msgs = await client.get_messages(bot, limit=1)
+msg = msgs[0]
+
+print(f"TEXT: {msg.text}")
+if msg.buttons:
+    for i, row in enumerate(msg.buttons):
+        for j, btn in enumerate(row):
+            url = getattr(btn, 'url', None)
+            print(f"  BTN[{i}][{j}]: '{btn.text}' data={btn.data} url={url}")
+```
+
+### Clicking inline buttons
+
+```python
+# Click button at row X, col Y
+await msg.click(row, col)
+
+# Wait for bot response
+await asyncio.sleep(1)
+response = await client.get_messages(bot, limit=1)
+```
+
+### Common pitfalls
+
+- **Button indices shift after navigation** — re-fetch the message and re-read buttons before each click
+- **URL buttons** have `data=None` and `url=https://...` — detect with `getattr(btn, 'url', None)`
+- **Callback buttons** have `data=b'...'` — use the data string for programmatic clicking
+- **Empty text + inline keyboard** = MCP tools will show nothing. Use Telethon.
+
+Core pattern for mass messaging with flood resilience:
+
+```python
+PROGRESS = Path("spam_progress.json")
+p = {"sent": {}, "failed": {}, "flood_until": {}, "stats": {"total_sent": 0, "total_failed": 0}}
+
+async def spam(account_id, chats, session_path):
+    done = set(p["sent"].get(account_id, []) + p["failed"].get(account_id, []))
+    remaining = [c for c in chats if c["username"] not in done]
+    if not remaining:
+        return
+
+    # Skip flooded accounts
+    if p["flood_until"].get(account_id, 0) > time.time():
+        return
+
+    client = None
+    try:
+        client = TelegramClient(str(session_path), API_ID, API_HASH)
+        await client.connect()
+    except Exception as e:
+        log(f"BAD SESSION {account_id}: {e}")
+        p["flood_until"][account_id] = int(time.time()) + 3600
+        save()
+        return
+
+    msg = random.choice(MESSAGES)
+    for c in remaining:
+        try:
+            await client.send_message(f"@{c['username']}", msg)
+            p["sent"].setdefault(account_id, []).append(c["username"])
+            p["stats"]["total_sent"] += 1
+            save()
+            await asyncio.sleep(random.uniform(4, 10))
+        except FloodWaitError as e:
+            p["flood_until"][account_id] = int(time.time()) + e.seconds
+            save()
+            break  # Stop this account, cron will retry later
+        except Exception as e:
+            p["failed"].setdefault(account_id, []).append(c["username"])
+            save()
+
+    await client.disconnect()
+```
+
+Key design decisions:
+- **Never `await asyncio.sleep(flood_seconds)`** — timeouts can be 20+ hours. Save `flood_until` and move on.
+- **Save progress every message** — crash-safe, resume on restart.
+- **Cron retry every 2 hours** — picks up accounts after flood clears.
+- **Random delays 4-10s between messages** — stay under rate limits.
+- **One message per account per run** — use the same message for all chats on one account (less detectable).
+
+## Exit/Chat Leave Loop
+
+Same pattern, adapted for leaving chats:
+
+```python
+async def leave_chats(account_id, chat_list, session_path):
+    undone = [c for c in chat_list if c not in PROGRESS["done"].get(account_id, [])]
+    if not undone:
+        return
+
+    if p["flood_until"].get(account_id, 0) > time.time():
+        return
+
+    client = await connect_safe(session_path)
+    if not client:
+        return
+
+    for chat_id in undone:
+        try:
+            await client.delete_dialog(chat_id)
+            p["done"].setdefault(account_id, []).append(chat_id)
+            save()
+            await asyncio.sleep(random.uniform(2, 6))
+        except FloodWaitError as e:
+            p["flood_until"][account_id] = int(time.time()) + e.seconds
+            save()
+            break
+```
+
+## Cron Wrapper Pattern (Lock File)
+
+From `eni-orchestrator-suite` — use for all `no_agent` cron jobs:
+
+```bash
+#!/usr/bin/env bash
+set -u
+cd /path/to/project || exit 1
+LOCK="script.lock"
+LOG="script_cron.log"
+
+if [ -f "$LOCK" ]; then
+  pid=$(cat "$LOCK" 2>/dev/null || true)
+  if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+    exit 0
+  fi
+fi
+echo $$ > "$LOCK"
+trap 'rm -f "$LOCK"' EXIT
+
+echo "===== $(date) tick =====" >> "$LOG"
+python -u script.py >> "$LOG" 2>&1
+```
+
+Cron registration:
+```
+cronjob(action='create', name='job-name', schedule='every 2h',
+         script='name.sh', no_agent=true, deliver='origin')
+```
+
+## Windows Telethon Invocation (Hermes Venv Contamination)
+
+Hermes venv injects its own Telethon into `sys.path`. System Python 3.14+ breaks Telethon SQLite sessions. Always use:
+
+```bash
+PYTHONPATH="" /c/Users/User/AppData/Local/Programs/Python/Python311/python.exe -c "..."
+```
+
+Rules:
+- **PYTHONPATH=""** mandatory — otherwise venv's Telethon contaminates sys.path
+- **Python 3.11** (not 3.14) — 3.14 breaks SQLite session handling in Telethon
+- **Session path as raw string** — `r'C:\Users\User\.orca\sessions\[REDACTED-NAME]'` (backslashes, not forward slashes)
+- **API_ID=23926822, API_HASH=[REDACTED-KEY]** — [REDACTED-NAME] session
+- **AlStack channel ID: -1004420835850** — use `parse_mode='html'`, `link_preview=False`
+- **MessageTooLongError** — TG limit 4096 chars. Split into parts with (1/3) markers.
+
+## Pitfalls
+
+- ❌ **PYTHONPATH contamination** — Hermes venv injects its own Telethon. Always `PYTHONPATH=""` when running Telethon scripts.
+- ❌ **Python 3.14 breaks Telethon** — `sqlite3.OperationalError: unable to open database file`. Use Python 3.11.
+- ❌ **MCP tools strip inline keyboards** — `maintg` and `[REDACTED-NAME]` return empty text for bot messages with inline keyboards. Use Telethon directly for any bot interaction.
+- ❌ **Don't use browser/playwright for Telegram** — Telethon is faster, more reliable, and doesn't need browser auth. The user expects Telethon, not browser tools.
+- ❌ **Don't wait for FloodWait** — save `flood_until` and let cron retry. Waiting blocks the whole run.
+- ❌ **Don't use `session/` directory for active work** — it may contain stale/banned sessions. Use `sessions5/` or `sessions_clean/`.
+- ❌ **Don't crash on bad sessions** — `try/except` around `TelegramClient` init, mark as flooded for 1h, continue to next account.
+- ❌ **Don't spam without progress tracking** — if the script crashes, you lose all state. Save after every message.
+- ❌ **Don't use the same message for all accounts** — rotate 5+ variants. One account = one message variant per run.
+- ❌ **Don't run spam without a cron fallback** — if all accounts are flooded, cron retries automatically. Manual runs require manual retries.
+- ❌ **Don't use `spam_progress.json` and `spam_live_progress.json` interchangeably** — they track different account sets. Keep separate progress files for separate scripts.
+
+## Verification
+
+```bash
+# Check session health
+python -c "
+import sqlite3
+from pathlib import Path
+for f in Path('sessions5').glob('*.session'):
+    db = sqlite3.connect(str(f))
+    cols = [r[1] for r in db.execute('PRAGMA table_info(sessions)')]
+    ok = 'OK' if len(cols) == 6 else f'BAD({len(cols)})'
+    print(f'{f.stem}: {ok}')
+"
+
+# Check flood status
+python -c "
+import json, time
+p = json.load(open('spam_progress.json'))
+now = time.time()
+flooded = sum(1 for v in p.get('flood_until', {}).values() if v > now)
+print(f'Flooded: {flooded}, Ready: {len(p[\"sent\"]) - flooded}')
+"
+```
+
+## References
+
+- `references/session-repair-recipes.md` — copy-paste scripts for fixing Telethon sessions (7→6 cols, 5→6 cols, bulk health check, corrupted auth_key detection)
+- `references/mcp-fallback-direct-telethon.md` — bypass `[REDACTED-NAME]` MCP when Telethon is down by connecting directly to the same SQLite session file. Includes the AI intel classification regex patterns, dedup via state file, and full cron job adaptation flow.
+
+## Templates
+
+- `templates/spam_live_template.py` — canonical flood-resilient spam script. Copy to project, fill in API_ID/API_HASH/MESSAGES/BASE path, run.
--- a/skills/telegram-automation/references/lead-funnel-echogate.md
+++ b/skills/telegram-automation/references/lead-funnel-echogate.md
@@ -0,0 +1,110 @@
+# AI Lead Funnel — Echogate LLM + Telethon
+
+Full runnable pattern for Telegram accounts that auto-respond to DMs using LLM.
+
+## When to use
+
+- User wants a Telegram account to auto-respond to incoming messages
+- Redirect leads to a target contact (@lordrax, etc.)
+- Need a human-like operator that filters and redirects
+
+## Key design decisions
+
+1. **Stage-gated dialog, not free-form LLM** — LLM is too eager to share contact immediately or too chatty. Use 3 hardcoded stages with separate system prompts.
+2. **Processing lock per user** — `asyncio.Event` or `set()` to prevent parallel handler invocations.
+3. **Typing indicator before every message** — `SetTypingRequest(SendMessageTypingAction())` + `asyncio.sleep(3-10s)`.
+4. **State persistence** — JSON file with `stage`, `history`, `done` per user. Survives restarts.
+
+## LLM config
+
+```python
+from openai import AsyncOpenAI
+
+llm = AsyncOpenAI(
+    base_url="https://api.echogate.one/v1",
+    api_key="[REDACTED]",
+    timeout=60,
+)
+
+# gpt-5.5: ~3s response — fast enough for real-time
+# deepseek-v4-pro: ~21s — too slow, breaks the illusion
+```
+
+## Stage prompts
+
+```python
+STAGE_PROMPTS = {
+    0: """Ты — оператор. Строгий, деловой, немногословный.
+Это ПЕРВОЕ сообщение в диалоге. Ответь коротко (1 предложение).
+Поприветствуй и спроси что интересует / по какому вопросу.
+НЕ давай контакты. НЕ упоминай @target. НЕ давай ссылки.
+НЕ используй эмодзи. Стиль: спокойный, уверенный, без лишней вежливости.""",
+
+    1: """Ты — оператор. Строгий, деловой.
+Это ВТОРОЕ сообщение. Ответь на вопрос пользователя коротко (1-2 предложения).
+Упомяни что детали, цены и наличие — у партнёра @target.
+НЕ давай прямую ссылку пока. НЕ используй эмодзи.
+Стиль: уверенный, деловой. Не извиняйся, не будь подобострастным.""",
+
+    2: """Ты — оператор. Строгий, деловой.
+Это ТРЕТЬЕ (финальное) сообщение. Дай прямую ссылку.
+Скажи обратиться туда, это всё. Закругляйся.
+1 предложение. НЕ продолжай диалог. НЕ используй эмодзи.""",
+}
+```
+
+## Processing lock pattern
+
+```python
+processing = set()  # Track user_ids currently being processed
+
+@client.on(events.NewMessage(incoming=True))
+async def handler(event):
+    uk = str(event.sender_id)
+
+    if uk in processing:
+        log(f"Already processing {uk}, skip")
+        return
+
+    processing.add(uk)
+    try:
+        # ... generate and send reply ...
+    finally:
+        processing.discard(uk)
+```
+
+## Race condition: why it happens
+
+When two messages arrive within 2 seconds (e.g. user sends empty message then "привет"), the Telethon event handler fires twice in parallel. Both invocations see the same state (stage=0, our_count=0), both generate Stage 0 replies, and both send simultaneously. Result: two greeting messages back-to-back, no dialog.
+
+The processing lock prevents this — the second invocation sees `uk in processing` and skips.
+
+## Fallback messages
+
+Always have hardcoded fallbacks per stage in case LLM times out:
+
+```python
+FALLBACKS = {
+    0: "Добрый. По какому вопросу?",
+    1: "По наличию и ценам — обратись к @target",
+    2: "Напиши @target: https://t.me/target",
+}
+```
+
+## Full runnable script
+
+See `C:\Users\User\Desktop\_PROJECTS\рассылка\lead_funnel.py` for the production version with:
+- echogate.one LLM integration
+- 3-stage dialog with processing lock
+- Typing indicator + random delays
+- JSON state persistence
+- @Tomitotototo → @lordrax funnel
+
+## Pitfalls learned 2026-08-11
+
+1. **JSON account metadata is stale**: `sessions/*.json` files say `status: "Active"`, `spamblock: "none"` but 90%+ of accounts are actually RESTRICTED/BANNED. Always verify by connecting and sending a test message to "me".
+2. **SpamBot "RESTRICTED" ≠ can't DM**: Account may be RESTRICTED for groups but perfectly fine for private messages. The real test is `client.send_message("me", "test")`.
+3. **Free-form LLM fails**: Without stage-gating, LLM either shares contact immediately (no dialog) or never shares it (endless chat). Hardcode stages.
+4. **No processing lock = duplicate messages**: Parallel handler invocations on rapid-fire messages produce duplicate greetings.
+5. **deepseek-v4-pro is 21s**: Too slow for real-time. gpt-5.5 is 3s. Pick fast models.
+6. **No skip phrases in lead funnel**: Respond to EVERYTHING — "ку", "привет", empty messages. No intent detection needed.
--- a/skills/telegram-automation/references/mcp-fallback-direct-telethon.md
+++ b/skills/telegram-automation/references/mcp-fallback-direct-telethon.md
@@ -0,0 +1,143 @@
+# MCP Fallback: Direct Telethon When `[REDACTED-NAME]` MCP Is Down
+
+## Problem
+
+The `[REDACTED-NAME]` MCP returns:
+```
+ERROR: Telethon not available or client not connected
+```
+
+This happens when the Telethon client the MCP server wraps isn't authenticated or the MCP process itself is down. All MCP tools (`reform_messages`, `reform_dialogs`, `reform_me`, `reform_resolve`, `reform_search`) fail with the same error.
+
+## Direct Telethon Bypass
+
+The MCP server wraps a local SQLite session file. You can bypass the MCP entirely by connecting directly with the same session:
+
+```python
+from telethon import TelegramClient
+from telethon.sessions import SQLiteSession
+
+SESSION_PATH = r"C:\Users\User\Desktop\_PROJECTS\tg_content_agent\MAINTG1_fixed.session"
+API_ID = 2040
+API_HASH = "[REDACTED-KEY]"
+
+async def main():
+    client = TelegramClient(SQLiteSession(SESSION_PATH), API_ID, API_HASH)
+    try:
+        await asyncio.wait_for(client.start(), timeout=30)
+        me = await client.get_me()
+        print(f"Connected: @{me.username} (id={me.id})")
+        
+        # Get dialogs (same as reform_dialogs)
+        dialogs = await client.get_dialogs(limit=50)
+        
+        # Get messages from a chat (same as reform_messages)
+        msgs = await client.get_messages(chat_id, limit=30)
+        
+        # Resolve username (same as reform_resolve)
+        entity = await client.get_entity(username)
+        
+    except asyncio.TimeoutError:
+        print("ERROR: Connection timed out — session may be expired")
+    finally:
+        await client.disconnect()
+```
+
+## Session Details
+
+- **Session file**: `MAINTG1_fixed.session` (~630 KB, active)
+- **Account**: @[REDACTED-NAME] (id=[REDACTED-TGID])
+- **API credentials**: id=2040, hash `[REDACTED-KEY]`
+- **Auth flow**: Session is pre-authenticated — no phone/OTP needed
+
+## Pitfalls
+
+- **Session can expire** — if `client.start()` times out (30s+), the auth keys may be stale. Requires re-authentication via phone code.
+- **Write_file restrictions** — `skill_manage(write_file)` can write reference/template/script files into existing skills without file-system permission issues. Use this instead of `write_file` for session-sensitive scripts.
+- **No MCP tools available** — direct Telethon doesn't provide the convenience wrappers (`reform_search`, etc.). You have to implement search manually via `client.get_messages()` iteration.
+- **Timeouts** — `TelegramClient.start()` with a large session file can take 10-20s. Set `asyncio.wait_for(client.start(), timeout=30)`.
+- **Race with MCP** — if both direct client and MCP connect simultaneously with the same session file, one will get `Database is locked`. Don't overlap.
+
+## Typical Cron Job Adaptation
+
+When the cron job's MCP dependency is down, the full flow is:
+
+1. **Detect** — call MCP tool, catch error
+2. **Fall back** — connect via direct `TelegramClient(SQLiteSession(...))`
+3. **Scan** — iterate dialogs, get messages per chat
+4. **Classify** — regex-based AI intel categorization (see below)
+5. **Dedup** — hash message text, compare with state file
+6. **Report** — format digest, deliver via cron output contract
+
+## AI Intel Classification Pattern
+
+For parsing Telegram messages for AI intelligence:
+
+```python
+import re
+from collections import defaultdict
+
+CATEGORIES = {
+    "api_keys": r"sk-[a-zA-Z0-9]{20,}|Bearer\s+[a-zA-Z0-9_\-\.]{30,}|api.?key[:\s][a-zA-Z0-9]{16,}",
+    "jailbreak": r"jailbreak|bypass|prompt inj|uncensored|g0dm0d3|refusal",
+    "ai_abuse": r"free api|free key|0元|unlimited|turbo charge",
+    "ai_news": r"gpt-?5|claude|opus|sonnet|deepseek|grok|qwen|gemini|release|launch|new model",
+    "traffic": r"traffic|seo|seeding|guerrilla|growth hack|virality",
+    "funnels": r"funnel|lead gen|conversion|cpa|cpl|autofunnel|landing",
+    "code_tips": r"claude code|codex|opencode|cursor|mcp|agent skill|workflow|template",
+}
+
+def classify(text: str) -> dict:
+    """Score message text against all AI intel categories."""
+    scores = defaultdict(float)
+    textl = text.lower()
+    for cat, pattern in CATEGORIES.items():
+        matches = re.findall(pattern, textl, re.IGNORECASE)
+        if matches:
+            scores[cat] += len(matches) * 2
+    
+    # Semantic boosters for weak signals
+    if any(k in textl for k in ["api key", "token", "secret", "sk-", "bearer"]):
+        scores["api_keys"] += 5
+    if any(k in textl for k in ["claude code", "codex", "cursor", "opencode", "mcp server"]):
+        scores["code_tips"] += 3
+    if any(k in textl for k in ["free", "trial", "credit", "generat"]):
+        scores["ai_abuse"] += 2
+    if any(k in textl for k in ["release", "announce", "new model", "just launched"]):
+        scores["ai_news"] += 2
+    
+    return dict(scores)
+```
+
+## Dedup via State File
+
+```python
+import json
+
+STATE_PATH = "~/tg_intel_state.json"
+
+def load_state() -> dict:
+    try:
+        with open(STATE_PATH) as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {"last_scan": None, "seen_hashes": []}
+
+def hash_msg(text: str) -> str:
+    return str(hash(text.strip()[:200]))
+
+def update_state(state: dict, new_items: list) -> dict:
+    seen = set(state.get("seen_hashes", []))
+    for item in new_items:
+        if item["hash"] not in seen:
+            seen.add(item["hash"])
+    state["seen_hashes"] = list(seen)[-5000:]  # keep last 5000
+    state["last_scan"] = datetime.now(timezone.utc).isoformat() + "Z"
+    return state
+```
+
+## References
+
+- `telegram-account-management` — for session audit and health patterns
+- `cron-job-execution-discipline` — for cron job execution contracts and formatting
+- `telegram-automation` — parent skill with Telethon repair patterns
--- a/skills/telegram-automation/references/session-repair-recipes.md
+++ b/skills/telegram-automation/references/session-repair-recipes.md
@@ -0,0 +1,191 @@
+# Telethon Session Repair — Full Recipes
+
+Real repair scripts used in production. Copy-paste and run.
+
+## Fix 7-column → 6-column (drop `number`)
+
+Two 7-column variants exist. ALWAYS check actual column names first.
+
+### Variant A: `number` column (Telethon v2, 2026+)
+Columns: `dc_id, server_address, port, auth_key, takeout_id, tmp_auth_key, number`
+
+Drop the extra `number` column:
+
+```python
+import sqlite3, shutil
+from pathlib import Path
+
+SESSION_DIR = Path("sessions_clean")
+
+for f in SESSION_DIR.glob("*.session"):
+    db = sqlite3.connect(str(f))
+    cur = db.execute("PRAGMA table_info(sessions)")
+    cols = [r[1] for r in cur.fetchall()]
+    db.close()
+
+    if len(cols) == 7 and "number" in cols:
+        shutil.copy(str(f), str(f) + ".bak7cols")
+        db = sqlite3.connect(str(f))
+        db.execute("""
+            CREATE TABLE sessions_new (
+                dc_id INT PRIMARY KEY, server_address TEXT, port INT,
+                auth_key BLOB, takeout_id INTEGER, tmp_auth_key BLOB
+            )
+        """)
+        db.execute("INSERT INTO sessions_new SELECT dc_id, server_address, port, auth_key, takeout_id, tmp_auth_key FROM sessions")
+        db.execute("DROP TABLE sessions")
+        db.execute("ALTER TABLE sessions_new RENAME TO sessions")
+        db.commit()
+        db.close()
+        print(f"Fixed: {f.name}")
+```
+
+### Variant B: `auth_key_id` column (older)
+Columns: `dc_id, server_address, port, auth_key, auth_key_id, takeout_id, tmp_auth_key`
+
+Drop the extra `auth_key_id` column:
+
+```python
+import sqlite3, shutil
+from pathlib import Path
+
+for f in Path("sessions_clean").glob("*.session"):
+    db = sqlite3.connect(str(f))
+    cur = db.execute("PRAGMA table_info(sessions)")
+    cols = [r[1] for r in cur.fetchall()]
+    db.close()
+
+    if len(cols) == 7 and "auth_key_id" in cols:
+        shutil.copy(str(f), str(f) + ".bak7cols")
+        db = sqlite3.connect(str(f))
+        db.execute("""
+            CREATE TABLE sessions_new (
+                dc_id INT, server_address TEXT, port INT,
+                auth_key BLOB, takeout_id INTEGER, tmp_auth_key BLOB
+            )
+        """)
+        db.execute("INSERT INTO sessions_new SELECT dc_id, server_address, port, auth_key, takeout_id, tmp_auth_key FROM sessions")
+        db.execute("DROP TABLE sessions")
+        db.execute("ALTER TABLE sessions_new RENAME TO sessions")
+        db.commit()
+        db.close()
+        print(f"Fixed: {f.name}")
+```
+
+## Fix 5-column → 6-column
+
+Two 5-column variants exist. ALWAYS check the actual column names before repairing.
+
+### Variant A: missing `takeout_id` (cols: `dc_id, server_address, port, auth_key, auth_key_id`)
+
+Older Telethon v7 sessions. Add `takeout_id` as NULL.
+
+```python
+import sqlite3, shutil
+from pathlib import Path
+
+for f in Path("sessions_clean").glob("*.session"):
+    db = sqlite3.connect(str(f))
+    cur = db.execute("PRAGMA table_info(sessions)")
+    cols = [r[1] for r in cur.fetchall()]
+    db.close()
+
+    if len(cols) == 5 and "auth_key_id" in cols:
+        shutil.copy(str(f), str(f) + ".bak5cols")
+        db = sqlite3.connect(str(f))
+        db.execute("""
+            CREATE TABLE sessions_new (
+                dc_id INT, server_address TEXT, port INT,
+                auth_key BLOB, auth_key_id BLOB, takeout_id INTEGER
+            )
+        """)
+        db.execute("INSERT INTO sessions_new SELECT dc_id, server_address, port, auth_key, auth_key_id, NULL FROM sessions")
+        db.execute("DROP TABLE sessions")
+        db.execute("ALTER TABLE sessions_new RENAME TO sessions")
+        db.commit()
+        db.close()
+        print(f"Fixed: {f.name}")
+```
+
+### Variant B: missing `auth_key_id` (cols: `dc_id, server_address, port, auth_key, takeout_id`)
+
+Encountered on MAINTG1.session (2026-07-28). This schema has `takeout_id` but no `auth_key_id`. Add `auth_key_id` as NULL.
+
+```python
+# PROVEN on MAINTG1.session (C:\Users\User\Desktop\_PROJECTS\tg_content_agent\)
+import sqlite3, shutil
+
+f = "MAINTG1.session"
+db = sqlite3.connect(f)
+cols = [r[1] for r in db.execute("PRAGMA table_info(sessions)")]
+print(f"Cols: {cols}")
+# Expected: ['dc_id', 'server_address', 'port', 'auth_key', 'takeout_id']
+
+if len(cols) == 5 and "takeout_id" in cols and "auth_key_id" not in cols:
+    shutil.copy(f, f + ".bak5cols_v2")
+    db.execute("""
+        CREATE TABLE sessions_new (
+            dc_id INT, server_address TEXT, port INT,
+            auth_key BLOB, auth_key_id BLOB, takeout_id INTEGER
+        )
+    """)
+    db.execute("INSERT INTO sessions_new SELECT dc_id, server_address, port, auth_key, NULL, takeout_id FROM sessions")
+    db.execute("DROP TABLE sessions")
+    db.execute("ALTER TABLE sessions_new RENAME TO sessions")
+    db.commit()
+    # Verify
+    new_cols = [r[1] for r in db.execute("PRAGMA table_info(sessions)")]
+    row = db.execute("SELECT * FROM sessions").fetchone()
+    assert len(new_cols) == 6, f"Expected 6 cols, got {len(new_cols)}"
+    print(f"Fixed: {new_cols}, auth_key_len={len(row[3]) if row[3] else 0}")
+db.close()
+```
+
+## Bulk session health check
+
+```python
+import sqlite3
+from pathlib import Path
+
+for d in ["sessions5", "sessions_clean", "session", "sessions_archive"]:
+    sd = Path(d)
+    if not sd.exists():
+        continue
+    for f in sorted(sd.glob("*.session")):
+        try:
+            db = sqlite3.connect(str(f))
+            cur = db.execute("PRAGMA table_info(sessions)")
+            cols = [r[1] for r in cur.fetchall()]
+            cur = db.execute("SELECT * FROM sessions")
+            row = cur.fetchone()
+            db.close()
+            status = "OK" if len(cols) == 6 and row and len(row) == 6 else f"BAD cols={len(cols)} row={len(row) if row else 0}"
+            print(f"{d}/{f.stem}: {status}")
+        except Exception as e:
+            print(f"{d}/{f.stem}: ERROR {e}")
+```
+
+## Check for corrupted auth_key (causes `TypeError: Strings must be encoded before hashing`)
+
+```python
+import sqlite3
+from pathlib import Path
+
+for d in ["sessions5", "sessions_clean"]:
+    for f in Path(d).glob("*.session"):
+        db = sqlite3.connect(str(f))
+        cur = db.execute("SELECT auth_key FROM sessions")
+        row = cur.fetchone()
+        db.close()
+        if row and row[0] is not None:
+            ak = row[0]
+            if isinstance(ak, str):
+                print(f"BAD (string auth_key): {f}")
+            elif isinstance(ak, bytes):
+                if len(ak) < 100:
+                    print(f"SUSPECT (short auth_key {len(ak)}b): {f}")
+            else:
+                print(f"BAD (type {type(ak).__name__}): {f}")
+        else:
+            print(f"NULL auth_key: {f}")
+```
--- a/skills/telegram-automation/templates/lead_funnel_template.py
+++ b/skills/telegram-automation/templates/lead_funnel_template.py
@@ -0,0 +1,147 @@
+"""
+Lead funnel auto-reply bot — human-like DM responder.
+Shows typing indicator, realistic delays, 3-4 messages → redirect to target.
+
+Copy to project, fill in SESSION_PATH, MY_USERNAME, TARGET_LINK, run.
+"""
+
+import asyncio, json, random, time
+from datetime import datetime
+from pathlib import Path
+from telethon import TelegramClient, events
+from telethon.tl.functions.messages import SetTypingRequest
+from telethon.tl.types import SendMessageTypingAction
+from telethon.errors import FloodWaitError
+
+# ── Config ──────────────────────────────────────────────
+API_ID = 2040
+API_HASH = "[REDACTED-KEY]"
+SESSION_PATH = "session_file.session"
+MY_USERNAME = "my_username"
+TARGET_LINK = "https://t.me/target"
+
+STATE_FILE = Path("lead_funnel_state.json")
+LOG_FILE = Path("lead_funnel_log.txt")
+
+FUNNEL = [
+    ("Привет! Да, всё актуально. Что именно интересует?", (3, 7)),
+    ("Понял, есть в наличии. Цены адекватные. Что планируешь брать?", (5, 10)),
+    ("Я сейчас редко тут сижу. Напиши партнёру — он всегда в сети: {target}", (4, 8)),
+    ("Скажи что от @{me}, он подберёт под бюджет. Давай 🤝", (3, 6)),
+]
+
+REPLY_DELAY_MIN = 15
+REPLY_DELAY_MAX = 60
+
+BUY_KEYWORDS = [
+    "купить", "продаёшь", "цена", "сколько", "стоит", "прайс",
+    "хочу", "интересует", "нужен", "заказ", "готов", "возьму",
+    "беру", "покупаю", "приобрести", "каталог", "в наличии",
+    "есть", "почём", "расценки", "отзывы", "тема", "подробнее",
+]
+
+def load_state():
+    if STATE_FILE.exists():
+        return json.loads(STATE_FILE.read_text(encoding="utf-8"))
+    return {}
+
+def save_state(state):
+    STATE_FILE.write_text(json.dumps(state, indent=2, ensure_ascii=False), encoding="utf-8")
+
+def log(msg):
+    line = f"[{datetime.now().strftime('%H:%M:%S')}] {msg}"
+    print(line)
+    with open(LOG_FILE, "a", encoding="utf-8") as f:
+        f.write(line + "\n")
+
+def is_buy_intent(text):
+    if not text:
+        return False
+    t = text.lower().strip()
+    skip = ["привет", "здравствуй", "хай", "hello", "hi", "как дела", "салам", "ку", "здарова"]
+    if t in skip:
+        return False
+    return any(kw in t for kw in BUY_KEYWORDS)
+
+async def type_and_send(client, user_id, message, typing_range):
+    secs = random.uniform(*typing_range)
+    try:
+        await client(SetTypingRequest(peer=user_id, action=SendMessageTypingAction()))
+    except Exception:
+        pass
+    await asyncio.sleep(secs)
+    await client.send_message(user_id, message)
+    log(f"SENT: {message[:60]}...")
+
+async def process_user(client, user_id, state):
+    user_key = str(user_id)
+    ud = state.get(user_key, {})
+    step = ud.get("step", 0)
+    if ud.get("done") or step >= len(FUNNEL):
+        state[user_key]["done"] = True
+        save_state(state)
+        return
+
+    if step == 0:
+        await asyncio.sleep(random.uniform(REPLY_DELAY_MIN, REPLY_DELAY_MAX))
+
+    msg, trange = FUNNEL[step]
+    msg = msg.format(target=TARGET_LINK, me=MY_USERNAME)
+    await type_and_send(client, user_id, msg, trange)
+
+    state[user_key]["step"] = step + 1
+    state[user_key]["last_msg_time"] = time.time()
+    save_state(state)
+
+async def funnel_timer(client):
+    while True:
+        await asyncio.sleep(30)
+        state = load_state()
+        for user_key, ud in list(state.items()):
+            if ud.get("done") or ud.get("step", 0) == 0:
+                continue
+            if ud.get("step", 0) >= len(FUNNEL):
+                state[user_key]["done"] = True
+                save_state(state)
+                continue
+            if time.time() - ud.get("last_msg_time", 0) < random.uniform(120, 240):
+                continue
+            try:
+                await process_user(client, int(user_key), state)
+            except FloodWaitError:
+                pass
+            except Exception as e:
+                log(f"Timer error: {e}")
+
+async def main():
+    client = TelegramClient(SESSION_PATH, API_ID, API_HASH)
+    await client.start()
+    me = await client.get_me()
+    log(f"STARTED: @{me.username} ({me.first_name})")
+
+    state = load_state()
+
+    @client.on(events.NewMessage(incoming=True))
+    async def handler(event):
+        if not event.is_private or event.out:
+            return
+        sender = await event.get_sender()
+        uid, text = event.sender_id, event.raw_text or ""
+        uk = str(uid)
+        ud = state.get(uk, {})
+
+        if is_buy_intent(text) or ud.get("step", 0) > 0:
+            if uk not in state:
+                state[uk] = {"step": 0, "last_msg_time": 0, "first_seen": time.time()}
+                save_state(state)
+            try:
+                await process_user(client, uid, state)
+            except FloodWaitError:
+                pass
+
+    asyncio.create_task(funnel_timer(client))
+    log("Listening...")
+    await client.run_until_disconnected()
+
+if __name__ == "__main__":
+    asyncio.run(main())
--- a/skills/telegram-automation/templates/spam_live_template.py
+++ b/skills/telegram-automation/templates/spam_live_template.py
@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""SPAM LIVE — все аккаунты с live-чатами, авто-пропуск флуда.
+TEMPLATE: copy to project, fill in API_ID, API_HASH, MESSAGES, BASE path."""
+import asyncio, json, random, time
+from pathlib import Path
+from datetime import datetime
+from telethon import TelegramClient
+from telethon.errors import FloodWaitError
+
+BASE = Path(r"C:\Users\User\Desktop\_PROJECTS\рассылка")
+API_ID = 2040
+API_HASH = "[REDACTED-KEY]"
+
+MESSAGES = [
+    "🚀 Заработок на трафике — без вложений!\n\nИщу партнёров...",
+    # Add 4-5 variants
+]
+
+PROGRESS = BASE / "spam_live_progress.json"
+if PROGRESS.exists():
+    p = json.loads(PROGRESS.read_text())
+else:
+    p = {"sent": {}, "failed": {}, "flood_until": {}, "stats": {"total_sent": 0, "total_failed": 0}}
+
+def save():
+    PROGRESS.write_text(json.dumps(p, indent=2))
+
+def log(msg):
+    ts = datetime.now().strftime("%H:%M:%S")
+    print(f"[{ts}] {msg}")
+
+def find_sessions():
+    sessions = {}
+    for folder in ["sessions5", "sessions_clean"]:
+        sd = BASE / folder
+        if sd.exists():
+            for f in sd.glob("*.session"):
+                if f.stem not in sessions:
+                    sessions[f.stem] = f
+    return sessions
+
+async def spam(aid, chats, session_path):
+    done = set(p["sent"].get(aid, []) + p["failed"].get(aid, []))
+    remaining = [c for c in chats if c["username"] not in done]
+    if not remaining:
+        return 0, 0
+
+    client = None
+    try:
+        client = TelegramClient(str(session_path), API_ID, API_HASH)
+        await client.connect()
+    except Exception as e:
+        log(f"❌ {aid} BAD SESSION: {e}")
+        p["flood_until"][aid] = int(time.time()) + 3600
+        save()
+        if client:
+            await client.disconnect()
+        return 0, 0
+
+    me = await client.get_me()
+    log(f"✅ {aid} (@{me.username or me.first_name}): {len(remaining)} chats")
+
+    sent = 0
+    msg = random.choice(MESSAGES)
+
+    for i, c in enumerate(remaining):
+        u = c["username"]
+        t = c.get("title", u)
+        try:
+            entity = await client.get_entity(f"@{u}")
+            await client.send_message(entity, msg)
+            p["sent"].setdefault(aid, []).append(u)
+            p["stats"]["total_sent"] += 1
+            sent += 1
+            log(f"  [{i+1}/{len(remaining)}] SENT: {t}")
+            save()
+            await asyncio.sleep(random.uniform(4, 10))
+        except FloodWaitError as e:
+            p["flood_until"][aid] = int(time.time()) + e.seconds
+            save()
+            log(f"  FLOOD {e.seconds}s — DONE with {aid}")
+            break
+        except Exception as e:
+            p["failed"].setdefault(aid, []).append(u)
+            p["stats"]["total_failed"] += 1
+            save()
+            log(f"  [{i+1}/{len(remaining)}] {type(e).__name__}: {t}")
+
+    await client.disconnect()
+    return sent, 0
+
+async def main():
+    # Load live chats from generated/account_live_chats_v2.json
+    live_path = BASE / "generated" / "account_live_chats_v2.json"
+    if not live_path.exists():
+        log("No live chats file found!")
+        return
+    all_chats = {}
+    src = json.loads(live_path.read_text())
+    for aid, chats in src.items():
+        if not isinstance(chats, list):
+            continue
+        all_chats[aid] = {}
+        for c in chats:
+            all_chats[aid][c["username"]] = c
+
+    sessions = find_sessions()
+    now = time.time()
+
+    working = []
+    skipped = 0
+    for aid, sp in sorted(sessions.items(), key=lambda x: len(all_chats.get(x[0], {})), reverse=True):
+        if aid not in all_chats:
+            continue
+        fu = p["flood_until"].get(aid, 0)
+        if fu > now:
+            skipped += 1
+            continue
+        chats = list(all_chats[aid].values())
+        done = len(p["sent"].get(aid, [])) + len(p["failed"].get(aid, []))
+        remaining = len(chats) - done
+        if remaining > 0:
+            working.append((aid, chats, sp, remaining))
+
+    working.sort(key=lambda x: x[3], reverse=True)
+    total = sum(w[3] for w in working)
+
+    log(f"=== SPAM LIVE ===")
+    log(f"Accounts ready: {len(working)}, flooded: {skipped}")
+    log(f"Total chats remaining: {total}")
+    log(f"Already sent: {p['stats']['total_sent']}, failed: {p['stats']['total_failed']}\n")
+
+    for aid, chats, sp, rem in working:
+        log(f"▶ {aid}: {rem} chats")
+        s, f = await spam(aid, chats, sp)
+        if s > 0:
+            delay = random.uniform(30, 60)
+            log(f"💤 Cooldown {delay:.0f}s\n")
+            await asyncio.sleep(delay)
+
+    log(f"\n=== DONE ===")
+    log(f"Sent: {p['stats']['total_sent']}, Failed: {p['stats']['total_failed']}")
+
+asyncio.run(main())