easyoref 1.14.2 → 1.15.1

package/dist/agent/graph.js

@@ -1,32 +1,27 @@
 /**
  * LangGraph.js enrichment pipeline — phase-aware, time-validated.
  *
- * KEY DESIGN PRINCIPLES:
- *   1. TIME IS KING — every post is validated against the alert time window.
- *      LLM receives alert time + post time and scores time_relevance.
- *      Posts about previous/different attacks are rejected.
- *   2. PHASE-AWARE — each phase extracts only what's relevant:
- *      - early_warning: origin, ETA, rocket count, cassette
- *      - siren: carries early data + adds interception, impacts
- *      - resolved: carries all + adds casualties, injuries, final stats
- *   3. CARRY-FORWARD — results persist in Redis (EnrichmentData).
- *      Each phase inherits previous phase's findings.
- *   4. INLINE CITATIONS — no superscripts, no footer sources.
- *      Format: [[1]](url) right after each data point.
- *   5. DEDUP EDITS — hash-based check prevents "message not modified" spam.
+ * Lean orchestrator: connects filter → extract → vote → edit.
+ * All logic lives in dedicated modules:
+ *   - filters.ts:  deterministic noise filter, channel tracking
+ *   - extract.ts:  cheap LLM pre-filter, expensive extraction, post-filter
+ *   - vote.ts:     consensus voting (deterministic)
+ *   - message.ts:  message building, Telegram editing
+ *   - helpers.ts:  toIsraelTime, textHash
  *
  * Pipeline:
- *   preFilter → extractAndValidate → postFilter → vote → [clarify] → editMessage
+ *   collectAndFilter → extract → vote → [clarify → revote] → editMessage
  */
 import { Annotation, MemorySaver, StateGraph } from "@langchain/langgraph";
-import { ChatOpenAI } from "@langchain/openai";
-import { Bot } from "grammy";
-import { createHash } from "node:crypto";
 import { config } from "../config.js";
 import * as logger from "../logger.js";
 import { runClarify } from "./clarify.js";
-import { getActiveSession, getCachedExtractions, getChannelPosts, getEnrichmentData, saveCachedExtractions, saveEnrichmentData, } from "./store.js";
+import { extractPosts, filterChannelsCheap, postFilter, } from "./extract.js";
+import { buildChannelTracking } from "./filters.js";
+import { editMessage } from "./message.js";
+import { getActiveSession, getChannelPosts, getEnrichmentData, getLastUpdateTs, setLastUpdateTs, } from "./store.js";
 import { emptyEnrichmentData } from "./types.js";
+import { vote } from "./vote.js";
 // ── State ──────────────────────────────────────────────
 const AgentState = Annotation.Root({
     alertId: Annotation({ reducer: (_, b) => b }),
@@ -37,1101 +32,133 @@ const AgentState = Annotation.Root({
     messageId: Annotation({ reducer: (_, b) => b }),
     isCaption: Annotation({ reducer: (_, b) => b }),
     currentText: Annotation({ reducer: (_, b) => b }),
-    channelPosts: Annotation({ reducer: (_, b) => b }),
-    filteredPosts: Annotation({ reducer: (_, b) => b }),
+    tracking: Annotation({ reducer: (_, b) => b }),
     extractions: Annotation({ reducer: (_, b) => b }),
     votedResult: Annotation({ reducer: (_, b) => b }),
-    /** Tracks whether clarify has already run (prevents infinite loop) */
     clarifyAttempted: Annotation({ reducer: (_, b) => b }),
-    /** Cross-phase enrichment data loaded at start */
     previousEnrichment: Annotation({ reducer: (_, b) => b }),
-    /** Session start timestamp for time window calculations */
-    sessionStartTs: Annotation({ reducer: (_, b) => b }),
-    /** Phase start timestamp */
-    phaseStartTs: Annotation({ reducer: (_, b) => b }),
 });
-// ── LLM ───────────────────────────────────────────────
-function getLLM() {
-    return new ChatOpenAI({
-        model: config.agent.model,
-        configuration: {
-            baseURL: "https://openrouter.ai/api/v1",
-            defaultHeaders: {
-                "HTTP-Referer": "https://github.com/mikhailkogan17/EasyOref",
-                "X-Title": "EasyOref",
-            },
-        },
-        apiKey: config.agent.apiKey,
-        temperature: 0,
-        maxTokens: 500,
-    });
-}
-// ── Region keywords (Hebrew + transliterations) ────────
-function buildRegionKeywords() {
-    const keywords = [];
-    for (const area of config.areas) {
-        keywords.push(area.toLowerCase());
-        const first = area.split(" ")[0];
-        if (first && first.length >= 2)
-            keywords.push(first.toLowerCase());
-    }
-    for (const [he, label] of Object.entries(config.agent.areaLabels)) {
-        keywords.push(he.toLowerCase());
-        for (const word of label.split(/\s+/)) {
-            if (word.length >= 3)
-                keywords.push(word.toLowerCase());
-        }
-    }
-    // Common attack-related keywords (always relevant)
-    keywords.push("ישראל", "israel", "израиль", "ракет", "rocket", "missile", "iron dome", "כיפת ברזל", "перехват", "intercept", "צבע אדום", "red alert");
-    return [...new Set(keywords)];
-}
-// ── Hard-ignore: Pikud HaOref official area lists ("простыня") ──
-const OREF_LINK_PATTERN = /oref\.org\.il/i;
-const OREF_OFFICIAL_CHANNEL_PATTERN = /pikud|פיקוד|oref/i;
-/** Detect posts that are just official Pikud HaOref area list links */
-function isOrefAreaList(post) {
-    const text = post.text;
-    // Link to official Pikud HaOref page
-    if (OREF_LINK_PATTERN.test(text))
-        return true;
-    // Official channels that just echo the area list (very long, >300 chars, mostly city names)
-    if (OREF_OFFICIAL_CHANNEL_PATTERN.test(post.channel) && text.length > 300)
-        return true;
-    return false;
-}
-// ── Launch detection keywords (strict — early_warning only) ──
-const LAUNCH_KEYWORDS = [
-    "שיגור",
-    "שיגורים",
-    "שוגרו",
-    "נורו",
-    "зафиксированы запуски",
-    "обнаружены запуски",
-    "запуски ракет",
-    "запуск ракет",
-    "пуски ракет",
-    "ракетный обстрел",
-    "ракетная атака",
-    "missile launch",
-    "rocket launch",
-    "barrage",
-    "fired towards",
-    "launches detected",
-    "missiles fired",
-    "שיגורים לישראל",
-    "ירי טילים",
-    "ירי רקטות",
-    "إطلاق صواريخ",
-].map((kw) => kw.toLowerCase());
-// ── Time window per phase (ms before alertTs to accept posts) ──
-const TIME_WINDOW_MS = {
-    early_warning: 5 * 60 * 1000, // 5 min before alert
-    siren: 10 * 60 * 1000, // 10 min (includes early_warning period)
-    resolved: 30 * 60 * 1000, // 30 min (full session window)
-};
-// ── Helpers ────────────────────────────────────────────
-/** Format timestamp as HH:MM Israel time */
-function toIsraelTime(ts) {
-    return new Date(ts).toLocaleTimeString("he-IL", {
-        hour: "2-digit",
-        minute: "2-digit",
-        timeZone: "Asia/Jerusalem",
-    });
-}
-/** MD5 hash for edit dedup */
-function textHash(text) {
-    return createHash("md5").update(text).digest("hex");
-}
-// ─────────────────────────────────────────────────────────
-// Tier 0: Pre-filter (phase-aware, time-bounded, 0 tokens)
-// ─────────────────────────────────────────────────────────
-async function collectAndPreFilter(state) {
+// ── Node: collect posts + deterministic noise filter ───
+async function collectAndFilter(state) {
     const posts = await getChannelPosts(state.alertId);
     const prevEnrichment = await getEnrichmentData();
-    // Load session for time boundaries
     const session = await getActiveSession();
     const sessionStartTs = session?.sessionStartTs ?? state.alertTs;
-    const phaseStartTs = session?.phaseStartTs ?? state.alertTs;
+    const lastUpdateTs = await getLastUpdateTs();
     if (posts.length === 0) {
-        logger.info("Agent: no posts in session", { alertId: state.alertId });
-        return {
-            channelPosts: posts,
-            filteredPosts: [],
-            previousEnrichment: prevEnrichment,
-            sessionStartTs,
-            phaseStartTs,
-        };
+        logger.info("Agent: no posts", { alertId: state.alertId });
+        return { tracking: null, previousEnrichment: prevEnrichment };
     }
-    const keywords = buildRegionKeywords();
-    const alertType = state.alertType;
-    const alertTs = state.alertTs;
-    // Time window: reject posts older than window before alertTs
-    const windowMs = TIME_WINDOW_MS[alertType];
-    const cutoffTs = alertTs - windowMs;
-    let filtered;
-    if (alertType === "early_warning") {
-        // ── STRICT launch-only filter for early warning ──
-        // Step 1: Find posts with launch keywords, within time window
-        const launchPosts = posts.filter((post) => {
-            if (post.ts < cutoffTs)
-                return false;
-            if (isOrefAreaList(post))
-                return false;
-            const text = post.text.toLowerCase();
-            return LAUNCH_KEYWORDS.some((kw) => text.includes(kw));
-        });
-        // Step 2: Get channels that posted about launches
-        const channelFirstLaunchTs = new Map();
-        for (const post of launchPosts) {
-            const current = channelFirstLaunchTs.get(post.channel);
-            if (current === undefined || post.ts < current) {
-                channelFirstLaunchTs.set(post.channel, post.ts);
-            }
-        }
-        // Step 3: Accept follow-up posts from launch channels only (within window)
-        filtered = posts.filter((post) => {
-            if (post.ts < cutoffTs)
-                return false;
-            const text = post.text.toLowerCase();
-            if (!keywords.some((kw) => text.includes(kw)))
-                return false;
-            const firstLaunch = channelFirstLaunchTs.get(post.channel);
-            if (firstLaunch === undefined)
-                return false;
-            return post.ts >= firstLaunch;
-        });
-        logger.info("Agent: pre-filter (early_warning)", {
-            alertId: state.alertId,
-            total: posts.length,
-            launch_posts: launchPosts.length,
-            launch_channels: channelFirstLaunchTs.size,
-            after_filter: filtered.length,
-            cutoff: toIsraelTime(cutoffTs),
-            channels_breakdown: Object.fromEntries([...new Set(posts.map((p) => p.channel))].map((ch) => [
-                ch,
-                {
-                    total: posts.filter((p) => p.channel === ch).length,
-                    passed: filtered.filter((p) => p.channel === ch).length,
-                },
-            ])),
-            oref_filtered: posts.filter(isOrefAreaList).length,
-        });
-    }
-    else {
-        // ── Siren & Resolved: broader filter, time-bounded ──
-        filtered = posts.filter((post) => {
-            if (post.ts < cutoffTs)
-                return false;
-            if (isOrefAreaList(post))
-                return false;
-            const text = post.text.toLowerCase();
-            return keywords.some((kw) => text.includes(kw));
-        });
-        logger.info("Agent: pre-filter", {
+    const tracking = buildChannelTracking(posts, sessionStartTs, lastUpdateTs);
+    logger.info("Agent: channel tracking", {
+        alertId: state.alertId,
+        total_posts: posts.length,
+        channels_with_updates: tracking.channels_with_updates.length,
+        total_new_posts: tracking.channels_with_updates.reduce((s, c) => s + c.last_tracked_messages.length, 0),
+    });
+    return { tracking, previousEnrichment: prevEnrichment };
+}
+// ── Node: cheap LLM channel filter + expensive extraction ──
+async function extractNode(state) {
+    if (!state.tracking || state.tracking.channels_with_updates.length === 0) {
+        logger.info("Agent: no channels with updates", {
             alertId: state.alertId,
-            alertType,
-            total: posts.length,
-            after_filter: filtered.length,
-            cutoff: toIsraelTime(cutoffTs),
-            channels_breakdown: Object.fromEntries([...new Set(posts.map((p) => p.channel))].map((ch) => [
-                ch,
-                {
-                    total: posts.filter((p) => p.channel === ch).length,
-                    passed: filtered.filter((p) => p.channel === ch).length,
-                },
-            ])),
-            oref_filtered: posts.filter(isOrefAreaList).length,
         });
+        return { extractions: [] };
     }
-    return {
-        channelPosts: posts,
-        filteredPosts: filtered,
-        previousEnrichment: prevEnrichment,
-        sessionStartTs,
-        phaseStartTs,
-    };
-}
-// ─────────────────────────────────────────────────────────
-// Tier 1: Extract + validate (1 LLM call per post)
-// Phase-aware prompts — agent knows what to look for.
-// TIME CONTEXT — agent sees alert time + post time.
-// ─────────────────────────────────────────────────────────
-const QUAL_VALUES = '"all"|"most"|"many"|"few"|"exists"|"none"|"more_than"|"less_than"';
-/** Phase-specific extraction instructions */
-function getPhaseInstructions(alertType) {
-    switch (alertType) {
-        case "early_warning":
-            return `PHASE: EARLY WARNING (radar detected launches, sirens not yet).
-Focus on: country_origin (WHERE were rockets launched from?), eta_refined_minutes, rocket_count, is_cassette.
-Do NOT extract: intercepted, sea_impact, open_area_impact, hits_confirmed, casualties, injuries — these are IMPOSSIBLE at this stage.
-If a message discusses interception results, it is about a PREVIOUS attack — set time_relevance=0.`;
-        case "siren":
-            return `PHASE: SIREN (rockets incoming, impact imminent).
-Focus on: country_origin (if not known yet), rocket_count, intercepted, sea_impact, open_area_impact, is_cassette.
-Do NOT extract: hits_confirmed, casualties, injuries — too early for confirmed damage reports.
-If a message discusses casualties or confirmed hits, verify the timing carefully - it may be about a previous attack.`;
-        case "resolved":
-            return `PHASE: RESOLVED (incident over, assessing damage).
-Focus on: intercepted (final count), hits_confirmed, casualties, injuries, open_area_impact.
-All fields are valid at this stage. Prioritize confirmed official reports.`;
-    }
-}
-const SYSTEM_PROMPT_BASE = `You analyze Telegram channel messages about a missile/rocket attack on Israel.
-Your job: extract factual data, assess quality, AND validate temporal relevance.
-
-CRITICAL — TIME VALIDATION:
-You will receive the alert time and the post time. You MUST determine if this post
-is about the CURRENT attack or about a previous/different event.
-- If post discusses events clearly BEFORE the alert time → time_relevance=0
-- If post is generic military news not specific to this attack → time_relevance=0.2
-- If post discusses the current attack → time_relevance=1.0
-- If uncertain → time_relevance=0.5 (the system will use alert_history to verify)
-
-Return ONLY valid JSON (no markdown, no explanation):
-{
-  "region_relevance": float,       // 0–1: does this message discuss the specified alert region?
-  "source_trust": float,           // 0–1: factual reporting (1.0) vs unverified rumors/panic (0.0)
-  "tone": "calm"|"neutral"|"alarmist",
-  "time_relevance": float,         // 0–1: is this post about the CURRENT attack? (see rules above)
-  "country_origin": string|null,   // "Iran","Yemen","Lebanon","Gaza","Iraq","Syria" or null
-  "rocket_count": int|null,
-  "is_cassette": bool|null,
-  "intercepted": int|null,
-  "intercepted_qual": ${QUAL_VALUES}|null,
-  "intercepted_qual_num": int|null,
-  "sea_impact": int|null,
-  "sea_impact_qual": ${QUAL_VALUES}|null,
-  "sea_impact_qual_num": int|null,
-  "open_area_impact": int|null,
-  "open_area_impact_qual": ${QUAL_VALUES}|null,
-  "open_area_impact_qual_num": int|null,
-  "hits_confirmed": int|null,
-  "casualties": int|null,
-  "injuries": int|null,
-  "eta_refined_minutes": int|null,
-  "confidence": float
-}
-
-Rules:
-- If unrelated to the alert region, set region_relevance=0 and all data fields to null.
-- If message is speculative/unconfirmed rumor, set source_trust < 0.4.
-- If message uses excessive caps, exclamation marks, panic language → tone="alarmist".
-- Only extract concrete numbers explicitly stated in the text. Never guess.
-- *_qual fields: use ONLY when NO exact count is given. If exact number present, set *_qual=null.
-- "none" qual is only valid if explicitly stated (e.g., "все перехвачены", "не упало в море").
-- For IDF (@idf_telegram) posts about ongoing operations (not this specific attack) → time_relevance=0.
-- LANGUAGE NEUTRALITY: Posts may be in Hebrew, Russian, Arabic, or English. The language of the post
-  MUST NOT affect source_trust or confidence. Russian-language Israeli channels are equally reliable
-  and often break news faster than Hebrew ones. Judge ONLY by factual content and tone.
-- TRUST INTERCEPTION & IMPACT REPORTS: When a channel explicitly states interception results
-  (e.g., "перехвачены", "intercepted", "יירוט", "упали в море", "fell in the sea", "נפלו בים",
-  "open area impact", "שטח פתוח"), trust these claims with source_trust >= 0.7 and confidence >= 0.7.
-  Israeli Telegram channels often report interception results before official confirmation,
-  and these reports are typically accurate. Do NOT downgrade these just because they lack official source.`;
-async function extractAndValidate(state) {
-    if (state.filteredPosts.length === 0) {
-        logger.info("Agent: no filtered posts to extract", {
+    // Step 1: cheap LLM — which channels have important military intel?
+    const relevantChannels = await filterChannelsCheap(state.tracking, state.alertAreas, state.alertTs, state.alertType);
+    if (relevantChannels.length === 0) {
+        logger.info("Agent: no relevant channels after cheap filter", {
             alertId: state.alertId,
         });
         return { extractions: [] };
     }
-    // ── Post-level dedup: only send NEW posts to LLM ───────
-    const posts = state.filteredPosts;
-    // Compute hash for each post (channel + text content)
-    const postHashMap = new Map(); // hash → serialized post key
-    const hashToPost = new Map();
-    for (const post of posts) {
-        const hash = textHash(post.channel + "|" + post.text.slice(0, 800));
-        postHashMap.set(hash, post.channel);
-        hashToPost.set(hash, post);
-    }
-    // Fetch cached extractions from previous jobs in this session
-    const allHashes = [...postHashMap.keys()];
-    const cached = await getCachedExtractions(allHashes);
-    // Split: cached results vs posts needing LLM
-    const cachedResults = [];
-    const newPosts = [];
-    const newHashes = [];
-    for (const [hash, post] of hashToPost) {
-        const cachedJson = cached.get(hash);
-        if (cachedJson) {
-            cachedResults.push(JSON.parse(cachedJson));
-        }
-        else {
-            newPosts.push(post);
-            newHashes.push(hash);
+    // Step 2: collect posts from relevant channels only
+    const postsToExtract = [];
+    for (const ch of state.tracking.channels_with_updates) {
+        const match = relevantChannels.some((rc) => rc === ch.channel || rc === `@${ch.channel}` || `@${rc}` === ch.channel);
+        if (match) {
+            postsToExtract.push(...ch.last_tracked_messages);
         }
     }
-    logger.info("Agent: extraction dedup", {
-        alertId: state.alertId,
-        total: posts.length,
-        cached: cachedResults.length,
-        new: newPosts.length,
-    });
-    // If all posts are cached, return immediately (0 LLM calls)
-    if (newPosts.length === 0) {
-        logger.info("Agent: extracted (all cached)", {
+    if (postsToExtract.length === 0) {
+        logger.info("Agent: no posts from relevant channels", {
             alertId: state.alertId,
-            count: cachedResults.length,
         });
-        return { extractions: cachedResults };
+        return { extractions: [] };
     }
-    const llm = getLLM();
-    const regionHint = state.alertAreas.length > 0
-        ? state.alertAreas.join(", ")
-        : Object.keys(config.agent.areaLabels).join(", ") || "Israel";
-    const alertTimeIL = toIsraelTime(state.alertTs);
-    const nowIL = toIsraelTime(Date.now());
-    const phaseInstructions = getPhaseInstructions(state.alertType);
-    const systemPrompt = SYSTEM_PROMPT_BASE + "\n\n" + phaseInstructions;
-    // Only extract NEW posts (not seen in previous jobs)
-    const newResults = await Promise.all(newPosts.map(async (post) => {
-        const postTimeIL = toIsraelTime(post.ts);
-        const postAgeMin = Math.round((state.alertTs - post.ts) / 60_000);
-        const postAgeSuffix = postAgeMin > 0
-            ? `(${postAgeMin} min BEFORE alert)`
-            : postAgeMin < 0
-                ? `(${Math.abs(postAgeMin)} min AFTER alert)`
-                : "(same time as alert)";
-        const contextHeader = `Alert time: ${alertTimeIL} (Israel)\n` +
-            `Post time:  ${postTimeIL} (Israel) ${postAgeSuffix}\n` +
-            `Current time: ${nowIL} (Israel)\n` +
-            `Alert region: ${regionHint}\n` +
-            `UI language: ${config.language}\n`;
-        try {
-            const response = await llm.invoke([
-                { role: "system", content: systemPrompt },
-                {
-                    role: "user",
-                    content: `${contextHeader}Channel: ${post.channel}\n\nMessage:\n${post.text.slice(0, 800)}`,
-                },
-            ]);
-            const raw = typeof response.content === "string"
-                ? response.content
-                : JSON.stringify(response.content);
-            const text = raw
-                .replace(/^```(?:json)?\s*\n?/i, "")
-                .replace(/\n?```\s*$/i, "");
-            const parsed = JSON.parse(text.trim());
-            return {
-                ...parsed,
-                channel: post.channel,
-                messageUrl: post.messageUrl,
-                time_relevance: parsed.time_relevance ?? 0.5,
-                valid: true,
-            };
-        }
-        catch (err) {
-            logger.warn("Agent: extraction failed", {
-                channel: post.channel,
-                error: String(err),
-            });
-            return {
-                channel: post.channel,
-                region_relevance: 0,
-                source_trust: 0,
-                tone: "neutral",
-                time_relevance: 0,
-                country_origin: null,
-                rocket_count: null,
-                is_cassette: null,
-                intercepted: null,
-                intercepted_qual: null,
-                intercepted_qual_num: null,
-                sea_impact: null,
-                sea_impact_qual: null,
-                sea_impact_qual_num: null,
-                open_area_impact: null,
-                open_area_impact_qual: null,
-                open_area_impact_qual_num: null,
-                hits_confirmed: null,
-                casualties: null,
-                injuries: null,
-                eta_refined_minutes: null,
-                confidence: 0,
-                valid: false,
-                reject_reason: "extraction_error",
-            };
-        }
-    }));
-    // Save new extractions to Redis cache for future jobs
-    const cacheEntries = {};
-    newPosts.forEach((post, i) => {
-        const hash = textHash(post.channel + "|" + post.text.slice(0, 800));
-        cacheEntries[hash] = JSON.stringify(newResults[i]);
-    });
-    await saveCachedExtractions(cacheEntries);
-    // Merge cached + new results
-    const results = [...cachedResults, ...newResults];
-    logger.info("Agent: extracted", {
-        alertId: state.alertId,
-        count: results.length,
-        newLLMCalls: newResults.length,
-        cachedReused: cachedResults.length,
-        timeRelevance: results.map((r) => ({
-            ch: r.channel,
-            tr: r.time_relevance,
-            conf: r.confidence,
-            origin: r.country_origin,
-            intercepted: r.intercepted ?? r.intercepted_qual,
-            sea: r.sea_impact ?? r.sea_impact_qual,
-            valid: r.valid,
-        })),
-    });
-    return { extractions: results };
-}
-// ─────────────────────────────────────────────────────────
-// Tier 2: Post-filter (deterministic, 0 tokens)
-// Now includes TIME RELEVANCE check.
-// ─────────────────────────────────────────────────────────
-function postFilter(state) {
-    const validated = state.extractions.map((ext) => {
-        // V0: TIME RELEVANCE — the most important check
-        if (ext.time_relevance < 0.5) {
-            return { ...ext, valid: false, reject_reason: "stale_post" };
-        }
-        // V1: region relevance
-        if (ext.region_relevance < 0.5) {
-            return { ...ext, valid: false, reject_reason: "region_irrelevant" };
-        }
-        // V2: source trust
-        if (ext.source_trust < 0.4) {
-            return { ...ext, valid: false, reject_reason: "untrusted_source" };
-        }
-        // V3: tone — reject alarmist
-        if (ext.tone === "alarmist") {
-            return { ...ext, valid: false, reject_reason: "alarmist_tone" };
-        }
-        // V4: at least one data field must be non-null
-        const hasData = ext.country_origin !== null ||
-            ext.rocket_count !== null ||
-            ext.is_cassette !== null ||
-            ext.intercepted !== null ||
-            ext.intercepted_qual !== null ||
-            ext.hits_confirmed !== null ||
-            ext.casualties !== null ||
-            ext.injuries !== null ||
-            ext.eta_refined_minutes !== null;
-        if (!hasData) {
-            return { ...ext, valid: false, reject_reason: "no_data" };
-        }
-        // V5: overall confidence floor
-        if (ext.confidence < 0.3) {
-            return { ...ext, valid: false, reject_reason: "low_confidence" };
-        }
-        return { ...ext, valid: true };
-    });
-    const passed = validated.filter((e) => e.valid);
-    const rejected = validated.filter((e) => !e.valid);
-    logger.info("Agent: post-filter", {
+    // Step 3: expensive extraction with post-level dedup
+    const ctx = {
+        alertTs: state.alertTs,
+        alertType: state.alertType,
+        alertAreas: state.alertAreas,
         alertId: state.alertId,
-        passed: passed.length,
-        rejected: rejected.length,
-        reasons: rejected.map((r) => `${r.channel}:${r.reject_reason}`),
-        passed_channels: passed.map((p) => p.channel),
-    });
-    return { extractions: validated };
-}
-// ─────────────────────────────────────────────────────────
-// Tier 3: Vote (deterministic, 0 tokens)
-// ─────────────────────────────────────────────────────────
-function vote(state) {
-    const valid = state.extractions.filter((e) => e.valid);
-    if (valid.length === 0) {
-        return { votedResult: null };
-    }
-    // Assign 1-based citation indices
-    const indexed = valid.map((e, i) => ({ ...e, idx: i + 1 }));
-    const citedSources = indexed.map((e) => ({
-        index: e.idx,
-        channel: e.channel,
-        messageUrl: e.messageUrl ?? null,
-    }));
-    // ETA: highest confidence source
-    const withEta = indexed
-        .filter((e) => e.eta_refined_minutes !== null)
-        .sort((a, b) => b.confidence - a.confidence);
-    const bestEta = withEta[0] ?? null;
-    // Country: group unique values
-    const countryMap = new Map();
-    for (const e of indexed) {
-        if (e.country_origin) {
-            const list = countryMap.get(e.country_origin) ?? [];
-            list.push(e.idx);
-            countryMap.set(e.country_origin, list);
-        }
-    }
-    const country_origins = countryMap.size > 0
-        ? Array.from(countryMap.entries()).map(([name, citations]) => ({
-            name,
-            citations,
-        }))
-        : null;
-    // Rocket count: range
-    const rocketSrcs = indexed.filter((e) => e.rocket_count !== null);
-    const rocketVals = rocketSrcs.map((e) => e.rocket_count);
-    const rocket_count_min = rocketVals.length > 0 ? Math.min(...rocketVals) : null;
-    const rocket_count_max = rocketVals.length > 0 ? Math.max(...rocketVals) : null;
-    const rocket_citations = rocketSrcs.map((e) => e.idx);
-    // Helper: avg weighted confidence
-    function fieldConf(srcs) {
-        if (srcs.length === 0)
-            return 0;
-        return (srcs.reduce((s, e) => s + e.source_trust * e.confidence, 0) / srcs.length);
-    }
-    // Helper: mode for QualCount
-    function modeQual(srcs, key) {
-        const vals = srcs
-            .map((e) => e[key])
-            .filter((v) => v !== null);
-        if (vals.length === 0)
-            return null;
-        const freq = new Map();
-        for (const v of vals)
-            freq.set(v, (freq.get(v) ?? 0) + 1);
-        return [...freq.entries()].sort((a, b) => b[1] - a[1])[0][0];
-    }
-    function medianQualNum(srcs, key) {
-        const vals = srcs
-            .map((e) => e[key])
-            .filter((v) => v !== null)
-            .sort((a, b) => a - b);
-        return vals.length > 0 ? vals[Math.floor(vals.length / 2)] : null;
-    }
-    // Cassette: majority
-    const cassSrcs = indexed.filter((e) => e.is_cassette !== null);
-    const cassVals = cassSrcs.map((e) => e.is_cassette);
-    const is_cassette = cassVals.length > 0
-        ? cassVals.filter(Boolean).length > cassVals.length / 2
-        : null;
-    const is_cassette_confidence = fieldConf(cassSrcs);
-    // Hits: median
-    const hitsSrcs = indexed.filter((e) => e.hits_confirmed !== null && e.hits_confirmed > 0);
-    const hitsVals = indexed
-        .filter((e) => e.hits_confirmed !== null)
-        .map((e) => e.hits_confirmed)
-        .sort((a, b) => a - b);
-    const hits_confirmed = hitsVals.length > 0 ? hitsVals[Math.floor(hitsVals.length / 2)] : null;
-    const hits_citations = hitsSrcs.map((e) => e.idx);
-    const hits_confidence = fieldConf(hitsSrcs);
-    // Intercepted: median / qual
-    const interceptedSrcs = indexed.filter((e) => e.intercepted !== null);
-    const interceptedQualSrcs = indexed.filter((e) => e.intercepted_qual !== null);
-    const interceptedVals = interceptedSrcs
-        .map((e) => e.intercepted)
-        .sort((a, b) => a - b);
-    const intercepted = interceptedVals.length > 0
-        ? interceptedVals[Math.floor(interceptedVals.length / 2)]
-        : null;
-    const intercepted_qual = intercepted === null
-        ? modeQual(interceptedQualSrcs, "intercepted_qual")
-        : null;
-    const intercepted_qual_num = intercepted_qual !== null
-        ? medianQualNum(interceptedQualSrcs, "intercepted_qual_num")
-        : null;
-    const intercepted_confidence = fieldConf(interceptedSrcs.length > 0 ? interceptedSrcs : interceptedQualSrcs);
-    // Sea impact: median / qual
-    const seaSrcs = indexed.filter((e) => e.sea_impact !== null);
-    const seaQualSrcs = indexed.filter((e) => e.sea_impact_qual !== null);
-    const seaVals = seaSrcs
-        .map((e) => e.sea_impact)
-        .sort((a, b) => a - b);
-    const sea_impact = seaVals.length > 0 ? seaVals[Math.floor(seaVals.length / 2)] : null;
-    const sea_impact_qual = sea_impact === null ? modeQual(seaQualSrcs, "sea_impact_qual") : null;
-    const sea_impact_qual_num = sea_impact_qual !== null
-        ? medianQualNum(seaQualSrcs, "sea_impact_qual_num")
-        : null;
-    const sea_confidence = fieldConf(seaSrcs.length > 0 ? seaSrcs : seaQualSrcs);
-    // Open area impact: median / qual
-    const openSrcs = indexed.filter((e) => e.open_area_impact !== null);
-    const openQualSrcs = indexed.filter((e) => e.open_area_impact_qual !== null);
-    const openVals = openSrcs
-        .map((e) => e.open_area_impact)
-        .sort((a, b) => a - b);
-    const open_area_impact = openVals.length > 0 ? openVals[Math.floor(openVals.length / 2)] : null;
-    const open_area_impact_qual = open_area_impact === null
-        ? modeQual(openQualSrcs, "open_area_impact_qual")
-        : null;
-    const open_area_impact_qual_num = open_area_impact_qual !== null
-        ? medianQualNum(openQualSrcs, "open_area_impact_qual_num")
-        : null;
-    const open_area_confidence = fieldConf(openSrcs.length > 0 ? openSrcs : openQualSrcs);
-    // Casualties
-    const casualtySrcs = indexed.filter((e) => e.casualties !== null && e.casualties > 0);
-    const casualtyVals = casualtySrcs
-        .map((e) => e.casualties)
-        .sort((a, b) => a - b);
-    const casualties = casualtyVals.length > 0
-        ? casualtyVals[Math.floor(casualtyVals.length / 2)]
-        : null;
-    const casualties_citations = casualtySrcs.map((e) => e.idx);
-    const casualties_confidence = fieldConf(casualtySrcs);
-    // Injuries
-    const injurySrcs = indexed.filter((e) => e.injuries !== null && e.injuries > 0);
-    const injuryVals = injurySrcs
-        .map((e) => e.injuries)
-        .sort((a, b) => a - b);
-    const injuries = injuryVals.length > 0
-        ? injuryVals[Math.floor(injuryVals.length / 2)]
-        : null;
-    const injuries_citations = injurySrcs.map((e) => e.idx);
-    const injuries_confidence = fieldConf(injurySrcs);
-    // Rocket confidence
-    const rocket_confidence = fieldConf(rocketSrcs);
-    // Overall weighted confidence
-    const totalWeight = indexed.reduce((s, e) => s + e.source_trust * e.confidence, 0);
-    const weightedConf = totalWeight / indexed.length;
-    const voted = {
-        eta_refined_minutes: bestEta?.eta_refined_minutes ?? null,
-        eta_citations: bestEta ? [bestEta.idx] : [],
-        country_origins,
-        rocket_count_min,
-        rocket_count_max,
-        rocket_citations,
-        rocket_confidence,
-        is_cassette,
-        is_cassette_confidence,
-        intercepted,
-        intercepted_qual,
-        intercepted_qual_num,
-        intercepted_confidence,
-        sea_impact,
-        sea_impact_qual,
-        sea_impact_qual_num,
-        sea_confidence,
-        open_area_impact,
-        open_area_impact_qual,
-        open_area_impact_qual_num,
-        open_area_confidence,
-        hits_confirmed,
-        hits_citations,
-        hits_confidence,
-        casualties,
-        casualties_citations,
-        casualties_confidence,
-        injuries,
-        injuries_citations,
-        injuries_confidence,
-        confidence: Math.round(weightedConf * 100) / 100,
-        sources_count: indexed.length,
-        citedSources,
-    };
-    logger.info("Agent: voted", { alertId: state.alertId, voted });
-    return { votedResult: voted };
-}
-// ─────────────────────────────────────────────────────────
-// Tier 4: Edit message — inline citations, carry-forward
-// ─────────────────────────────────────────────────────────
-/** EN country name → Russian */
-const COUNTRY_RU = {
-    Iran: "Иран",
-    Yemen: "Йемен",
-    Lebanon: "Ливан",
-    Gaza: "Газа",
-    Iraq: "Ирак",
-    Syria: "Сирия",
-    Hezbollah: "Хезболла",
-};
-/** Format inline citations: [[1]](url), [[2]](url) */
-function inlineCites(indices, citedSources) {
-    const parts = [];
-    for (const idx of indices) {
-        const src = citedSources.find((s) => s.index === idx);
-        if (src?.messageUrl) {
-            parts.push(`<a href="${src.messageUrl}">[${idx}]</a>`);
-        }
-    }
-    return parts.length > 0 ? " " + parts.join(", ") : "";
-}
-/** Get InlineCite[] from citation indices */
-function extractCites(indices, citedSources) {
-    const cites = [];
-    for (const idx of indices) {
-        const src = citedSources.find((s) => s.index === idx);
-        if (src?.messageUrl) {
-            cites.push({ url: src.messageUrl, channel: src.channel });
-        }
-    }
-    return cites;
-}
-/** Format inline citations from InlineCite[] (for carry-forward data) */
-function inlineCitesFromData(cites) {
-    if (cites.length === 0)
-        return "";
-    return (" " + cites.map((c, i) => `<a href="${c.url}">[${i + 1}]</a>`).join(", "));
-}
-// Confidence thresholds
-const SKIP = 0.6;
-const UNCERTAIN = 0.75;
-const CERTAIN = 0.95;
-function qualDisplay(qual, qualNum, conf) {
-    if (qual === null)
-        return null;
-    if (qual === "none")
-        return conf >= CERTAIN ? "нет" : null;
-    const map = {
-        all: "все",
-        most: "большинство",
-        many: "много",
-        few: "несколько",
-        exists: "есть",
-        none: "нет",
-        more_than: qualNum != null ? `>${qualNum}` : ">1",
-        less_than: qualNum != null ? `<${qualNum}` : "<нескольких",
+        language: config.language,
     };
-    return map[qual];
-}
-function breakdownItem(label, num, qual, qualNum, conf) {
-    if (conf < SKIP)
-        return null;
-    const u = conf < UNCERTAIN ? " (?)" : "";
-    if (num !== null)
-        return `${label} — ${num}${u}`;
-    const qs = qualDisplay(qual, qualNum, conf);
-    if (qs === null)
-        return null;
-    return `${label} — ${qs}${u}`;
-}
-/**
- * Build enrichment data from current vote + previous enrichment (carry-forward).
- * Returns updated EnrichmentData for Redis persistence.
- */
-function buildEnrichmentFromVote(r, prev, alertType, alertTs) {
-    const data = { ...prev };
-    // Origin — update if voted has it
-    if (r.country_origins && r.country_origins.length > 0) {
-        data.origin = r.country_origins
-            .map((c) => COUNTRY_RU[c.name] ?? c.name)
-            .join(" + ");
-        data.originCites = r.country_origins.flatMap((c) => extractCites(c.citations, r.citedSources));
-    }
-    // ETA — only for early_warning/siren
-    if (r.eta_refined_minutes !== null &&
-        (alertType === "early_warning" || alertType === "siren")) {
-        const absTime = new Date(alertTs + r.eta_refined_minutes * 60_000).toLocaleTimeString("he-IL", {
-            hour: "2-digit",
-            minute: "2-digit",
-            timeZone: "Asia/Jerusalem",
-        });
-        data.etaAbsolute = `~${absTime}`;
-        data.etaCites = extractCites(r.eta_citations, r.citedSources);
-    }
-    // Rocket count
-    if (r.rocket_count_min !== null && r.rocket_count_max !== null) {
-        const u = r.rocket_confidence < UNCERTAIN ? " (?)" : "";
-        data.rocketCount =
-            r.rocket_count_min === r.rocket_count_max
-                ? `${r.rocket_count_min}${u}`
-                : `~${r.rocket_count_min}–${r.rocket_count_max}${u}`;
-        data.rocketCites = extractCites(r.rocket_citations, r.citedSources);
-    }
-    // Cassette
-    if (r.is_cassette !== null && r.is_cassette_confidence >= SKIP) {
-        data.isCassette = r.is_cassette;
-    }
-    // Intercepted
-    if (r.intercepted !== null && r.intercepted_confidence >= SKIP) {
-        const u = r.intercepted_confidence < UNCERTAIN ? " (?)" : "";
-        data.intercepted = `${r.intercepted}${u}`;
-        data.interceptedCites = extractCites(r.citedSources
-            .filter((s) => {
-            const ext = r.citedSources.find((cs) => cs.index === s.index);
-            return ext !== undefined;
-        })
-            .map((s) => s.index), r.citedSources);
-    }
-    else if (r.intercepted_qual !== null && r.intercepted_confidence >= SKIP) {
-        const qs = qualDisplay(r.intercepted_qual, r.intercepted_qual_num, r.intercepted_confidence);
-        if (qs)
-            data.intercepted = qs;
-    }
-    // Hits
-    if (r.hits_confirmed !== null &&
-        r.hits_confirmed > 0 &&
-        r.hits_confidence >= SKIP) {
-        const u = r.hits_confidence < UNCERTAIN ? " (?)" : "";
-        data.hitsConfirmed = `${r.hits_confirmed}${u}`;
-        data.hitsCites = extractCites(r.hits_citations, r.citedSources);
-    }
-    // Casualties
-    if (r.casualties !== null &&
-        r.casualties > 0 &&
-        r.casualties_confidence >= SKIP) {
-        const u = r.casualties_confidence < UNCERTAIN ? " (?)" : "";
-        data.casualties = `${r.casualties}${u}`;
-        data.casualtiesCites = extractCites(r.casualties_citations, r.citedSources);
-    }
-    // Injuries
-    if (r.injuries !== null && r.injuries > 0 && r.injuries_confidence >= SKIP) {
-        const u = r.injuries_confidence < UNCERTAIN ? " (?)" : "";
-        data.injuries = `${r.injuries}${u}`;
-        data.injuriesCites = extractCites(r.injuries_citations, r.citedSources);
-    }
-    // Early warning time — record when first early_warning was received
-    if (alertType === "early_warning" && !data.earlyWarningTime) {
-        data.earlyWarningTime = toIsraelTime(alertTs);
-    }
-    return data;
-}
-/**
- * Build the enriched message text from current message + enrichment data.
- * Uses inline [[1]](url) citations. No superscripts. No footer sources.
- */
-function buildEnrichedMessage(currentText, alertType, alertTs, enrichment) {
-    let text = currentText;
-    // ── Refine ETA in-place ──
-    if (enrichment.etaAbsolute &&
-        (alertType === "early_warning" || alertType === "siren")) {
-        const etaCiteStr = inlineCitesFromData(enrichment.etaCites);
-        const refined = `${enrichment.etaAbsolute}${etaCiteStr}`;
-        const etaPatterns = [
-            /~\d+[–-]\d+\s*мин/, // ~5–12 мин
-            /~\d+[–-]\d+\s*min/, // ~5–12 min
-            /~\d+[–-]\d+\s*דקות/, // ~5–12 דקות
-            /~\d+[–-]\d+\s*دقيقة/, // ~5–12 دقيقة
-            /1\.5\s*мин/, // 1.5 мин (siren)
-            /1\.5\s*min/,
-            /1\.5\s*דקות/,
-            /1\.5\s*دقيقة/,
-        ];
-        for (const pattern of etaPatterns) {
-            if (pattern.test(text)) {
-                text = text.replace(pattern, refined);
-                break;
-            }
-        }
-    }
-    // ── Siren: show "Раннее предупреждение: было в HH:MM" ──
-    if (alertType === "siren" && enrichment.earlyWarningTime) {
-        text = insertBeforeTimeLine(text, `<b>Раннее предупреждение:</b> было в ${enrichment.earlyWarningTime}`);
-    }
-    // ── Origin ──
-    if (enrichment.origin) {
-        const citeStr = inlineCitesFromData(enrichment.originCites);
-        text = insertBeforeTimeLine(text, `\n<b>Откуда:</b> ${enrichment.origin}${citeStr}`);
-    }
-    // ── Rocket count + breakdown ──
-    if (enrichment.rocketCount) {
-        const citeStr = inlineCitesFromData(enrichment.rocketCites);
-        const cassette = enrichment.isCassette ? ", есть кассетные" : "";
-        let breakdown = "";
-        const bParts = [];
-        if (enrichment.intercepted) {
-            bParts.push(`перехвачено — ${enrichment.intercepted}`);
-        }
-        if (enrichment.seaImpact) {
-            bParts.push(`упали в море — ${enrichment.seaImpact}`);
-        }
-        if (enrichment.openAreaImpact) {
-            bParts.push(`открытая местность — ${enrichment.openAreaImpact}`);
-        }
-        if (bParts.length > 0)
-            breakdown = `, из них: ${bParts.join(", ")}`;
-        text = insertBeforeTimeLine(text, `<b>Ракет:</b> ${enrichment.rocketCount}${breakdown}${cassette}${citeStr}`);
-    }
-    else if (enrichment.intercepted && alertType !== "early_warning") {
-        // No rocket count but have interception data
-        const citeStr = inlineCitesFromData(enrichment.interceptedCites);
-        text = insertBeforeTimeLine(text, `<b>Перехвачено:</b> ${enrichment.intercepted}${citeStr}`);
-    }
-    // ── Hits ──
-    if (enrichment.hitsConfirmed && alertType !== "early_warning") {
-        const areaLabel = Object.values(config.agent.areaLabels)[0] ?? "район";
-        const citeStr = inlineCitesFromData(enrichment.hitsCites);
-        text = insertBeforeTimeLine(text, `<b>Попадания (${areaLabel}):</b> ${enrichment.hitsConfirmed}${citeStr}`);
-    }
-    // ── Casualties / Injuries (resolved only) ──
-    if (enrichment.casualties && alertType === "resolved") {
-        const citeStr = inlineCitesFromData(enrichment.casualtiesCites);
-        text = insertBeforeTimeLine(text, `<b>Погибшие:</b> ${enrichment.casualties}${citeStr}`);
-    }
-    if (enrichment.injuries && alertType === "resolved") {
-        const citeStr = inlineCitesFromData(enrichment.injuriesCites);
-        text = insertBeforeTimeLine(text, `<b>Пострадавшие:</b> ${enrichment.injuries}${citeStr}`);
-    }
-    return text;
-}
-/**
- * Insert a line before the time line (last "Время" / "Time" / "שעת" line).
- */
-function insertBeforeTimeLine(text, line) {
-    const timePattern = /(<b>(?:Время оповещения|Alert time|שעת ההתרעה|وقت الإنذار):<\/b>)/;
-    const match = text.match(timePattern);
-    if (match?.index !== undefined) {
-        return text.slice(0, match.index) + line + "\n" + text.slice(match.index);
-    }
-    const lines = text.split("\n");
-    lines.splice(Math.max(lines.length - 1, 0), 0, line);
-    return lines.join("\n");
-}
-async function editMessage(state) {
-    const { votedResult } = state;
-    if (!config.botToken)
-        return {};
-    const tgBot = new Bot(config.botToken);
-    // No valid sources — carry forward previous data only
-    const prevEnrichment = state.previousEnrichment ?? emptyEnrichmentData();
-    if (!votedResult) {
-        // No new data from channels — still try to build message from carry-forward
-        if (prevEnrichment.origin || prevEnrichment.intercepted) {
-            // Have carry-forward data, build message
-            const newText = buildEnrichedMessage(state.currentText, state.alertType, state.alertTs, prevEnrichment);
-            const hash = textHash(newText);
-            if (hash === prevEnrichment.lastEditHash) {
-                logger.info("Agent: no change in message (dedup) — skipping edit", {
-                    alertId: state.alertId,
-                });
-                return {};
-            }
-            try {
-                if (state.isCaption) {
-                    await tgBot.api.editMessageCaption(state.chatId, state.messageId, {
-                        caption: newText,
-                        parse_mode: "HTML",
-                    });
-                }
-                else {
-                    await tgBot.api.editMessageText(state.chatId, state.messageId, newText, { parse_mode: "HTML" });
-                }
-                prevEnrichment.lastEditHash = hash;
-                await saveEnrichmentData(prevEnrichment);
-                logger.info("Agent: message enriched (carry-forward only)", {
-                    alertId: state.alertId,
-                    messageId: state.messageId,
-                });
-            }
-            catch (err) {
-                const errStr = String(err);
-                if (errStr.includes("message is not modified")) {
-                    prevEnrichment.lastEditHash = hash;
-                    await saveEnrichmentData(prevEnrichment);
-                    logger.info("Agent: message already up-to-date (dedup)", {
-                        alertId: state.alertId,
-                    });
-                }
-                else {
-                    logger.error("Agent: failed to edit message", {
-                        alertId: state.alertId,
-                        error: errStr,
-                    });
-                }
-            }
-        }
-        else {
-            logger.info("Agent: no voted result — skipping edit", {
-                alertId: state.alertId,
-            });
-        }
-        return {};
-    }
-    // Build enrichment data: merge vote + previous
-    const enrichment = buildEnrichmentFromVote(votedResult, prevEnrichment, state.alertType, state.alertTs);
-    const newText = buildEnrichedMessage(state.currentText, state.alertType, state.alertTs, enrichment);
-    // Dedup: skip if text hasn't changed
-    const hash = textHash(newText);
-    if (hash === enrichment.lastEditHash) {
-        logger.info("Agent: no change in message (dedup) — skipping edit", {
-            alertId: state.alertId,
-        });
-        return {};
-    }
-    // Low confidence: log but still show data with (?) markers
-    if (votedResult.confidence < config.agent.confidenceThreshold) {
-        logger.info("Agent: confidence below threshold — editing with (?) markers", {
-            alertId: state.alertId,
-            confidence: votedResult.confidence,
-            threshold: config.agent.confidenceThreshold,
-        });
-    }
-    try {
-        if (state.isCaption) {
-            await tgBot.api.editMessageCaption(state.chatId, state.messageId, {
-                caption: newText,
-                parse_mode: "HTML",
-            });
-        }
-        else {
-            await tgBot.api.editMessageText(state.chatId, state.messageId, newText, {
-                parse_mode: "HTML",
-            });
-        }
-        enrichment.lastEditHash = hash;
-        await saveEnrichmentData(enrichment);
-        logger.info("Agent: message enriched", {
+    const raw = await extractPosts(postsToExtract, ctx);
+    // Step 4: deterministic post-filter
+    const filtered = postFilter(raw, state.alertId);
+    // Update timestamp for next job's dedup split
+    await setLastUpdateTs(Date.now());
+    return { extractions: filtered };
+}
+// ── Node: vote ─────────────────────────────────────────
+function voteNode(state) {
+    return { votedResult: vote(state.extractions, state.alertId) };
+}
+// ── Node: clarify (MCP tool calling) ───────────────────
+async function clarifyNode(state) {
+    if (!state.votedResult) {
+        logger.info("Agent: clarify skipped — no voted result", {
             alertId: state.alertId,
-            messageId: state.messageId,
-            confidence: votedResult.confidence,
-            sources: votedResult.sources_count,
-            phase: state.alertType,
         });
-    }
-    catch (err) {
-        const errStr = String(err);
-        if (errStr.includes("message is not modified")) {
-            enrichment.lastEditHash = hash;
-            await saveEnrichmentData(enrichment);
-            logger.info("Agent: message already up-to-date (dedup)", {
-                alertId: state.alertId,
-            });
-        }
-        else {
-            logger.error("Agent: failed to edit message", {
-                alertId: state.alertId,
-                error: errStr,
-            });
-        }
-    }
-    return {};
-}
-// ─────────────────────────────────────────────────────────
-// Clarify Node — MCP tool calling via ReAct (conditional)
-// ─────────────────────────────────────────────────────────
-async function clarifyNode(state) {
-    const { votedResult, extractions, alertId, alertAreas, alertType, alertTs, messageId, currentText, } = state;
-    if (!votedResult) {
-        logger.info("Agent: clarify skipped — no voted result", { alertId });
         return { clarifyAttempted: true };
     }
     logger.info("Agent: clarify triggered", {
-        alertId,
-        confidence: votedResult.confidence,
-        threshold: config.agent.confidenceThreshold,
-        phase: alertType,
+        alertId: state.alertId,
+        confidence: state.votedResult.confidence,
     });
     try {
         const result = await runClarify({
-            alertId,
-            alertAreas,
-            alertType,
-            alertTs,
-            messageId,
-            currentText,
-            extractions,
-            votedResult,
-        });
-        const mergedExtractions = [...extractions, ...result.newExtractions];
-        logger.info("Agent: clarify completed", {
-            alertId,
-            toolCalls: result.toolCallCount,
-            clarified: result.clarified,
-            newExtractions: result.newExtractions.length,
-            newPosts: result.newPosts.length,
+            alertId: state.alertId,
+            alertAreas: state.alertAreas,
+            alertType: state.alertType,
+            alertTs: state.alertTs,
+            messageId: state.messageId,
+            currentText: state.currentText,
+            extractions: state.extractions,
+            votedResult: state.votedResult,
         });
         return {
-            extractions: mergedExtractions,
+            extractions: [...state.extractions, ...result.newExtractions],
             votedResult: null,
             clarifyAttempted: true,
         };
     }
     catch (err) {
         logger.error("Agent: clarify failed", {
-            alertId,
+            alertId: state.alertId,
             error: String(err),
         });
         return { clarifyAttempted: true };
     }
 }
+// ── Node: edit Telegram message ────────────────────────
+async function editNode(state) {
+    await editMessage({
+        alertId: state.alertId,
+        alertTs: state.alertTs,
+        alertType: state.alertType,
+        chatId: state.chatId,
+        messageId: state.messageId,
+        isCaption: state.isCaption,
+        currentText: state.currentText,
+        votedResult: state.votedResult,
+        previousEnrichment: state.previousEnrichment ?? emptyEnrichmentData(),
+    });
+    return {};
+}
 // ── Conditional routing after vote ─────────────────────
 function shouldClarify(state) {
     if (state.clarifyAttempted)
@@ -1140,29 +167,23 @@ function shouldClarify(state) {
         return "editMessage";
     if (!state.votedResult)
         return "editMessage";
-    // Low confidence → clarify (may use Oref tool for time validation)
     if (state.votedResult.confidence < config.agent.confidenceThreshold) {
         logger.info("Agent: routing to clarify (low confidence)", {
             confidence: state.votedResult.confidence,
-            threshold: config.agent.confidenceThreshold,
         });
         return "clarify";
     }
-    // Suspicious time: if the only country is unexpected for the region, verify
-    // This catches cases like "Lebanon" appearing on a Tel Aviv alert
-    // when the real attack is from Iran/Yemen
+    // Suspicious single-source: Lebanon for central Israel → verify
     const origins = state.votedResult.country_origins;
     if (origins &&
         origins.length === 1 &&
         state.votedResult.sources_count === 1) {
-        const singleOrigin = origins[0].name;
-        // Lebanon attacks typically don't reach central Israel
-        if (singleOrigin === "Lebanon" &&
+        if (origins[0].name === "Lebanon" &&
             state.alertAreas.some((a) => a.includes("תל אביב") ||
                 a.includes("גוש דן") ||
                 a.includes("שרון") ||
                 a.includes("מרכז"))) {
-            logger.info("Agent: routing to clarify (suspicious single source: Lebanon for central Israel)", { origin: singleOrigin });
+            logger.info("Agent: routing to clarify (suspicious Lebanon origin)", {});
             return "clarify";
         }
     }
@@ -1171,30 +192,27 @@ function shouldClarify(state) {
 // ── Build graph ────────────────────────────────────────
 const checkpointer = new MemorySaver();
 function buildGraph() {
-    const graph = new StateGraph(AgentState)
-        .addNode("collectAndPreFilter", collectAndPreFilter)
-        .addNode("extractAndValidate", extractAndValidate)
-        .addNode("postFilter", postFilter)
-        .addNode("vote", vote)
+    return new StateGraph(AgentState)
+        .addNode("collectAndFilter", collectAndFilter)
+        .addNode("extract", extractNode)
+        .addNode("vote", voteNode)
         .addNode("clarify", clarifyNode)
-        .addNode("revote", vote)
-        .addNode("editMessage", editMessage)
-        .addEdge("__start__", "collectAndPreFilter")
-        .addEdge("collectAndPreFilter", "extractAndValidate")
-        .addEdge("extractAndValidate", "postFilter")
-        .addEdge("postFilter", "vote")
+        .addNode("revote", voteNode)
+        .addNode("editMessage", editNode)
+        .addEdge("__start__", "collectAndFilter")
+        .addEdge("collectAndFilter", "extract")
+        .addEdge("extract", "vote")
         .addConditionalEdges("vote", shouldClarify, {
         clarify: "clarify",
         editMessage: "editMessage",
     })
         .addEdge("clarify", "revote")
         .addEdge("revote", "editMessage")
-        .addEdge("editMessage", "__end__");
-    return graph.compile({ checkpointer });
+        .addEdge("editMessage", "__end__")
+        .compile({ checkpointer });
 }
 export async function runEnrichment(input) {
-    const app = buildGraph();
-    await app.invoke({
+    await buildGraph().invoke({
         alertId: input.alertId,
         alertTs: input.alertTs,
         alertType: input.alertType,
@@ -1203,37 +221,11 @@ export async function runEnrichment(input) {
         messageId: input.messageId,
         isCaption: input.isCaption,
         currentText: input.currentText,
-        channelPosts: [],
-        filteredPosts: [],
+        tracking: null,
         extractions: [],
         votedResult: null,
         clarifyAttempted: false,
         previousEnrichment: emptyEnrichmentData(),
-        sessionStartTs: 0,
-        phaseStartTs: 0,
     }, { configurable: { thread_id: input.alertId } });
 }
-// ── Exported for testing ───────────────────────────────
-export const _test = {
-    getLLM,
-    buildRegionKeywords,
-    LAUNCH_KEYWORDS,
-    TIME_WINDOW_MS,
-    toIsraelTime,
-    textHash,
-    postFilter,
-    vote,
-    buildEnrichmentFromVote,
-    buildEnrichedMessage,
-    insertBeforeTimeLine,
-    inlineCites,
-    inlineCitesFromData,
-    extractCites,
-    COUNTRY_RU,
-    SYSTEM_PROMPT_BASE,
-    getPhaseInstructions,
-    SKIP,
-    UNCERTAIN,
-    CERTAIN,
-};
 //# sourceMappingURL=graph.js.map