"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.sanitizeAssistantReplyForUserFacing = sanitizeAssistantReplyForUserFacing;
exports.composeAssistantAnswer = composeAssistantAnswer;
function fallbackFromSummary(routeSummary) {
    if (!routeSummary || routeSummary.mode !== "deterministic_v2") {
        return "none";
    }
    return routeSummary.fallback.type;
}
function uniqueStrings(values, limit = 6) {
    return Array.from(new Set(values.map((item) => item.trim()).filter(Boolean))).slice(0, limit);
}
function withUniquePush(target, value) {
    const normalized = String(value ?? "").trim();
    if (!normalized) {
        return;
    }
    if (!target.includes(normalized)) {
        target.push(normalized);
    }
}
function normalizeAnchorForMatch(value) {
    return String(value ?? "")
        .toLowerCase()
        .replace(/[^\p{L}\p{N}.:/-]+/gu, " ")
        .replace(/\s+/g, " ")
        .trim();
}
function collectCompanyAnchorTokens(anchors) {
    if (!anchors) {
        return [];
    }
    const tokens = [];
    for (const item of anchors.contract_numbers ?? [])
        withUniquePush(tokens, item);
    for (const item of anchors.document_numbers ?? [])
        withUniquePush(tokens, item);
    for (const item of anchors.dates ?? [])
        withUniquePush(tokens, item);
    for (const item of anchors.amounts ?? [])
        withUniquePush(tokens, item);
    for (const item of anchors.accounts ?? [])
        withUniquePush(tokens, `\u0441\u0447\u0435\u0442 ${item}`);
    for (const item of anchors.accounts ?? [])
        withUniquePush(tokens, item);
    for (const item of anchors.periods ?? [])
        withUniquePush(tokens, item);
    for (const item of anchors.document_types ?? [])
        withUniquePush(tokens, item);
    for (const item of anchors.all ?? [])
        withUniquePush(tokens, item);
    return uniqueStrings(tokens, 48);
}
function collectRetrievalCorpus(results) {
    const chunks = [];
    for (const result of results) {
        chunks.push(JSON.stringify(result.summary ?? {}));
        for (const item of result.items.slice(0, 10)) {
            chunks.push(JSON.stringify(item));
        }
        for (const evidence of result.evidence.slice(0, 16)) {
            chunks.push(JSON.stringify(evidence));
        }
        chunks.push(...result.why_included.slice(0, 16));
        chunks.push(...result.selection_reason.slice(0, 16));
        chunks.push(...result.business_interpretation.slice(0, 16));
    }
    return chunks.join(" ").toLowerCase();
}
function isAnchorMatchedInCorpus(anchor, corpus) {
    const normalized = normalizeAnchorForMatch(anchor);
    if (!normalized) {
        return false;
    }
    if (normalized.length < 3) {
        return false;
    }
    if (corpus.includes(normalized)) {
        return true;
    }
    const withoutPrefix = normalized
        .replace(/^(?:\u0434\u043e\u0433\u043e\u0432\u043e\u0440|document|account|period|doc_type)\s*[:№#]?\s*/iu, "")
        .trim();
    if (withoutPrefix.length >= 3 && corpus.includes(withoutPrefix)) {
        return true;
    }
    if (/^\d+(?:[.,]\d{2})?$/.test(withoutPrefix)) {
        const normalizedAmount = withoutPrefix.replace(",", ".");
        return corpus.includes(withoutPrefix) || corpus.includes(normalizedAmount);
    }
    return false;
}
function evaluateCompanyAnchorUsage(anchors, retrievalResults) {
    const present = collectCompanyAnchorTokens(anchors);
    if (present.length === 0) {
        return {
            present: [],
            used: [],
            unused: []
        };
    }
    const corpus = normalizeAnchorForMatch(collectRetrievalCorpus(retrievalResults));
    const used = [];
    const unused = [];
    for (const anchor of present) {
        if (isAnchorMatchedInCorpus(anchor, corpus)) {
            withUniquePush(used, anchor);
        }
        else {
            withUniquePush(unused, anchor);
        }
    }
    return {
        present: uniqueStrings(present, 24),
        used: uniqueStrings(used, 12),
        unused: uniqueStrings(unused, 12)
    };
}
const UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
const LONG_HEX_PATTERN = /\b[0-9a-f]{24,}\b/gi;
const RAW_REF_BLOB_PATTERN = /\bevidence_source_ref_v1\|[^\s,;]+/gi;
const RAW_REF_TOKEN_PATTERN = /\b(?:source_ref|canonical_ref|entity_id|fragment_id|guid|uuid)\b/gi;
const SYNTHETIC_PLACEHOLDER_PATTERN = /\bunknown_entity(?::[^\s,;]+)?\b/gi;
const SYNTHETIC_FALLBACK_MARKER_PATTERN = /\b(?:unknown_source|unknown_record)\b/gi;
const SYNTHETIC_ROUTE_TOKEN_PATTERN = /\bbatch_refresh_then_store:[^\s,;]+/gi;
const CYRILLIC_MOJIBAKE_FRAGMENT_PATTERN = /(?:[\u0420\u0421][\u0080-\u04FF\u2000-\u20CF]){2,}/u;
const LATIN_MOJIBAKE_FRAGMENT_PATTERN = /(?:[\u00D0\u00D1][\u0080-\u00FF]){2,}/u;
const SHORT_CYRILLIC_MOJIBAKE_TOKEN_PATTERN = /^[\u0420\u0421][\u0080-\u04FF\u2000-\u20CF]{1,2}$/u;
const PREFIXED_SHORT_CYRILLIC_MOJIBAKE_TOKEN_PATTERN = /^[\p{L}\p{N}_-]+[\u0420\u0421][\u0080-\u04FF\u2000-\u20CF]{1,2}$/u;
const MOJIBAKE_SINGLE_MARKER_PATTERN = /^[\u0420\u0421\u00D0\u00D1]$/u;
const MOJIBAKE_MARKER_CHAR_PATTERN = /[\u0402\u0403\u040A\u040C\u040E\u040F\u0452\u0453\u0459\u045A\u045C\u045E\u045F\u201A\u201E\u2020\u2021\u2026\u2030\u20AC\u2122]/u;
const CYRILLIC_MOJIBAKE_FRAGMENT_GLOBAL_PATTERN = /(?:[\u0420\u0421][\u0080-\u04FF\u2000-\u20CF]){2,}/gu;
const LATIN_MOJIBAKE_FRAGMENT_GLOBAL_PATTERN = /(?:[\u00D0\u00D1][\u0080-\u00FF]){2,}/g;
const MOJIBAKE_MARKER_CHAR_GLOBAL_PATTERN = /[\u0402\u0403\u040A\u040C\u040E\u040F\u0452\u0453\u0459\u045A\u045C\u045E\u045F\u201A\u201E\u2020\u2021\u2026\u2030\u20AC\u2122]/gu;
const INTERNAL_DEBUG_LINE_PATTERNS = [
    /\bgraph traversal mode\b/i,
    /\bplanner mode\b/i,
    /\bsemantic_only\b/i,
    /\btyped_domain_path\b/i,
    /\bmatched=\d+\s*\/\s*\d+\b/i,
    /\bdomain\/document\/relation\b/i,
    /\baccount_scope\b/i,
    /\bdomain_scope\b/i,
    /\bdocument_types\b/i,
    /\brelation_patterns\b/i,
    /\banomaly_patterns\b/i,
    /\bsemantic retrieval profile\b/i,
    /\bsemantic profile\b/i,
    /\bgraph signal counts?\b/i,
    /\bgraph ranking signals?\b/i,
    /\broute_focus\b/i,
    /\bcross_entity_breakage\b/i,
    /\bnarrowing\s+\d+\s+\d+\b/i,
    /\breference-mode\b/i,
    /\bbasis:\s*(?:closure_risk|repeatability|financial_impact)\b/i,
    /\bgraph_runtime_(?:enabled|signals?|summary)\b/i,
    /\bgraph_(?:eligible|traversal|domain_scope|match_hits|traversal_score|signal_counts|ranking_shift_signals)\b/i,
    /\bdomain\s+purity\s+guardrail\b/i,
    /\bdebug_payload_json\b/i,
    /\bdebug_payload\b/i,
    /^\s*```json\s*$/i,
    /^\s*```\s*$/i,
    /\btechnical_breakdown_json\b/i,
    /\b(?:coverage_report|retrieval_status|problem_unit_state)\b/i
];
const USER_FACING_LEAKAGE_PATTERNS = [
    /\bgraph_[a-z0-9_]+\b/i,
    /\bdomain_scope\b/i,
    /\brelation_patterns\b/i,
    /\baccount_scope\b/i,
    /\bsemantic_profile\b/i,
    /\bsemantic\s+retrieval\s+profile\b/i,
    /\broute(?:_hint|_focus)?\b/i,
    /\b(?:store_canonical|hybrid_store_plus_live|deterministic_v2|typed_domain_path|semantic_only)\b/i,
    /\b(?:problem_unit|candidate_evidence|raw_entities|graph_binding|graph_node_id|relation_path)\b/i,
    /\b(?:missing_transition|conflicting_transition|terminal_state_gap|wrong_closing_document_type)\b/i,
    /\b(?:expected_transition_not_observed|stale_active_state|misclosed_state|cross_branch_state_conflict)\b/i,
    /\b(?:document|catalog|accumulationregister|register)_[a-z0-9_:-]+\b/i,
    /\b(?:domain|state|missing):[a-z0-9_><:-]+\b/i,
    /\b(?:lifecycle_domain|lifecycle_defect_type|lifecycle_ranking_basis)\b/i,
    /\bdomain\s+purity\s+guardrail\b/i,
    /\bdebug_payload_json\b/i,
    /\bdebug_payload\b/i,
    /\btechnical_breakdown_json\b/i,
    /\b(?:coverage_report|retrieval_status|problem_unit_state|requirements_(?:covered|uncovered|partially_covered))\b/i,
    /\b(?:lifecycle_anomaly_node|unresolved_settlement_cluster|period_risk_cluster|cross_branch_inconsistency_cluster|broken_chain_segment)\b/i,
    /\b(?:bank_settlement|customer_settlement|deferred_expense|vat_flow|period_close|fixed_asset)\b/i
];
const TECHNICAL_TOKEN_PATTERN = /^[a-z0-9_:-]+$/i;
const TECHNICAL_GRAPH_TOKEN_PATTERN = /(?:^|_)(?:graph|domain|relation|signal|pattern|profile|scope)(?:_|$)/i;
const TECHNICAL_INTERNAL_TOKEN_PATTERN = /(?:^|_)(?:risk|closure|lifecycle|anomaly|transition|link|mismatch|posting|narrowing|ranking)(?:_|$)/i;
const HUMAN_SIGNAL_MAP = {
    lifecycle_anomaly_node_detected: "Выявлен признак незавершенного этапа в учетной цепочке.",
    cross_branch_inconsistency_cluster_detected: "Выявлен конфликт состояния между связанными ветками цепочки.",
    broken_chain_segment_detected: "Выявлен разрыв связанной цепочки операций.",
    missing_transition: "Ожидаемый закрывающий переход не подтвержден.",
    expected_transition_not_observed: "Ожидаемый переход к следующему этапу не подтвержден.",
    conflicting_transition: "Есть конфликт состояния между связанными участками цепочки.",
    terminal_state_gap: "Контур дошел почти до завершения, но финальный шаг не подтвержден.",
    wrong_closing_document_type: "Закрытие похоже выполнено неподходящим типом документа.",
    missing_link: "Часть обязательных связей между документами и проводками не подтверждена.",
    broken_lifecycle: "Контур операций выглядит незавершенным.",
    posting_mismatch: "Документ и проводка расходятся по состоянию.",
    cross_domain_inconsistency: "Между связанными участками учета есть конфликт состояния.",
    closure_risk: "Разрыв может мешать закрытию периода и сверке.",
    repeated_anomaly: "Паттерн повторяется и похож на системную проблему.",
    amount_independent_risk: "Проблема не выглядит случайной суммовой погрешностью.",
    wrong_document_type: "Есть признак неверного типа закрывающего документа.",
    fixed_asset_card_mismatch: "Есть несоответствие между карточкой ОС, документом движения и начислением.",
    contradictory_asset_state: "Состояние объекта ОС выглядит противоречивым по текущей опоре.",
    disposed: "Есть признак выбытия объекта ОС в цепочке состояния.",
    invalid_document_or_posting_transition: "Переход состояния ОС не подтвержден документами и проводками.",
    asset_card_to_depreciation: "Переход от карточки ОС к начислению амортизации подтвержден не полностью.",
    supplier_tail_analysis: "Есть признаки незавершенного расчетного контура по поставщикам.",
    cross_entity_breakage: "Есть разрыв между связанными объектами в одной цепочке.",
    deferred_expense_to_writeoff: "Ожидаемая цепочка списания РБП выглядит незавершенной.",
    overdue_writeoff: "объект завис в просроченном состоянии списания",
    fully_written_off: "полное списание",
    unknown_snapshot_window: "точный интервал зависания не определен в текущем snapshot",
    broken_chain_segment: "Есть разрыв цепочки: ожидаемое закрытие операции не подтверждено.",
    unresolved_settlement_cluster: "По расчетам остался незавершенный хвост.",
    period_risk_cluster: "Есть признак сбоя в контуре закрытия месяца.",
    lifecycle_anomaly_node: "Операция зависла в промежуточном состоянии.",
    document_conflict: "Между документами и проводками есть расхождение.",
    cross_branch_inconsistency_cluster: "Есть конфликт между связанными ветками учета.",
    "failed_edge:payment_to_settlement": "Оплата отражена, но ожидаемое закрытие расчета не подтверждено.",
    payment_to_settlement: "Переход от оплаты к закрытию расчета не подтвержден.",
    missing_expected_transition: "Ожидаемый переход в учетной цепочке не подтвержден.",
    stale_unlinked_payment: "Оплата зависла без подтвержденного закрытия расчета.",
    settlement_closed: "расчет закрыт",
    recognized: "признано в учете",
    partially_written_off: "частично списано",
    period_boundary_exceeded: "срок перехода по цепочке превышен"
};
function isInternalDebugLikeLine(value) {
    const text = String(value ?? "").trim();
    if (!text) {
        return false;
    }
    return INTERNAL_DEBUG_LINE_PATTERNS.some((pattern) => pattern.test(text));
}
function hasUserFacingLeakage(value) {
    const text = String(value ?? "").trim();
    if (!text) {
        return false;
    }
    if (isInternalDebugLikeLine(text)) {
        return true;
    }
    return USER_FACING_LEAKAGE_PATTERNS.some((pattern) => pattern.test(text));
}
function normalizeTechnicalToken(value) {
    return String(value ?? "")
        .trim()
        .toLowerCase()
        .replace(/[^\p{L}\p{N}_:-]+/gu, "_")
        .replace(/_+/g, "_")
        .replace(/^_+|_+$/g, "");
}
function humanizeTechnicalToken(value) {
    const normalized = normalizeTechnicalToken(value);
    if (!normalized) {
        return null;
    }
    if (Object.prototype.hasOwnProperty.call(HUMAN_SIGNAL_MAP, normalized)) {
        return HUMAN_SIGNAL_MAP[normalized];
    }
    if (TECHNICAL_TOKEN_PATTERN.test(normalized) && (TECHNICAL_GRAPH_TOKEN_PATTERN.test(normalized) || TECHNICAL_INTERNAL_TOKEN_PATTERN.test(normalized))) {
        return null;
    }
    if (/_/.test(normalized) && TECHNICAL_TOKEN_PATTERN.test(normalized)) {
        return null;
    }
    return null;
}
function toStringList(value) {
    if (!Array.isArray(value)) {
        return [];
    }
    return value
        .map((item) => String(item ?? "").trim())
        .filter((item) => item.length > 0);
}
function collectGraphCausalInsight(results) {
    let hasChainResult = false;
    let hasMissingTransition = false;
    let hasConflictingTransition = false;
    let hasTerminalGap = false;
    let hasWrongClosingType = false;
    let hasNeighborBranchLifting = false;
    let hasPeriodCloseImpact = false;
    const domains = new Set();
    for (const result of results) {
        if (result.result_type !== "chain" || (result.status !== "ok" && result.status !== "partial")) {
            continue;
        }
        hasChainResult = true;
        const summaryGraphTraversal = summaryValue(result, "graph_traversal");
        if (summaryGraphTraversal && typeof summaryGraphTraversal === "object") {
            const traversal = summaryGraphTraversal;
            for (const domain of toStringList(traversal.target_domains)) {
                domains.add(domain);
                if (domain === "period_close") {
                    hasPeriodCloseImpact = true;
                }
            }
            const rankingSignals = toStringList(traversal.ranking_shift_signals);
            if (rankingSignals.includes("neighbor_branch_lifting")) {
                hasNeighborBranchLifting = true;
            }
            const signalCounts = traversal.signal_counts;
            if (signalCounts && typeof signalCounts === "object") {
                const counts = signalCounts;
                const missingCount = Number(counts.missing_transition ?? 0);
                const conflictCount = Number(counts.conflicting_transition ?? 0);
                const terminalCount = Number(counts.terminal_state_gap ?? 0);
                const wrongTypeCount = Number(counts.wrong_closing_document_type ?? 0);
                if (missingCount > 0) {
                    hasMissingTransition = true;
                }
                if (conflictCount > 0) {
                    hasConflictingTransition = true;
                }
                if (terminalCount > 0) {
                    hasTerminalGap = true;
                }
                if (wrongTypeCount > 0) {
                    hasWrongClosingType = true;
                }
            }
        }
        for (const item of result.items.slice(0, 4)) {
            for (const signal of toStringList(item.graph_runtime_signals)) {
                if (signal === "missing_transition") {
                    hasMissingTransition = true;
                }
                if (signal === "conflicting_transition") {
                    hasConflictingTransition = true;
                }
                if (signal === "terminal_state_gap") {
                    hasTerminalGap = true;
                }
                if (signal === "wrong_closing_document_type") {
                    hasWrongClosingType = true;
                }
            }
            for (const domain of toStringList(item.graph_domain_scope)) {
                domains.add(domain);
                if (domain === "period_close") {
                    hasPeriodCloseImpact = true;
                }
            }
            for (const risk of toStringList(item.risk_factors)) {
                if (risk === "closure_risk") {
                    hasPeriodCloseImpact = true;
                }
            }
        }
    }
    const strongSignalHits = Number(hasMissingTransition) + Number(hasConflictingTransition) + Number(hasTerminalGap) + Number(hasWrongClosingType);
    return {
        active: hasChainResult && (hasMissingTransition || hasConflictingTransition || hasTerminalGap || hasWrongClosingType || hasNeighborBranchLifting),
        has_missing_transition: hasMissingTransition,
        has_conflicting_transition: hasConflictingTransition,
        has_terminal_gap: hasTerminalGap,
        has_wrong_closing_type: hasWrongClosingType,
        has_neighbor_branch_lifting: hasNeighborBranchLifting,
        has_period_close_impact: hasPeriodCloseImpact,
        looks_systemic: strongSignalHits >= 2 || hasNeighborBranchLifting,
        domains: Array.from(domains)
    };
}
function buildGraphProblemFirstLead(insight, scopeLabel) {
    if (!insight.active) {
        return scopeLabel === "full"
            ? "Коротко: запрос обработан по доступной опоре, явные проблемные разрывы подтверждены выборочно."
            : "Коротко: есть подтвержденные сигналы, но часть вывода остается ограниченной.";
    }
    const causes = [];
    if (insight.has_missing_transition) {
        causes.push("подтверждено движение по контуру, но закрывающий переход не подтвержден");
    }
    if (insight.has_conflicting_transition) {
        causes.push("между связанными участками есть конфликт состояния");
    }
    if (insight.has_terminal_gap) {
        causes.push("цепочка дошла почти до финала, но последний шаг не зафиксирован");
    }
    if (insight.has_wrong_closing_type) {
        causes.push("закрытие похоже выполнено неверным типом документа");
    }
    const causeText = causes.length > 0 ? causes.join("; ") : "виден разрыв в связанной цепочке операций";
    return `Коротко: есть признаки реальной проблемы в связанном контуре - ${causeText}.`;
}
function buildGraphCausalLines(insight) {
    if (!insight.active) {
        return [];
    }
    const lines = [];
    if (insight.has_neighbor_branch_lifting) {
        lines.push("Проблема проявляется не внутри одного документа, а между связанными ветками цепочки.");
    }
    if (insight.has_period_close_impact) {
        lines.push("Такой разрыв может мешать закрытию периода и итоговой сверке.");
    }
    if (insight.looks_systemic) {
        lines.push("Это больше похоже на реальную проблему, чем на случайный хвост.");
    }
    else {
        lines.push("Сигнал пока слабый: часть признаков может быть шумом, нужна точечная проверка.");
    }
    return lines;
}
function buildGraphFirstChecks(insight) {
    if (!insight.active) {
        return [];
    }
    const checks = [];
    const hasSettlementDomain = insight.domains.includes("bank_settlement") ||
        insight.domains.includes("customer_settlement") ||
        insight.domains.includes("settlements");
    if (hasSettlementDomain) {
        checks.push("Сначала проверьте связку: документ оплаты -> закрывающий документ расчета -> проводка по расчетам.");
    }
    if (insight.domains.includes("deferred_expense")) {
        checks.push("Проверьте РБП-контур: документ признания -> документ списания -> проводка списания.");
    }
    if (insight.domains.includes("fixed_asset")) {
        checks.push("Проверьте ОС-контур: карточка объекта -> документ движения -> начисление амортизации.");
    }
    if (insight.domains.includes("vat_flow")) {
        checks.push("Проверьте НДС-контур: документ операции -> запись регистра -> проводка.");
    }
    if (insight.domains.includes("period_close")) {
        checks.push("Проверьте регламентную операцию закрытия периода и документы, которые она должна завершить.");
    }
    if (insight.has_conflicting_transition) {
        checks.push("Сверьте связанный контур в двух ветках: где одна ветка закрыта, а другая остается в промежуточном состоянии.");
    }
    return uniqueStrings(checks, 6);
}
function extractChainCausalFacts(result) {
    const topSignals = uniqueStrings(result.items
        .slice(0, 3)
        .flatMap((item) => toStringList(item.graph_runtime_signals)), 6);
    const topRiskFactors = uniqueStrings(result.items
        .slice(0, 3)
        .flatMap((item) => toStringList(item.risk_factors)), 6);
    const lines = [];
    if (topSignals.includes("missing_transition")) {
        lines.push("Оплата/движение зафиксированы, но ожидаемый закрывающий шаг не подтвержден.");
    }
    if (topSignals.includes("conflicting_transition")) {
        lines.push("Есть конфликт между связанными участками: состояния веток расходятся.");
    }
    if (topSignals.includes("terminal_state_gap")) {
        lines.push("Контур почти завершен, но финальный переход не подтвержден.");
    }
    if (topSignals.includes("wrong_closing_document_type") || topRiskFactors.includes("wrong_document_type")) {
        lines.push("Есть признак неверного типа закрывающего документа.");
    }
    if (topRiskFactors.includes("closure_risk")) {
        lines.push("Разрыв потенциально влияет на закрытие периода.");
    }
    if (lines.length === 0) {
        lines.push("Есть признаки незавершенной связки документов и проводок в связанном контуре.");
    }
    return lines;
}
function normalizeToken(value) {
    return value.replace(/^[^\p{L}\p{N}_-]+|[^\p{L}\p{N}_-]+$/gu, "");
}
function isLikelyMojibakeToken(value) {
    const token = normalizeToken(String(value ?? ""));
    if (!token) {
        return false;
    }
    if (MOJIBAKE_SINGLE_MARKER_PATTERN.test(token)) {
        return true;
    }
    if (SHORT_CYRILLIC_MOJIBAKE_TOKEN_PATTERN.test(token)) {
        return true;
    }
    if (token.length <= 8 && PREFIXED_SHORT_CYRILLIC_MOJIBAKE_TOKEN_PATTERN.test(token)) {
        return true;
    }
    return CYRILLIC_MOJIBAKE_FRAGMENT_PATTERN.test(token) || LATIN_MOJIBAKE_FRAGMENT_PATTERN.test(token);
}
function countMojibakeTokens(value) {
    return String(value ?? "")
        .split(/[\s,.;:!?()[\]{}"']+/g)
        .filter((token) => token.length > 0)
        .filter((token) => isLikelyMojibakeToken(token)).length;
}
function countMojibakeSingleMarkers(value) {
    return String(value ?? "")
        .split(/[\s,.;:!?()[\]{}"']+/g)
        .filter((token) => token.length > 0)
        .map((token) => normalizeToken(token))
        .filter((token) => MOJIBAKE_SINGLE_MARKER_PATTERN.test(token)).length;
}
function stripMojibakeFragments(value) {
    const removedByToken = String(value ?? "")
        .split(/(\s+)/g)
        .map((part) => {
        if (/^\s+$/u.test(part)) {
            return part;
        }
        return isLikelyMojibakeToken(part) ? "" : part;
    })
        .join("");
    return removedByToken
        .replace(CYRILLIC_MOJIBAKE_FRAGMENT_GLOBAL_PATTERN, "")
        .replace(LATIN_MOJIBAKE_FRAGMENT_GLOBAL_PATTERN, "")
        .replace(MOJIBAKE_MARKER_CHAR_GLOBAL_PATTERN, "")
        .replace(/\s+([,.;:!?])/g, "$1")
        .replace(/\s{2,}/g, " ")
        .trim();
}
function looksLikeMojibake(value) {
    const text = String(value ?? "");
    if (!text.trim()) {
        return false;
    }
    const tokenHits = countMojibakeTokens(text);
    const singleMarkers = countMojibakeSingleMarkers(text);
    if (tokenHits >= 2 || (tokenHits >= 1 && singleMarkers >= 1) || singleMarkers >= 3) {
        return true;
    }
    if (MOJIBAKE_MARKER_CHAR_PATTERN.test(text)) {
        return true;
    }
    if (CYRILLIC_MOJIBAKE_FRAGMENT_PATTERN.test(text) || LATIN_MOJIBAKE_FRAGMENT_PATTERN.test(text)) {
        return true;
    }
    if (/\uFFFD/u.test(text)) {
        return true;
    }
    return false;
}
function looksLikeTechnicalIdentifier(value) {
    const text = String(value ?? "").trim();
    if (!text) {
        return false;
    }
    if (UUID_PATTERN.test(text)) {
        UUID_PATTERN.lastIndex = 0;
        return true;
    }
    UUID_PATTERN.lastIndex = 0;
    if (LONG_HEX_PATTERN.test(text)) {
        LONG_HEX_PATTERN.lastIndex = 0;
        return true;
    }
    LONG_HEX_PATTERN.lastIndex = 0;
    return /(?:evidence_source_ref_v1\||cmp%3a|batch_refresh_then_store:|^cmp:)/i.test(text);
}
function scrubRawTechnicalRefs(value) {
    const raw = String(value ?? "").trim();
    if (!raw) {
        return "";
    }
    return raw
        .replace(RAW_REF_BLOB_PATTERN, "linked source")
        .replace(UUID_PATTERN, "[id]")
        .replace(LONG_HEX_PATTERN, "[id]")
        .replace(RAW_REF_TOKEN_PATTERN, "reference")
        .replace(/\(\s*\[id\]\s*\)/g, "")
        .replace(/\[\s*id\s*\](?:\s*,\s*\[\s*id\s*\])+/g, "[id]")
        .replace(/[ \t]{2,}/g, " ")
        .trim();
}
function stripSyntheticPlaceholders(value) {
    return String(value ?? "")
        .replace(SYNTHETIC_PLACEHOLDER_PATTERN, "")
        .replace(SYNTHETIC_FALLBACK_MARKER_PATTERN, "")
        .replace(SYNTHETIC_ROUTE_TOKEN_PATTERN, "")
        .replace(/[;,:]\s*[;,:]+/g, "; ")
        .replace(/\s{2,}/g, " ")
        .trim();
}
function sanitizeUserFacingReply(value) {
    const raw = String(value ?? "");
    const hardCutMatch = raw.match(/(?:^|\n)\s*#{0,6}\s*(?:debug_payload_json|technical_breakdown_json|technical_debug_payload_json)\b/i);
    const preCut = hardCutMatch ? raw.slice(0, hardCutMatch.index) : raw;
    const withoutDebugBlocks = preCut
        .replace(/###\s*debug_payload_json[\s\S]*?(?:```[\s\S]*?```|$)/gi, "")
        .replace(/###\s*technical_debug_payload_json[\s\S]*?(?:```[\s\S]*?```|$)/gi, "")
        .replace(/###\s*technical_breakdown_json[\s\S]*?(?:```[\s\S]*?```|$)/gi, "")
        .replace(/(?:^|\n)\s*#{0,6}\s*(?:debug_payload_json|technical_breakdown_json|technical_debug_payload_json)\b[\s\S]*$/gi, "")
        .replace(/```json[\s\S]*?```/gi, "");
    const normalized = scrubRawTechnicalRefs(withoutDebugBlocks).replace(/[ \t]+\n/g, "\n");
    const preparedLines = normalized
        .split(/\r?\n/g)
        .map((line) => stripSyntheticPlaceholders(line))
        .map((line) => stripMojibakeFragments(line))
        .map((line) => line.trim());
    const cleanedLines = [];
    let previousWasBlank = false;
    for (const line of preparedLines) {
        if (line.length === 0) {
            if (!previousWasBlank && cleanedLines.length > 0) {
                cleanedLines.push("");
            }
            previousWasBlank = true;
            continue;
        }
        if (/^(?:-\s*)?(?:action|clarify|open|limit|note):\s*$/i.test(line)) {
            continue;
        }
        if (hasUserFacingLeakage(line)) {
            continue;
        }
        if (looksLikeMojibake(line)) {
            continue;
        }
        cleanedLines.push(line);
        previousWasBlank = false;
    }
    while (cleanedLines.length > 0 && cleanedLines[0] === "") {
        cleanedLines.shift();
    }
    while (cleanedLines.length > 0 && cleanedLines[cleanedLines.length - 1] === "") {
        cleanedLines.pop();
    }
    const cleaned = cleanedLines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
    return cleaned || "Available data requires clarification for a reliable user-facing answer.";
}
function sanitizeUserText(value) {
    const normalized = stripMojibakeFragments(stripSyntheticPlaceholders(scrubRawTechnicalRefs(String(value ?? "").replace(/\s+/g, " ").trim())));
    if (!normalized) {
        return null;
    }
    if (hasUserFacingLeakage(normalized)) {
        return null;
    }
    if (looksLikeMojibake(normalized)) {
        return null;
    }
    return normalized;
}
function sanitizeUserLines(values, limit = 6) {
    const cleaned = values
        .map((item) => sanitizeUserText(item))
        .filter((item) => Boolean(item))
        .filter((item) => !isInternalDebugLikeLine(item));
    return uniqueStrings(cleaned, limit);
}
function formatList(items) {
    if (items.length === 0) {
        return "";
    }
    return items.map((item) => `- ${item}`).join("\n");
}
function renderStage4ContractReply(input) {
    const shortLine = ensureSentence(input.shortLine);
    const checkedLines = dedupeNarrativeLines(input.checkedLines, 6);
    const foundLines = dedupeNarrativeLines(input.foundLines, 6);
    const unresolvedLines = dedupeNarrativeLines(input.unresolvedLines, 6);
    const nextStepLines = dedupeNarrativeLines(input.nextStepLines, 5);
    const contextLead = ensureSentence(String(input.contextLead ?? ""));
    return sanitizeUserFacingReply([
        `Коротко: ${shortLine}`,
        contextLead || "",
        `Что именно проверено:\n${formatList(checkedLines.length > 0
            ? checkedLines
            : ["Подтвержденная опора собрана частично; для полного вывода нужен дополнительный проход."])}`,
        `Что найдено:\n${formatList(foundLines.length > 0 ? foundLines : ["Явные отклонения по текущей опоре не подтверждены."])}`,
        `Что пока не доказано:\n${formatList(unresolvedLines.length > 0
            ? unresolvedLines
            : ["Существенных ограничений в текущем срезе не выявлено."])}`,
        `${input.nextStepTitle}:\n${formatList(nextStepLines.length > 0
            ? nextStepLines
            : ["Уточните период, объект или контрагента, чтобы продолжить проверку по 1С."])}`
    ]
        .filter(Boolean)
        .join("\n\n"));
}
function formatSafeItemLine(entity, sourceId, riskScore) {
    const entityLabel = sanitizeUserText(String(entity ?? "")) ?? "Record";
    const idRaw = String(sourceId ?? "").trim();
    const exposeId = idRaw.length > 0 && !looksLikeTechnicalIdentifier(idRaw);
    const subject = exposeId ? `${entityLabel} (${idRaw})` : entityLabel;
    if (riskScore !== undefined) {
        return `${subject} - risk ${String(riskScore)}.`;
    }
    return `${subject}.`;
}
function extractTopFacts(results) {
    const lines = [];
    for (const result of results.filter((item) => item.status === "ok").slice(0, 3)) {
        if (result.result_type === "chain") {
            const top = extractChainCausalFacts(result);
            lines.push(...top);
            continue;
        }
        if (result.result_type === "ranking") {
            const top = result.items
                .slice(0, 5)
                .map((item) => `${item.rank ?? "*"}. ${String(item.entity ?? "Entity")} - ${String(item.records_count ?? 0)}.`);
            lines.push(...top);
            continue;
        }
        if (result.result_type === "list") {
            const top = result.items.slice(0, 5).map((item) => {
                if (item.risk_score !== undefined) {
                    return formatSafeItemLine(item.source_entity ?? "Record", item.source_id ?? "", item.risk_score);
                }
                return formatSafeItemLine(item.source_entity ?? "Record", item.source_id ?? "");
            });
            lines.push(...top);
            continue;
        }
        const top = result.items
            .slice(0, 3)
            .map((item) => formatSafeItemLine(item.source_entity ?? "Record", item.source_id ?? ""));
        lines.push(...top);
    }
    return sanitizeUserLines(lines, 8);
}
function sanitizeSupportLine(value) {
    const raw = String(value ?? "").trim();
    if (!raw) {
        return null;
    }
    const mechanismMatch = raw.match(/^mechanism candidate:\s*(.+?)\.?$/i);
    if (mechanismMatch?.[1]) {
        const mechanismToken = mechanismMatch[1].trim();
        const mechanismHumanized = humanizeTechnicalToken(mechanismToken);
        if (mechanismHumanized) {
            return mechanismHumanized;
        }
    }
    const rawCore = raw.replace(/[.,;:!?]+$/g, "");
    const directHumanized = humanizeTechnicalToken(rawCore);
    if (directHumanized) {
        return directHumanized;
    }
    const cleaned = sanitizeUserText(raw);
    if (!cleaned) {
        return null;
    }
    const cleanedCore = cleaned.replace(/[.,;:!?]+$/g, "");
    const mapped = humanizeTechnicalToken(cleanedCore);
    if (mapped) {
        return mapped;
    }
    if (/^(?:lifecycle|domain|relation)\s+[a-z0-9_:-]+$/i.test(cleanedCore)) {
        return null;
    }
    if (TECHNICAL_TOKEN_PATTERN.test(cleanedCore) && /_/.test(cleanedCore)) {
        return null;
    }
    return cleaned;
}
function extractWhyIncluded(results) {
    return uniqueStrings(results
        .flatMap((item) => item.why_included)
        .map((line) => sanitizeSupportLine(line))
        .filter((line) => Boolean(line)), 8);
}
function extractSelectionReasons(results) {
    return uniqueStrings(results
        .flatMap((item) => item.selection_reason)
        .map((line) => sanitizeSupportLine(line))
        .filter((line) => Boolean(line)), 8);
}
function extractRiskFactors(results) {
    const mapped = results.flatMap((item) => item.risk_factors.flatMap((factor) => {
        const humanized = humanizeTechnicalToken(factor);
        if (humanized) {
            return [humanized];
        }
        const cleaned = sanitizeUserText(String(factor ?? ""));
        if (!cleaned) {
            return [];
        }
        if (TECHNICAL_TOKEN_PATTERN.test(cleaned) && /_/.test(cleaned)) {
            return [];
        }
        return [cleaned];
    }));
    return sanitizeUserLines(mapped);
}
function extractBusinessInterpretation(results) {
    return sanitizeUserLines(results.flatMap((item) => item.business_interpretation));
}
function extractLimitations(results) {
    return sanitizeUserLines(results.flatMap((item) => item.limitations), 10);
}
function summaryValue(result, key) {
    const summary = result.summary ?? {};
    return Object.prototype.hasOwnProperty.call(summary, key) ? summary[key] : undefined;
}
function summaryBoolean(result, key) {
    return summaryValue(result, key) === true;
}
function summaryString(result, key) {
    const value = summaryValue(result, key);
    return typeof value === "string" ? value : null;
}
function summaryNumber(result, key) {
    const value = summaryValue(result, key);
    return typeof value === "number" && Number.isFinite(value) ? value : null;
}
function summaryStringArray(result, key) {
    const value = summaryValue(result, key);
    if (!Array.isArray(value)) {
        return [];
    }
    return sanitizeUserLines(value.map((item) => String(item)), 6);
}
function buildFallbackWhyIncluded(results) {
    const lines = [];
    for (const result of results.slice(0, 2)) {
        const routeFocus = summaryString(result, "route_focus");
        const sourceRecords = summaryNumber(result, "source_records");
        const filteredRecords = summaryNumber(result, "filtered_records_after_narrowing");
        const checkedRecords = summaryNumber(result, "checked_records");
        if (routeFocus && !isInternalDebugLikeLine(routeFocus)) {
            lines.push(`Проверка выполнена по предметному фокусу: ${routeFocus}.`);
        }
        if (sourceRecords !== null && filteredRecords !== null && filteredRecords < sourceRecords) {
            lines.push(`Выборка сужена до ${filteredRecords} из ${sourceRecords} записей по условиям запроса.`);
        }
        if (checkedRecords !== null) {
            lines.push(`Проверено записей в текущем проходе: ${checkedRecords}.`);
        }
    }
    return sanitizeUserLines(lines, 4);
}
function buildFallbackSelectionReasons(results) {
    const lines = [];
    for (const result of results.slice(0, 2)) {
        if (summaryBoolean(result, "semantic_narrowing_applied")) {
            lines.push("Отбор выполнен по предметному сужению запроса.");
        }
        const rankingBasis = summaryStringArray(result, "ranking_basis");
        if (rankingBasis.length > 0) {
            lines.push("Ранжирование учитывает устойчивость разрыва, повторяемость и учетное влияние.");
        }
        if (summaryBoolean(result, "broad_guard_applied")) {
            lines.push("Для широкого запроса включен защитный режим против ложной точности.");
        }
    }
    if (lines.length === 0) {
        lines.push("Отбор выполнен по совпадению предметных сигналов с доступной опорой.");
    }
    return sanitizeUserLines(lines, 4);
}
function suggestNextStep(requirements, coverage) {
    const next = [];
    if (coverage.clarification_needed_for.length > 0) {
        next.push("Уточните период, счет, документ или контрагента для требований: " + coverage.clarification_needed_for.join(", ") + ".");
    }
    if (coverage.requirements_uncovered.length > 0) {
        next.push("Проверьте непокрытые требования: " + coverage.requirements_uncovered.join(", ") + ".");
    }
    if (coverage.out_of_scope_requirements.length > 0) {
        next.push("Часть запроса вне текущего учетного контура: " + coverage.out_of_scope_requirements.join(", ") + ".");
    }
    if (next.length === 0 && requirements.length > 0) {
        next.push("Следующим шагом откройте точечную проверку по связанным документам и проводкам.");
    }
    return next;
}
const PROBLEM_HEAVY_TYPES = new Set([
    "document_conflict",
    "broken_chain_segment",
    "lifecycle_anomaly_node",
    "unresolved_settlement_cluster",
    "period_risk_cluster",
    "cross_branch_inconsistency_cluster"
]);
function flattenEvidence(results) {
    return results.flatMap((item) => item.evidence);
}
function flattenProblemUnits(results) {
    const units = [];
    for (const result of results) {
        if (!Array.isArray(result.problem_units)) {
            continue;
        }
        units.push(...result.problem_units);
    }
    const byId = new Map();
    for (const unit of units) {
        byId.set(unit.problem_unit_id, unit);
    }
    return Array.from(byId.values());
}
function selectProblemUnitSummary(results) {
    let selected = null;
    for (const result of results) {
        if (!result.problem_unit_summary) {
            continue;
        }
        if (!selected || result.problem_unit_summary.units_total > selected.units_total) {
            selected = result.problem_unit_summary;
        }
    }
    return selected;
}
function isLikelyAccountToken(value) {
    const text = String(value ?? "").trim();
    if (!text) {
        return false;
    }
    if (/^\d{2}(?:\.\d{1,2})?$/.test(text)) {
        return true;
    }
    return /(?:^|[^a-zа-яё])(account|счет)(?:[^a-zа-яё]|$)/iu.test(text);
}
function isOpaqueEntityRef(value) {
    const text = String(value ?? "").trim();
    if (!text) {
        return false;
    }
    if (/^[a-zа-яё0-9_]+:\[id\]$/iu.test(text)) {
        return true;
    }
    if (/^(?:document|accumulationregister|catalog|register)_/iu.test(text)) {
        return true;
    }
    return false;
}
function humanizeLifecycleStateToken(value) {
    const raw = String(value ?? "").trim();
    if (!raw) {
        return raw;
    }
    const mapped = humanizeTechnicalToken(raw);
    if (mapped) {
        return mapped;
    }
    const normalized = normalizeTechnicalToken(raw);
    if (normalized.includes("->")) {
        return normalized
            .split("->")
            .map((part) => humanizeLifecycleStateToken(part))
            .join(" -> ");
    }
    return normalized.replace(/_/g, " ");
}
function humanizeLifecycleTransitionToken(value) {
    const raw = String(value ?? "").trim();
    if (!raw) {
        return raw;
    }
    const mapped = humanizeTechnicalToken(raw);
    if (mapped) {
        return mapped;
    }
    if (raw.includes("->")) {
        return raw
            .split("->")
            .map((part) => humanizeLifecycleStateToken(part))
            .join(" -> ");
    }
    return humanizeLifecycleStateToken(raw);
}
function formatAffectedScope(unit) {
    const accountScope = sanitizeUserLines(unit.affected_accounts, 3).filter((item) => isLikelyAccountToken(item));
    const counterpartyScope = sanitizeUserLines(unit.affected_counterparties, 2).filter((item) => !isOpaqueEntityRef(item));
    const documentScopeRaw = sanitizeUserLines(unit.affected_documents, 2);
    const documentScope = documentScopeRaw.filter((item) => !isOpaqueEntityRef(item));
    const entityScopeRaw = sanitizeUserLines(unit.affected_entities, 2);
    const entityScope = entityScopeRaw.filter((item) => !isOpaqueEntityRef(item));
    const scopeParts = [];
    if (accountScope.length > 0) {
        scopeParts.push(`счета: ${accountScope.join(", ")}`);
    }
    if (counterpartyScope.length > 0) {
        scopeParts.push(`контрагенты: ${counterpartyScope.join(", ")}`);
    }
    if (documentScopeRaw.length > 0) {
        if (documentScope.length > 0) {
            scopeParts.push(`документы: ${documentScope.join(", ")}`);
        }
        else {
            scopeParts.push("документы: связанные документы контура");
        }
    }
    if (scopeParts.length === 0 && entityScope.length > 0) {
        scopeParts.push(`связанные объекты: ${entityScope.join(", ")}`);
    }
    if (scopeParts.length === 0) {
        return "контур проверки: требуется уточнение объекта";
    }
    return scopeParts.join("; ");
}
function formatLifecycleScope(unit) {
    if (!unit.lifecycle_domain) {
        return null;
    }
    const domainLabel = unit.lifecycle_domain === "bank_settlement"
        ? "расчеты с оплатами"
        : unit.lifecycle_domain === "customer_settlement"
            ? "расчеты с покупателями"
            : unit.lifecycle_domain === "deferred_expense"
                ? "расходы будущих периодов"
                : unit.lifecycle_domain === "fixed_asset"
                    ? "основные средства"
                    : unit.lifecycle_domain === "vat_flow"
                        ? "НДС"
                        : unit.lifecycle_domain === "period_close"
                            ? "закрытие периода"
                            : "жизненный цикл операции";
    const parts = [`контур: ${domainLabel}`];
    if (unit.current_lifecycle_state && unit.expected_lifecycle_state) {
        const currentState = humanizeLifecycleStateToken(unit.current_lifecycle_state);
        const expectedState = humanizeLifecycleStateToken(unit.expected_lifecycle_state);
        parts.push(`фактическое состояние "${currentState}", ожидаемое "${expectedState}"`);
    }
    else if (unit.expected_lifecycle_state) {
        const expectedState = humanizeLifecycleStateToken(unit.expected_lifecycle_state);
        parts.push(`ожидаемое состояние "${expectedState}" не подтверждено`);
    }
    if (unit.missing_transition) {
        const missingTransition = humanizeLifecycleTransitionToken(unit.missing_transition);
        parts.push(`не подтвержден ожидаемый переход "${missingTransition}"`);
    }
    if (unit.invalid_transition) {
        const invalidTransition = humanizeLifecycleTransitionToken(unit.invalid_transition);
        parts.push(`обнаружен конфликтный переход "${invalidTransition}"`);
    }
    if (unit.lifecycle_defect_type === "misclosed_state") {
        parts.push("закрытие похоже формально завершено, но путь закрытия некорректный");
    }
    if (unit.lifecycle_defect_type === "cross_branch_state_conflict") {
        parts.push("между связанными ветками есть конфликт состояния");
    }
    if (unit.stale_duration) {
        const staleDuration = humanizeLifecycleStateToken(unit.stale_duration);
        parts.push(`зависание по времени: ${staleDuration}`);
    }
    return parts.join(", ");
}
function formatGraphScope(unit) {
    const binding = unit.graph_binding;
    if (!binding) {
        return null;
    }
    const parts = [];
    if (binding.missing_links.length > 0) {
        const missingLinks = binding.missing_links.map((item) => humanizeLifecycleTransitionToken(item));
        parts.push(`в связанной цепочке не подтверждены переходы: ${missingLinks.join(", ")}`);
    }
    if (binding.conflicting_links.length > 0) {
        const conflictingLinks = binding.conflicting_links.map((item) => humanizeLifecycleTransitionToken(item));
        parts.push(`между связанными участками есть конфликт: ${conflictingLinks.join(", ")}`);
    }
    if (binding.relation_path.length > 2) {
        parts.push("разрыв обнаружен между связанными объектами, а не только внутри одного документа");
    }
    if (binding.graph_confidence === "high") {
        parts.push("сигнал по связям устойчивый");
    }
    else if (binding.graph_confidence === "medium") {
        parts.push("сигнал по связям умеренной силы");
    }
    else {
        parts.push("сигнал по связям слабый, нужна проверка");
    }
    return parts.join(", ");
}
function isSettlementAccountToken(value) {
    return /^(?:60|62)(?:\.|$)/.test(String(value ?? "").trim());
}
function isVatAccountToken(value) {
    return /^(?:19|68)(?:\.|$)/.test(String(value ?? "").trim());
}
function isCloseCostsAccountToken(value) {
    const account = String(value ?? "").trim();
    if (!account) {
        return false;
    }
    if (/^97(?:\.|$)/.test(account)) {
        return true;
    }
    const match = account.match(/^(\d{2})/);
    if (!match) {
        return false;
    }
    const prefix = Number(match[1]);
    return prefix >= 20 && prefix <= 44;
}
function problemUnitSignalCorpus(unit) {
    return [
        unit.problem_unit_type,
        unit.lifecycle_domain ?? "",
        unit.business_defect_class ?? "",
        unit.failed_expected_edge ?? "",
        unit.missing_transition ?? "",
        unit.invalid_transition ?? "",
        unit.mechanism_summary ?? "",
        unit.business_lifecycle_interpretation ?? ""
    ]
        .join(" ")
        .toLowerCase();
}
function hasControlledCrossDomainHandoff(unit) {
    const corpus = problemUnitSignalCorpus(unit);
    return /controlled_cross_domain_handoff|secondary_hypothesis|related_area_to_check|cross_domain_handoff/i.test(corpus);
}
function isProblemUnitAlignedWithNarrativeDomain(unit, domain) {
    if (!domain) {
        return true;
    }
    const accounts = unit.affected_accounts ?? [];
    const corpus = problemUnitSignalCorpus(unit);
    if (domain === "settlements_60_62") {
        const foreignSettlementDomain = ["deferred_expense", "vat_flow", "period_close", "fixed_asset"].includes(String(unit.lifecycle_domain ?? ""));
        if (foreignSettlementDomain && !hasControlledCrossDomainHandoff(unit)) {
            return false;
        }
        if (unit.lifecycle_domain === "bank_settlement" || unit.lifecycle_domain === "customer_settlement") {
            return true;
        }
        if (accounts.some((item) => isSettlementAccountToken(item))) {
            return true;
        }
        if (unit.problem_unit_type === "broken_chain_segment" || unit.problem_unit_type === "unresolved_settlement_cluster") {
            return true;
        }
        return /(payment_to_settlement|settlement_closed|settlement|аванс|зачет|зачёт|расчет|расч[её]т|оплат)/i.test(corpus);
    }
    if (domain === "vat_document_register_book") {
        const foreignVatDomain = ["period_close", "deferred_expense", "fixed_asset", "bank_settlement", "customer_settlement"].includes(String(unit.lifecycle_domain ?? ""));
        if (foreignVatDomain && !hasControlledCrossDomainHandoff(unit)) {
            return false;
        }
        if (unit.lifecycle_domain === "vat_flow") {
            return true;
        }
        if (accounts.some((item) => isVatAccountToken(item))) {
            return true;
        }
        return /(vat|ндс|invoice|book_entry|register|книг|сч[её]т(?:а|у|ом|е)?[\s-]?фактур(?:а|ы|е|у|ой)?|вычет|налогов(?:ый|ого)?\s+эффект)/i.test(corpus);
    }
    if (domain === "month_close_costs_20_44") {
        const foreignMonthCloseDomain = ["vat_flow", "bank_settlement", "customer_settlement", "fixed_asset"].includes(String(unit.lifecycle_domain ?? ""));
        if (foreignMonthCloseDomain && !hasControlledCrossDomainHandoff(unit)) {
            return false;
        }
        if (unit.lifecycle_domain === "period_close" ||
            unit.lifecycle_domain === "deferred_expense" ||
            unit.lifecycle_domain === "fixed_asset") {
            return true;
        }
        if (accounts.some((item) => isCloseCostsAccountToken(item))) {
            return true;
        }
        if (unit.problem_unit_type === "period_risk_cluster" || unit.problem_unit_type === "lifecycle_anomaly_node") {
            return true;
        }
        return /(period_close|allocation|writeoff|cost|затрат|закрыти|списан|распредел)/i.test(corpus);
    }
    return true;
}
function rankProblemUnitsForAnswer(units, lifecycleAnswerEnabled, domainLock) {
    const sorted = !lifecycleAnswerEnabled
        ? units.slice().sort((left, right) => {
            const severityDiff = right.severity.score - left.severity.score;
            if (severityDiff !== 0)
                return severityDiff;
            return right.confidence.score - left.confidence.score;
        })
        : units.slice().sort((left, right) => {
            const lifecycleRankDiff = (right.lifecycle_ranking_score ?? 0) - (left.lifecycle_ranking_score ?? 0);
            if (lifecycleRankDiff !== 0)
                return lifecycleRankDiff;
            const lifecycleConfidenceDiff = (right.lifecycle_confidence?.score ?? 0) - (left.lifecycle_confidence?.score ?? 0);
            if (lifecycleConfidenceDiff !== 0)
                return lifecycleConfidenceDiff;
            const severityDiff = right.severity.score - left.severity.score;
            if (severityDiff !== 0)
                return severityDiff;
            return right.confidence.score - left.confidence.score;
        });
    if (!domainLock) {
        return sorted;
    }
    const aligned = sorted.filter((unit) => isProblemUnitAlignedWithNarrativeDomain(unit, domainLock));
    if (aligned.length === 0) {
        return sorted;
    }
    const alignedIds = new Set(aligned.map((unit) => unit.problem_unit_id));
    return [...aligned, ...sorted.filter((unit) => !alignedIds.has(unit.problem_unit_id))];
}
function hasLifecycleResolution(units) {
    return units.some((unit) => Boolean(unit.lifecycle_domain) &&
        Boolean(unit.current_lifecycle_state) &&
        Boolean(unit.expected_lifecycle_state) &&
        Boolean(unit.lifecycle_defect_type));
}
function hasGraphResolution(units) {
    return units.some((unit) => Boolean(unit.graph_binding?.graph_node_id));
}
function buildProblemCentricActions(input) {
    const actions = [];
    const unitTypes = new Set(input.units.map((item) => item.problem_unit_type));
    if (input.focusDomain === "settlements_60_62") {
        actions.push("Проверьте договор и объект расчетов по платежу/зачету.");
        actions.push("Сверьте регистр расчетов и привязку платежа к закрывающему документу по 60/62.");
        actions.push("Проверьте зачет аванса или взаимозачет и связку платежа с закрытием расчета.");
    }
    if (unitTypes.has("broken_chain_segment")) {
        actions.push("Проверьте связку выписка -> документ -> проводка по проблемным участкам цепочки.");
    }
    if (unitTypes.has("unresolved_settlement_cluster")) {
        actions.push("Сверьте хвосты по расчетам: закрылся ли документ оплаты корректным закрывающим документом.");
    }
    if (unitTypes.has("period_risk_cluster")) {
        actions.push("Оцените влияние дефекта на закрытие периода и корректность регламентных операций.");
    }
    if (unitTypes.has("cross_branch_inconsistency_cluster")) {
        actions.push("Сверьте противоречия между документами, проводками и регистрами по НДС/межконтурным связям.");
    }
    if (unitTypes.has("lifecycle_anomaly_node")) {
        actions.push("Проверьте lifecycle объекта: ожидаемый этап не должен оставаться в partially_linked состоянии.");
    }
    for (const unit of input.units) {
        if (unit.lifecycle_defect_type === "stale_active_state") {
            actions.push("Проверьте, почему объект завис: ожидаемый переход не должен оставаться в активной стадии.");
        }
        if (unit.lifecycle_defect_type === "misclosed_state") {
            actions.push("Проверьте закрывающий документ и проводки: закрытие может быть формальным, но некорректным по пути.");
        }
        if (unit.lifecycle_defect_type === "cross_branch_state_conflict") {
            actions.push("Сверьте бухгалтерскую и смежную ветки (например, НДС/расчеты): обнаружен межконтурный конфликт состояния.");
        }
    }
    if (input.missingAnchors.period && input.mode !== "clarification_required") {
        actions.push("Уточните период проверки (например, июль 2020), чтобы подтвердить незавершенное списание без лишнего шума.");
    }
    if (input.mode === "clarification_required") {
        if (input.missingAnchors.period) {
            actions.push("Уточните период проверки, чтобы зафиксировать границы проблемного контура.");
        }
        if (input.missingAnchors.account) {
            actions.push("Уточните счет или группу счетов для предметной локализации дефекта.");
        }
        if (input.missingAnchors.documentOrObject) {
            actions.push("Укажите конкретный документ или объект трассировки для проверки механизма отклонения.");
        }
        if (input.missingAnchors.counterparty) {
            actions.push("Укажите контрагента/договор, чтобы проверить хвосты и разрывы на конкретной связке.");
        }
    }
    if (input.coverageReport.requirements_uncovered.length > 0) {
        actions.push(`Закройте непокрытые требования: ${input.coverageReport.requirements_uncovered.join(", ")}.`);
    }
    return uniqueStrings(actions, 6);
}
function buildProblemCentricClarifications(input) {
    if (input.mode !== "clarification_required") {
        return [];
    }
    const questions = [];
    const unitTypes = new Set(input.units.map((item) => item.problem_unit_type));
    if (input.missingAnchors.period) {
        questions.push("Уточните период (например, июль 2020), в котором нужно проверить проблемный кластер.");
    }
    if (input.missingAnchors.account) {
        questions.push("Уточните счет или связку счетов (например, 51/60), где вы ожидаете дефект.");
    }
    if (input.missingAnchors.documentOrObject) {
        questions.push("Укажите документ/объект, от которого нужно строить проверку цепочки.");
    }
    if (input.missingAnchors.counterparty) {
        questions.push("Укажите контрагента или договор, по которому проверить незакрытую экспозицию.");
    }
    if (unitTypes.has("broken_chain_segment")) {
        questions.push("Уточните участок цепочки: выписка, платежный документ или проводка.");
    }
    if (unitTypes.has("period_risk_cluster")) {
        questions.push("Уточните, какой этап закрытия периода критичен: начисление, закрытие счетов или НДС-блок.");
    }
    if (unitTypes.has("unresolved_settlement_cluster")) {
        questions.push("Уточните, интересуют хвосты поставщиков, покупателей или оба направления.");
    }
    if (input.coverageReport.clarification_needed_for.length > 0) {
        questions.push(`Закройте уточнения для требований: ${input.coverageReport.clarification_needed_for.join(", ")}.`);
    }
    return uniqueStrings(questions, 6);
}
function buildClaimEvidenceLinks(results) {
    const byClaim = new Map();
    for (const evidence of flattenEvidence(results)) {
        const claimRef = String(evidence.claim_ref ?? "").trim();
        const evidenceId = String(evidence.evidence_id ?? "").trim();
        if (!claimRef || !evidenceId) {
            continue;
        }
        const current = byClaim.get(claimRef) ?? [];
        current.push(evidenceId);
        byClaim.set(claimRef, current);
    }
    return Array.from(byClaim.entries())
        .slice(0, 10)
        .map(([claim_ref, evidenceIds]) => ({
        claim_ref,
        evidence_ids: uniqueStrings(evidenceIds, 10)
    }));
}
function aggregatePolicySignals(results) {
    const broad_query_detected = results.some((item) => summaryBoolean(item, "broad_query_detected"));
    const broad_result_flag = results.some((item) => summaryBoolean(item, "broad_result_flag"));
    const minimum_evidence_failed = results.some((item) => summaryBoolean(item, "minimum_evidence_failed"));
    let degraded_to = null;
    for (const result of results) {
        const degraded = summaryString(result, "degraded_to");
        if (degraded === "clarification") {
            degraded_to = "clarification";
            break;
        }
        if (degraded === "partial") {
            degraded_to = "partial";
        }
    }
    const narrowingOrder = {
        weak: 0,
        medium: 1,
        strong: 2
    };
    let narrowing_strength = null;
    for (const result of results) {
        const value = summaryString(result, "narrowing_strength");
        if (value !== "weak" && value !== "medium" && value !== "strong") {
            continue;
        }
        if (!narrowing_strength || narrowingOrder[value] < narrowingOrder[narrowing_strength]) {
            narrowing_strength = value;
        }
    }
    return {
        broad_query_detected,
        broad_result_flag,
        minimum_evidence_failed,
        degraded_to,
        narrowing_strength
    };
}
function confidenceToScore(value) {
    if (value === "high")
        return 3;
    if (value === "medium")
        return 2;
    return 1;
}
function aggregateConfidence(results, evidenceItems) {
    const scores = [];
    for (const evidence of evidenceItems) {
        scores.push(confidenceToScore(evidence.confidence));
    }
    for (const result of results) {
        if (result.status === "error") {
            continue;
        }
        scores.push(confidenceToScore(result.confidence));
    }
    if (scores.length === 0) {
        return "low";
    }
    const average = scores.reduce((acc, item) => acc + item, 0) / scores.length;
    if (average >= 2.6)
        return "high";
    if (average >= 1.8)
        return "medium";
    return "low";
}
function collectLimitationReasonCodes(evidenceItems) {
    const codes = evidenceItems
        .map((item) => item.limitation?.reason_code ?? null)
        .filter((item) => Boolean(item));
    return uniqueStrings(codes, 8);
}
function limitationReasonToText(code) {
    if (code === "snapshot_only")
        return "Evidence is snapshot-only and may lag source-of-record.";
    if (code === "heuristic_inference")
        return "Part of the conclusion relies on heuristic inference.";
    if (code === "missing_mechanism")
        return "Mechanism is unresolved for part of the evidence.";
    if (code === "weak_source_mapping")
        return "Source mapping is weak for part of the evidence.";
    if (code === "insufficient_detail")
        return "Evidence lacks detail for a strong factual claim.";
    return "Some evidence limitations remain unresolved.";
}
function asRecordObject(value) {
    if (!value || typeof value !== "object" || Array.isArray(value)) {
        return null;
    }
    return value;
}
const EXPLICIT_PERIOD_ANCHOR_PATTERN = /(?:\b20\d{2}(?:[-./](?:0?[1-9]|1[0-2]))?(?:[-./](?:0?[1-9]|[12]\d|3[01]))?\b|\b(?:0?[1-9]|[12]\d|3[01])[./-](?:0?[1-9]|1[0-2])[./-](?:\d{2}|\d{4})\b|\b(?:январ[ьяе]|феврал[ьяе]|март[ае]?|апрел[ьяе]|ма[йея]|июн[ьяе]|июл[ьяе]|август[ае]?|сентябр[ьяе]|октябр[ьяе]|ноябр[ьяе]|декабр[ьяе]|january|february|march|april|may|june|july|august|september|october|november|december)\b)/i;
function hasPeriodAnchorInCompanyAnchors(anchors) {
    if (!anchors) {
        return false;
    }
    const dates = Array.isArray(anchors.dates) ? anchors.dates : [];
    const periods = Array.isArray(anchors.periods) ? anchors.periods : [];
    return dates.some((item) => String(item ?? "").trim().length > 0) || periods.some((item) => String(item ?? "").trim().length > 0);
}
function hasPeriodAnchorInRetrieval(results) {
    for (const result of results) {
        const summary = asRecordObject(result.summary);
        if (!summary) {
            continue;
        }
        const semanticProfile = asRecordObject(summary.semantic_profile);
        const periodScope = semanticProfile ? asRecordObject(semanticProfile.period_scope) : null;
        if (periodScope) {
            const from = String(periodScope.from ?? "").trim();
            const to = String(periodScope.to ?? "").trim();
            const granularity = String(periodScope.granularity ?? "").trim().toLowerCase();
            if (from.length > 0 || to.length > 0 || (granularity.length > 0 && granularity !== "unknown")) {
                return true;
            }
        }
        const queryPeriod = String(summary.query_period ?? "").trim();
        if (queryPeriod.length > 0) {
            return true;
        }
    }
    return false;
}
function hasAccountAnchorInRetrieval(results) {
    for (const result of results) {
        const summary = asRecordObject(result.summary);
        if (!summary) {
            continue;
        }
        const semanticProfile = asRecordObject(summary.semantic_profile);
        if (!semanticProfile) {
            continue;
        }
        const accountScope = Array.isArray(semanticProfile.account_scope) ? semanticProfile.account_scope : [];
        if (accountScope.length > 0) {
            return true;
        }
    }
    return false;
}
function detectMissingAnchors(userMessage, retrievalResults = [], options) {
    const lower = String(userMessage ?? "").toLowerCase();
    const hasPeriod = EXPLICIT_PERIOD_ANCHOR_PATTERN.test(lower) ||
        hasPeriodAnchorInRetrieval(retrievalResults) ||
        Boolean(options?.normalizationPeriodExplicit) ||
        hasPeriodAnchorInCompanyAnchors(options?.companyAnchors);
    const hasAccount = /(?:\bсчет\b|\baccount\b|\bschet\b|\b(?:0[1-9]|[1-9]\d)(?:\.\d{2})?\b|\b(?:60|62)\.\d{2}\s*\/\s*(?:60|62)\.\d{2}\b)/i.test(lower) || hasAccountAnchorInRetrieval(retrievalResults);
    const hasDocumentOrObject = /(?:документ|invoice|guid|object|obj|#\d+|\b№\s*[a-zа-я0-9-]+\b|\bid\b|\bref\b|dokument|doc)/i.test(lower);
    const hasCounterparty = /(?:контрагент|supplier|buyer|customer|kontragent|postavsh|pokupatel|договор|contract)/i.test(lower);
    const hasAnomalyType = /(?:аномал|risk|отклон|разрыв|mismatch|duplicate|tail|цепочк|anomali|hvost)/i.test(lower);
    return {
        period: !hasPeriod,
        account: !hasAccount,
        documentOrObject: !hasDocumentOrObject,
        counterparty: !hasCounterparty,
        anomalyType: !hasAnomalyType
    };
}
function buildClarificationQuestions(input) {
    const questions = [];
    const shouldAsk = input.mode === "clarification_required" || input.coverageReport.clarification_needed_for.length > 0;
    if (!shouldAsk) {
        return questions;
    }
    if (input.missingAnchors.period) {
        questions.push("Уточните период проверки (например, июль 2020).");
    }
    if (input.missingAnchors.account) {
        questions.push("Уточните счет или группу счетов (например, 19, 60, 62).");
    }
    if (input.missingAnchors.documentOrObject) {
        questions.push("Укажите документ/GUID/конкретный объект для трассировки.");
    }
    if (input.missingAnchors.counterparty) {
        questions.push("Укажите контрагента или группу контрагентов.");
    }
    if (input.policySignals.broad_query_detected && input.missingAnchors.anomalyType) {
        questions.push("Уточните тип отклонения: разрыв цепочки, неверный документ или аномальный риск.");
    }
    if (input.coverageReport.clarification_needed_for.length > 0) {
        questions.push(`Закройте уточнения для требований: ${input.coverageReport.clarification_needed_for.join(", ")}.`);
    }
    return uniqueStrings(questions, 6);
}
function buildRecommendedActions(input) {
    const actions = [];
    if (input.mode === "focused_grounded") {
        actions.push("Проверьте 1-2 ключевые записи в учетной базе и зафиксируйте итог в рабочем файле проверки.");
    }
    if (input.mode === "broad_partial") {
        actions.push("Сузьте запрос до периода + счета или периода + документа и повторите проверку.");
    }
    if (input.mode === "clarification_required") {
        actions.push("Дайте недостающие якоря (период/счет/объект), иначе сильный factual вывод невозможен.");
    }
    if (input.coverageReport.requirements_uncovered.length > 0) {
        actions.push(`Закройте непокрытые требования: ${input.coverageReport.requirements_uncovered.join(", ")}.`);
    }
    if (input.coverageReport.requirements_partially_covered.length > 0) {
        actions.push(`Доуточните частично покрытые требования: ${input.coverageReport.requirements_partially_covered.join(", ")}.`);
    }
    if (input.policySignals.broad_query_detected && input.policySignals.narrowing_strength !== "strong") {
        actions.push("Добавьте более узкий контекст: тип отклонения, группу документов и бизнес-участок.");
    }
    if (input.limitationReasonCodes.includes("snapshot_only")) {
        actions.push("Сверьте критичные выводы с live source-of-record в 1C.");
    }
    if (input.limitationReasonCodes.includes("weak_source_mapping")) {
        actions.push("Проверьте source mapping для связей document/register по указанным ref.");
    }
    if (input.sourceRefs.length > 0) {
        actions.push(`Начните проверку с ${input.sourceRefs.length} подтвержденных записей и сверьте их с первичными документами.`);
    }
    return uniqueStrings(actions, 6);
}
function firstMeaningfulFact(results) {
    const facts = extractTopFacts(results);
    return facts.length > 0 ? facts[0] : null;
}
function buildPolicyDecision(input) {
    const hasCoverageGaps = input.coverageReport.requirements_uncovered.length > 0 ||
        input.coverageReport.requirements_partially_covered.length > 0 ||
        input.coverageReport.clarification_needed_for.length > 0 ||
        input.coverageReport.out_of_scope_requirements.length > 0;
    if (input.fallbackType === "out_of_scope" && input.coverageReport.requirements_covered === 0) {
        return {
            mode: "out_of_scope",
            fallback_type: "out_of_scope",
            reply_type: "out_of_scope"
        };
    }
    if (input.groundingCheck.status === "route_mismatch_blocked") {
        return {
            mode: "route_mismatch",
            fallback_type: "partial",
            reply_type: "route_mismatch_blocked"
        };
    }
    if ((input.policySignals.degraded_to === "clarification" && input.policySignals.minimum_evidence_failed) ||
        (input.fallbackType === "clarification" && !input.hasSupport) ||
        (input.groundingCheck.status === "no_grounded_answer" && !input.hasSupport)) {
        return {
            mode: "clarification_required",
            fallback_type: "clarification",
            reply_type: "clarification_required"
        };
    }
    if (input.errorResults.length > 0 && input.okResults.length === 0 && input.partialResults.length === 0) {
        return {
            mode: "backend_error",
            fallback_type: input.fallbackType,
            reply_type: "backend_error"
        };
    }
    if (input.okResults.length === 0 && input.partialResults.length === 0 && input.emptyResults.length > 0) {
        return {
            mode: "empty",
            fallback_type: input.fallbackType,
            reply_type: "empty_but_valid"
        };
    }
    if (input.groundingCheck.status === "no_grounded_answer" && input.okResults.length === 0 && input.partialResults.length === 0) {
        return {
            mode: "no_grounded",
            fallback_type: input.fallbackType,
            reply_type: "no_grounded_answer"
        };
    }
    if (input.focusedStrong &&
        !input.policySignals.broad_query_detected &&
        !input.policySignals.minimum_evidence_failed &&
        !hasCoverageGaps) {
        return {
            mode: "focused_grounded",
            fallback_type: "none",
            reply_type: "factual_with_explanation"
        };
    }
    if (input.okResults.length > 0 ||
        input.partialResults.length > 0 ||
        hasCoverageGaps ||
        input.policySignals.minimum_evidence_failed ||
        input.policySignals.broad_result_flag ||
        input.groundingCheck.status === "partial") {
        return {
            mode: "broad_partial",
            fallback_type: "partial",
            reply_type: "partial_coverage"
        };
    }
    return {
        mode: "backend_error",
        fallback_type: "unknown",
        reply_type: "backend_error"
    };
}
function buildAnswerSummary(mode) {
    if (mode === "focused_grounded")
        return "Сформирован прямой ответ на основе подтвержденной опоры.";
    if (mode === "broad_partial")
        return "Вывод ограничен: есть частичная опора, но покрытие неполное.";
    if (mode === "clarification_required")
        return "Нужны уточнения: без сужения фокуса надежный вывод невозможен.";
    if (mode === "out_of_scope")
        return "Запрос вне доступного учетного контура.";
    if (mode === "route_mismatch")
        return "Предмет результата не совпал с предметом вопроса.";
    if (mode === "empty")
        return "В текущем срезе данных релевантные записи не обнаружены.";
    if (mode === "no_grounded")
        return "Недостаточно опоры для обоснованного ответа.";
    return "Не удалось собрать обоснованный ответ по текущему запросу.";
}
const BOUNDARY_CAPABILITY_SUGGESTIONS = [
    {
        key: "settlements_60_62",
        label: "Взаиморасчеты 60/62",
        helpText: "найти хвосты, незакрытые оплаты и рисковые связки по контрагентам.",
        signals: /(контраг|долг|сальдо|взаиморасчет|оплат|аванс|покупат|поставщ|банк|выписк|\b60\b|\b62\b|\b76\b)/iu
    },
    {
        key: "vat_document_register_book",
        label: "НДС 19/68",
        helpText: "проверить цепочку документ -> счет-фактура -> регистр -> книга.",
        signals: /(ндс|сч[её]т[-\s]?фактур|регистр|книга\s+покуп|книга\s+продаж|декларац|\b19\b|\b68\b)/iu
    },
    {
        key: "month_close_costs_20_44",
        label: "Закрытие месяца 20/44",
        helpText: "проверить распределение затрат и остатки после регламентных операций.",
        signals: /(закрыти[ея]|месяц|затрат|распределени|рбп|аморт|основн|ос\b|\b20\b|\b25\b|\b26\b|\b44\b)/iu
    }
];
function formatNarrativeDomainLabel(domain) {
    if (domain === "settlements_60_62") {
        return "взаиморасчетов 60/62";
    }
    if (domain === "vat_document_register_book") {
        return "НДС-контура 19/68";
    }
    if (domain === "month_close_costs_20_44") {
        return "закрытия месяца (20/44)";
    }
    return "доступного учетного контура";
}
function pickDeterministicBoundaryVariant(seed, variants) {
    if (variants.length === 0) {
        return "";
    }
    let score = 0;
    for (const char of String(seed ?? "")) {
        score = (score + char.charCodeAt(0)) % 104_729;
    }
    return variants[score % variants.length];
}
function pickBoundaryCapabilityLines(userMessage, limit = 3) {
    const text = String(userMessage ?? "").toLowerCase();
    const scored = BOUNDARY_CAPABILITY_SUGGESTIONS.map((item, index) => ({
        item,
        score: (text.match(item.signals) ?? []).length,
        order: index
    }));
    const ranked = scored
        .slice()
        .sort((left, right) => right.score - left.score || left.order - right.order)
        .map((entry) => entry.item);
    const selected = ranked.slice(0, Math.max(2, limit));
    return uniqueStrings(selected.map((item) => `${item.label}: ${item.helpText}`), limit);
}
function buildBoundaryQuickActionLine(capabilities) {
    const actions = capabilities
        .slice(0, 2)
        .map((item) => item.replace(/:\s*/u, " — ").trim())
        .filter((item) => item.length > 0);
    if (actions.length === 0) {
        return null;
    }
    return `Что могу сделать сейчас: ${actions.join("; ")}.`;
}
function buildBoundaryQuickActionItems(capabilities) {
    const actions = capabilities
        .slice(0, 3)
        .map((item) => item.replace(/:\s*/u, " — ").trim())
        .filter((item) => item.length > 0);
    return uniqueStrings(actions, 3);
}
function buildNaturalClarificationHints(input) {
    const hints = [];
    if (input.missingAnchors.period) {
        hints.push("Укажи период проверки (например, июль 2020).");
    }
    if (input.missingAnchors.account) {
        hints.push("Укажи счет или связку счетов (например, 60/62, 19/68 или 20/44).");
    }
    if (input.missingAnchors.counterparty) {
        hints.push("Добавь контрагента или договор, чтобы зафиксировать контур проверки.");
    }
    if (input.missingAnchors.documentOrObject) {
        hints.push("Укажи документ или объект, от которого строить проверку цепочки.");
    }
    if (input.missingAnchors.anomalyType) {
        hints.push("Уточни тип отклонения: разрыв цепочки, неверное закрытие или аномальный хвост.");
    }
    if (input.coverageReport.clarification_needed_for.length > 0) {
        hints.push(`Закрой уточнения для требований: ${input.coverageReport.clarification_needed_for.join(", ")}.`);
    }
    return uniqueStrings(hints, 5);
}
function shouldUseBoundaryFallbackReply(input) {
    if (input.mode === "out_of_scope") {
        return true;
    }
    if (input.mode !== "clarification_required" && input.mode !== "no_grounded" && input.mode !== "broad_partial") {
        return false;
    }
    const hasNoEvidenceRoutes = input.okResultsCount === 0 && input.partialResultsCount === 0;
    const hasNoConfirmedCoverage = input.coverageReport.requirements_covered === 0 &&
        input.coverageReport.requirements_partially_covered.length === 0;
    const groundingBlocked = input.groundingCheck.status === "no_grounded_answer" ||
        input.groundingCheck.status === "partial" ||
        input.groundingCheck.status === "route_mismatch_blocked";
    if (hasNoEvidenceRoutes && hasNoConfirmedCoverage && groundingBlocked) {
        return true;
    }
    const domainNotCovered = input.focusDomain === null || input.focusDomainGroundingBlocked;
    const weakEvidenceEnvelope = input.okResultsCount === 0 &&
        (input.partialResultsCount === 0 ||
            input.aggregateEvidenceConfidence === "low" ||
            input.hasCriticalEvidenceLimitation);
    if (domainNotCovered && hasNoConfirmedCoverage && groundingBlocked && weakEvidenceEnvelope) {
        return true;
    }
    return false;
}
function buildBoundaryFallbackReply(input) {
    const nearbyCapabilities = pickBoundaryCapabilityLines(input.userMessage, 3);
    const quickActionLine = buildBoundaryQuickActionLine(nearbyCapabilities);
    const quickActionItems = buildBoundaryQuickActionItems(nearbyCapabilities);
    if (input.focusDomain === null) {
        const heading = pickDeterministicBoundaryVariant(input.userMessage, [
            "По этому запросу у меня нет надежного доменного покрытия, поэтому даю мягкий отказ вместо технического шаблона.",
            "Сейчас у меня нет надежного доменного маршрута по этому запросу, поэтому даю мягкий отказ вместо шаблонной технички."
        ]);
        return renderStage4ContractReply({
            shortLine: heading,
            checkedLines: [
                "Проверен доступный контур 1С и возможность маршрутизации запроса.",
                "Надежный доменный путь для текущей формулировки не подтвержден."
            ],
            foundLines: nearbyCapabilities.length > 0
                ? nearbyCapabilities
                : ["Близких поддерживаемых сценариев по текущей формулировке не найдено."],
            unresolvedLines: ["Запрос не подтвержден в поддерживаемом контуре как надежный бухгалтерский сценарий."],
            nextStepLines: quickActionItems.length > 0
                ? quickActionItems
                : [quickActionLine ?? "Переформулируйте вопрос через период, счет или объект, и я сразу продолжу проверку."],
            nextStepTitle: "Что могу сделать сейчас"
        });
    }
    const clarificationHints = buildNaturalClarificationHints({
        missingAnchors: input.missingAnchors,
        coverageReport: input.coverageReport
    });
    const domainHeading = pickDeterministicBoundaryVariant(`${input.userMessage}|${input.focusDomain}`, [
        `Сейчас не могу надежно ответить по сценарию ${formatNarrativeDomainLabel(input.focusDomain)}: не хватает опоры.`,
        `По сценарию ${formatNarrativeDomainLabel(input.focusDomain)} пока не хватает подтвержденной опоры для надежного вывода.`
    ]);
    return renderStage4ContractReply({
        shortLine: domainHeading,
        checkedLines: [
            `Проверен сценарий ${formatNarrativeDomainLabel(input.focusDomain)} в текущем контуре 1С.`,
            "Оценена достаточность подтвержденной опоры для прямого вывода."
        ],
        foundLines: nearbyCapabilities.length > 0
            ? nearbyCapabilities.slice(0, 2)
            : ["Подтвержденных близких сценариев в текущем проходе не найдено."],
        unresolvedLines: clarificationHints.length > 0
            ? clarificationHints
            : ["Без дополнительного ориентира (период, объект или контрагент) вывод останется частичным."],
        nextStepLines: quickActionItems.length > 0
            ? quickActionItems
            : [quickActionLine ?? "Добавьте один уточняющий ориентир, и я продолжу проверку без смены контура."],
        nextStepTitle: "Что могу сделать сейчас"
    });
}
function ensureSentence(value) {
    const sanitized = sanitizeUserText(value) ?? String(value ?? "").trim();
    const normalized = sanitized.replace(/\s+/g, " ").trim();
    if (!normalized) {
        return "";
    }
    return /[.!?]$/u.test(normalized) ? normalized : `${normalized}.`;
}
function normalizeNarrativeKey(value) {
    return normalizeTechnicalToken(value).replace(/[^\p{L}\p{N}]+/gu, "_");
}
function dedupeNarrativeLines(values, limit = 4) {
    const byKey = new Map();
    for (const value of values) {
        const sentence = ensureSentence(value);
        if (!sentence) {
            continue;
        }
        const key = normalizeNarrativeKey(sentence);
        if (!key) {
            continue;
        }
        if (!byKey.has(key)) {
            byKey.set(key, sentence);
        }
    }
    return Array.from(byKey.values()).slice(0, limit);
}
function mapProblemUnitTypeToNarrative(value) {
    if (value === "broken_chain_segment") {
        return "Оплата отражена, но ожидаемое закрытие расчета по цепочке не подтверждено.";
    }
    if (value === "unresolved_settlement_cluster") {
        return "По расчетам остался незавершенный хвост: закрывающий документ или зачет не подтвержден.";
    }
    if (value === "period_risk_cluster") {
        return "Контур закрытия месяца не завершен: часть затрат не дошла до ожидаемого закрытия.";
    }
    if (value === "lifecycle_anomaly_node") {
        return "Операция зависла в промежуточном состоянии и не дошла до ожидаемого этапа.";
    }
    if (value === "document_conflict") {
        return "Документ и проводка расходятся по состоянию, поэтому закрытие не подтверждено.";
    }
    if (value === "cross_branch_inconsistency_cluster") {
        return "Между связанными ветками учета есть конфликт состояния.";
    }
    return null;
}
function mapDefectTokenToNarrative(value) {
    const normalized = normalizeTechnicalToken(value);
    if (!normalized) {
        return null;
    }
    if (/expected transition is missing/i.test(value)) {
        return "Ожидаемый переход в учетной цепочке не подтвержден.";
    }
    if (normalized.includes("payment_to_settlement") || normalized.includes("failed_edge:payment_to_settlement")) {
        return "Оплата отражена, но ожидаемое закрытие расчета не подтверждено.";
    }
    if (normalized.includes("invoice") || normalized.includes("vat_flow") || normalized.includes("book_entry")) {
        return "В цепочке НДС не подтвержден ожидаемый переход от документа к регистру и книге.";
    }
    if (normalized.includes("allocation") ||
        normalized.includes("period_close") ||
        normalized.includes("writeoff") ||
        normalized.includes("costs_accumulated")) {
        return "Цепочка затрат и закрытия месяца подтверждена только частично.";
    }
    if (normalized.includes("missing_transition") || normalized.includes("expected_transition_not_observed")) {
        return "Ожидаемый переход в учетной цепочке не подтвержден.";
    }
    if (normalized.includes("conflict") || normalized.includes("mismatch")) {
        return "Между связанными участками учета есть конфликт состояния.";
    }
    if (normalized.includes("broken_chain") || normalized.includes("failed_edge")) {
        return "Связанная цепочка документов и проводок выглядит разорванной.";
    }
    return null;
}
const KNOWN_ACCOUNT_PREFIXES = new Set([
    "01",
    "02",
    "07",
    "08",
    "10",
    "13",
    "19",
    "20",
    "21",
    "23",
    "25",
    "26",
    "28",
    "29",
    "41",
    "43",
    "44",
    "45",
    "50",
    "51",
    "52",
    "55",
    "57",
    "58",
    "60",
    "62",
    "66",
    "67",
    "68",
    "69",
    "70",
    "71",
    "73",
    "76",
    "90",
    "91",
    "94",
    "96",
    "97"
]);
function collectDateLikeSpansForNarrative(text) {
    const spans = [];
    const patterns = [
        /\b20\d{2}[./-](?:0[1-9]|1[0-2])(?:[./-](?:0[1-9]|[12]\d|3[01]))?\b/g,
        /\b(?:0?[1-9]|[12]\d|3[01])[./-](?:0?[1-9]|1[0-2])[./-](?:\d{2}|\d{4})\b/g,
        /\b(?:0?[1-9]|[12]\d|3[01])\s+(?:января|февраля|марта|апреля|мая|июня|июля|августа|сентября|октября|ноября|декабря)\b/giu
    ];
    for (const pattern of patterns) {
        let match = null;
        while ((match = pattern.exec(text)) !== null) {
            spans.push({
                start: match.index,
                end: match.index + match[0].length
            });
        }
    }
    return spans;
}
function collectAmountLikeSpansForNarrative(text) {
    const spans = [];
    const pattern = /\b\d{1,3}(?:[ \u00A0]\d{3})+(?:[.,]\d{2})?\b/g;
    let match = null;
    while ((match = pattern.exec(text)) !== null) {
        spans.push({
            start: match.index,
            end: match.index + match[0].length
        });
    }
    return spans;
}
function intersectsNarrativeSpan(start, end, spans) {
    return spans.some((span) => start < span.end && end > span.start);
}
function hasAccountContextMarker(text, start, end) {
    const left = text.slice(Math.max(0, start - 24), start);
    const right = text.slice(end, Math.min(text.length, end + 24));
    return /(?:счет|сч\.?|account|schet|по\s+60|по\s+62|по\s+19|по\s+68|по\s+20|по\s+25|по\s+26|по\s+44|расчет|ндс|закрыти|рбп|амортиз|settlement|vat|close)/iu.test(`${left} ${right}`);
}
function toKnownAccountToken(value) {
    const token = String(value ?? "").trim();
    const prefix = token.match(/^(\d{2})/)?.[1];
    if (!prefix || !KNOWN_ACCOUNT_PREFIXES.has(prefix)) {
        return null;
    }
    return token;
}
function extractAccountNumbers(values) {
    const tokens = [];
    for (const value of values) {
        const raw = String(value ?? "");
        const matches = raw.match(/\b\d{2}(?:\.\d{1,2})?\b/g) ?? [];
        for (const match of matches) {
            const account = toKnownAccountToken(match);
            if (account) {
                tokens.push(account);
            }
        }
    }
    return uniqueStrings(tokens, 16);
}
function extractAccountNumbersFromNarrativeText(value) {
    const text = String(value ?? "").toLowerCase();
    if (!text.trim()) {
        return [];
    }
    const result = [];
    const dateSpans = collectDateLikeSpansForNarrative(text);
    const amountSpans = collectAmountLikeSpansForNarrative(text);
    const blockedSpans = [...dateSpans, ...amountSpans];
    const contextualPattern = /(?:\b(?:счет(?:а|у|ом|ов)?|сч\.?|account(?:s)?|schet(?:a|u|om|ov)?)\b)\s*(?:№|#|:)?\s*([0-9./,\sиand]{2,96})/giu;
    let contextualMatch = null;
    while ((contextualMatch = contextualPattern.exec(text)) !== null) {
        const chunk = String(contextualMatch[1] ?? "");
        const chunkTokens = chunk.match(/\b\d{2}(?:\.\d{1,2})?\b/g) ?? [];
        for (const token of chunkTokens) {
            const account = toKnownAccountToken(token);
            if (account) {
                result.push(account);
            }
        }
    }
    const accountPairPattern = /\b(\d{2}(?:\.\d{1,2})?)\s*\/\s*(\d{2}(?:\.\d{1,2})?)\b/g;
    let pairMatch = null;
    while ((pairMatch = accountPairPattern.exec(text)) !== null) {
        const left = toKnownAccountToken(String(pairMatch[1] ?? ""));
        const right = toKnownAccountToken(String(pairMatch[2] ?? ""));
        if (left) {
            result.push(left);
        }
        if (right) {
            result.push(right);
        }
    }
    const explicitPattern = /\b\d{2}(?:\.\d{1,2})?\b/g;
    let explicitMatch = null;
    while ((explicitMatch = explicitPattern.exec(text)) !== null) {
        const token = String(explicitMatch[0] ?? "");
        const account = toKnownAccountToken(token);
        if (!account) {
            continue;
        }
        const start = explicitMatch.index;
        const end = start + token.length;
        if (intersectsNarrativeSpan(start, end, blockedSpans)) {
            continue;
        }
        if (!hasAccountContextMarker(text, start, end)) {
            continue;
        }
        result.push(account);
    }
    return uniqueStrings(result, 16);
}
function inferP0NarrativeDomain(units) {
    const allAccounts = extractAccountNumbers(units.flatMap((unit) => unit.affected_accounts ?? []));
    const hasSettlementAccount = allAccounts.some((account) => account === "60" || account === "62");
    const hasVatAccount = allAccounts.some((account) => account === "19" || account === "68");
    const hasCloseAccount = allAccounts.some((account) => /^(2\d|3\d|4[0-4])/.test(account));
    if (hasSettlementAccount ||
        units.some((unit) => unit.lifecycle_domain === "bank_settlement" || unit.lifecycle_domain === "customer_settlement") ||
        units.some((unit) => unit.problem_unit_type === "broken_chain_segment" || unit.problem_unit_type === "unresolved_settlement_cluster")) {
        return "settlements_60_62";
    }
    if (hasVatAccount ||
        units.some((unit) => unit.lifecycle_domain === "vat_flow") ||
        units.some((unit) => unit.problem_unit_type === "cross_branch_inconsistency_cluster")) {
        return "vat_document_register_book";
    }
    if (hasCloseAccount ||
        units.some((unit) => ["period_close", "deferred_expense"].includes(String(unit.lifecycle_domain ?? ""))) ||
        units.some((unit) => unit.problem_unit_type === "period_risk_cluster")) {
        return "month_close_costs_20_44";
    }
    return null;
}
function p0NarrativeDomainFromDomainCardId(value) {
    const normalized = String(value ?? "").trim().toLowerCase();
    if (!normalized) {
        return null;
    }
    if (normalized === "settlements_60_62") {
        return "settlements_60_62";
    }
    if (normalized === "vat_document_register_book") {
        return "vat_document_register_book";
    }
    if (normalized === "month_close_costs_20_44") {
        return "month_close_costs_20_44";
    }
    return null;
}
function p0NarrativeDomainFromHint(value) {
    const normalized = String(value ?? "").trim().toLowerCase();
    if (!normalized) {
        return null;
    }
    const byCardId = p0NarrativeDomainFromDomainCardId(normalized);
    if (byCardId) {
        return byCardId;
    }
    if (normalized.includes("settlements_60_62") ||
        normalized.includes("bank_settlement") ||
        normalized.includes("customer_settlement") ||
        normalized === "settlements") {
        return "settlements_60_62";
    }
    if (normalized.includes("vat_document_register_book") ||
        normalized.includes("vat_flow") ||
        normalized.includes("vat")) {
        return "vat_document_register_book";
    }
    if (normalized.includes("month_close_costs_20_44") ||
        normalized.includes("period_close") ||
        normalized.includes("deferred_expense")) {
        return "month_close_costs_20_44";
    }
    return null;
}
function inferP0NarrativeDomainFromDomainGuards(results) {
    const weightedCounts = new Map();
    for (const result of results) {
        const guard = summaryValue(result, "domain_purity_guard");
        if (!guard || typeof guard !== "object") {
            continue;
        }
        const domainCardId = p0NarrativeDomainFromDomainCardId(String(guard.domain_card_id ?? ""));
        if (!domainCardId) {
            continue;
        }
        const weight = result.status === "ok" ? 2 : result.status === "partial" ? 1 : 0;
        if (weight <= 0) {
            continue;
        }
        weightedCounts.set(domainCardId, (weightedCounts.get(domainCardId) ?? 0) + weight);
    }
    if (weightedCounts.size === 0) {
        return null;
    }
    return Array.from(weightedCounts.entries()).sort((left, right) => right[1] - left[1])[0]?.[0] ?? null;
}
function collectSemanticProfileScopes(results) {
    const accounts = [];
    const domains = [];
    for (const result of results) {
        const semanticProfile = summaryValue(result, "semantic_profile");
        if (semanticProfile && typeof semanticProfile === "object") {
            const profile = semanticProfile;
            accounts.push(...toStringList(profile.account_scope));
            domains.push(...toStringList(profile.domain_scope));
        }
        for (const item of result.items.slice(0, 6)) {
            const source = item;
            accounts.push(...toStringList(source.account_context));
            domains.push(...toStringList(source.graph_domain_scope));
        }
    }
    return {
        accounts: uniqueStrings(accounts, 16),
        domains: uniqueStrings(domains, 16).map((item) => item.toLowerCase())
    };
}
function hasControlledCrossDomainHandoffInResult(result) {
    const corpus = JSON.stringify({
        summary: result.summary,
        selection_reason: result.selection_reason,
        why_included: result.why_included,
        limitations: result.limitations
    }).toLowerCase();
    return /controlled_cross_domain_handoff|secondary_hypothesis|related_area_to_check|cross_domain_handoff/.test(corpus);
}
function isSettlementDomainToken(value) {
    return /(?:bank_settlement|customer_settlement|settlements?|supplier_payments|suppliers?|customers?)/i.test(String(value ?? ""));
}
function isVatDomainToken(value) {
    return /(?:vat_flow|vat|nds|taxes?|purchase_book|sales_book|invoice|book_entry|register)/i.test(String(value ?? ""));
}
function isMonthCloseDomainToken(value) {
    return /(?:period_close|month_close|close_operation|cost_close|cost_allocation|deferred_expense)/i.test(String(value ?? ""));
}
function isForeignToSettlementDomainToken(value) {
    return /(?:vat_flow|vat|deferred_expense|period_close|fixed_asset|fixed_assets|taxes?)/i.test(String(value ?? ""));
}
function isForeignToVatDomainToken(value) {
    return /(?:bank_settlement|customer_settlement|settlements?|period_close|deferred_expense|fixed_asset|fixed_assets|month_close)/i.test(String(value ?? ""));
}
function isForeignToMonthCloseDomainToken(value) {
    return /(?:bank_settlement|customer_settlement|settlements?|vat_flow|vat|fixed_asset|fixed_assets)/i.test(String(value ?? ""));
}
function collectResultAccounts(result) {
    const accounts = [];
    const semanticProfile = summaryValue(result, "semantic_profile");
    if (semanticProfile && typeof semanticProfile === "object") {
        accounts.push(...toStringList(semanticProfile.account_scope));
    }
    for (const item of result.items.slice(0, 8)) {
        const source = item;
        accounts.push(...toStringList(source.account_context));
    }
    return uniqueStrings(accounts, 24);
}
function collectResultDomains(result) {
    const domains = [];
    const semanticProfile = summaryValue(result, "semantic_profile");
    if (semanticProfile && typeof semanticProfile === "object") {
        domains.push(...toStringList(semanticProfile.domain_scope));
    }
    for (const item of result.items.slice(0, 8)) {
        const source = item;
        domains.push(...toStringList(source.graph_domain_scope));
    }
    return uniqueStrings(domains.map((item) => item.toLowerCase()), 24);
}
function collectResultRelations(result) {
    const relations = [];
    const semanticProfile = summaryValue(result, "semantic_profile");
    if (semanticProfile && typeof semanticProfile === "object") {
        relations.push(...toStringList(semanticProfile.relation_patterns));
    }
    for (const item of result.items.slice(0, 8)) {
        const source = item;
        relations.push(...toStringList(source.relation_pattern_hits));
    }
    return uniqueStrings(relations.map((item) => item.toLowerCase()), 24);
}
function isSubstantiveResult(result) {
    if (result.status !== "ok" && result.status !== "partial") {
        return false;
    }
    return result.items.length > 0 || result.evidence.length > 0;
}
function evaluateP0DomainEvidenceGrounding(results, focusDomain) {
    if (!focusDomain) {
        return {
            has_primary: false,
            has_foreign_primary: false,
            foreign_primary_domains: [],
            blocked: false
        };
    }
    const substantive = results.filter((item) => isSubstantiveResult(item));
    if (substantive.length === 0) {
        return {
            has_primary: false,
            has_foreign_primary: false,
            foreign_primary_domains: [],
            blocked: false
        };
    }
    const classify = (result) => {
        const accounts = collectResultAccounts(result);
        const domains = collectResultDomains(result);
        const relations = collectResultRelations(result);
        let inDomain = false;
        let foreignDomains = [];
        if (focusDomain === "settlements_60_62") {
            inDomain =
                accounts.some((item) => isSettlementAccountToken(item) || /^(?:51|76)(?:\.|$)/.test(item)) ||
                    domains.some((item) => isSettlementDomainToken(item)) ||
                    relations.some((item) => /payment_to_settlement|statement_to_document|contract_to_documents|linked_to_settlement|settlement_closed/.test(item));
            foreignDomains = domains.filter((item) => isForeignToSettlementDomainToken(item));
        }
        else if (focusDomain === "vat_document_register_book") {
            inDomain =
                accounts.some((item) => isVatAccountToken(item)) ||
                    domains.some((item) => isVatDomainToken(item)) ||
                    relations.some((item) => /invoice_to_vat|source_doc_present|invoice_linked|book_entry_generated|deduction_posted|register_to_book|vat_/i.test(item));
            foreignDomains = domains.filter((item) => isForeignToVatDomainToken(item));
        }
        else if (focusDomain === "month_close_costs_20_44") {
            inDomain =
                accounts.some((item) => isCloseCostsAccountToken(item)) ||
                    domains.some((item) => isMonthCloseDomainToken(item)) ||
                    relations.some((item) => /costs_accumulated|allocation_rules_resolved|close_operation_runs|residuals_zero|close_operation|period_close|allocation|writeoff/i.test(item));
            foreignDomains = domains.filter((item) => isForeignToMonthCloseDomainToken(item));
        }
        return {
            inDomain,
            foreignDomains: uniqueStrings(foreignDomains, 8)
        };
    };
    const top = substantive[0];
    const topClass = classify(top);
    const hasAnyPrimary = substantive.some((item) => classify(item).inDomain);
    const hasForeignPrimary = topClass.foreignDomains.length > 0 && !topClass.inDomain;
    const topAccounts = collectResultAccounts(top);
    const topDomains = collectResultDomains(top);
    const topRelations = collectResultRelations(top);
    const vatPrimarySignals = topAccounts.filter((item) => isVatAccountToken(item)).length +
        topDomains.filter((item) => isVatDomainToken(item)).length +
        topRelations.filter((item) => /invoice_to_vat|source_doc_present|invoice_linked|register_to_book|book_entry_generated|deduction_posted|vat_/i.test(item)).length;
    const vatForeignSignals = topAccounts.filter((item) => isSettlementAccountToken(item) || isCloseCostsAccountToken(item)).length +
        topDomains.filter((item) => isForeignToVatDomainToken(item)).length +
        topRelations.filter((item) => /payment_to_settlement|statement_to_document|deferred_expense_to_writeoff|close_operation|allocation|period_close|fixed_asset/i.test(item)).length;
    const vatContaminatedPrimary = focusDomain === "vat_document_register_book" &&
        topClass.inDomain &&
        topClass.foreignDomains.length > 0 &&
        vatForeignSignals > Math.max(1, vatPrimarySignals) &&
        !hasControlledCrossDomainHandoffInResult(top);
    const blocked = (hasForeignPrimary && !hasAnyPrimary && !hasControlledCrossDomainHandoffInResult(top)) || vatContaminatedPrimary;
    return {
        has_primary: hasAnyPrimary,
        has_foreign_primary: hasForeignPrimary,
        foreign_primary_domains: topClass.foreignDomains,
        blocked
    };
}
function hasStrongNarrativeDomainSignalInText(userMessage, domain) {
    if (!domain) {
        return false;
    }
    const text = String(userMessage ?? "").toLowerCase();
    const accountTokens = extractAccountNumbersFromNarrativeText(text);
    if (domain === "settlements_60_62") {
        return (accountTokens.some((item) => isSettlementAccountToken(item)) ||
            /(60\.0[12]|62\.0[12]|долг|аванс|зач[её]т|взаимозач|расч[её]т|оплат|плат[её]ж|деньг[аи])/i.test(text));
    }
    if (domain === "vat_document_register_book") {
        return (accountTokens.some((item) => isVatAccountToken(item)) ||
            /(ндс|vat|сч[её]т(?:а|у|ом|е)?[-\s]?фактур(?:а|ы|е|у|ой)?|книг[аи]|регистр|вычет|налогов(?:ый|ого)?\s+эффект)/i.test(text));
    }
    if (domain === "month_close_costs_20_44") {
        return (accountTokens.some((item) => isCloseCostsAccountToken(item)) ||
            /(закрыти[ея]\s+месяц|закрытие\s+счетов|регламентн|косвенн|затрат|распределени|рбп|финансовых\s+результат|month\s*close|period\s*close|close\s+operation)/i.test(text));
    }
    return false;
}
function hasFixedAssetAmortizationSignalInText(userMessage) {
    const text = String(userMessage ?? "").toLowerCase();
    const explicitFixedAssetAccountMention = /(?:сч(?:е|ё)т(?:а|у|ом|ов)?\s*(?:№|#|:)?\s*0[12](?:\.\d{1,2})?|\b0[12]\s*\/\s*0[12]\b)/iu.test(text);
    return (explicitFixedAssetAccountMention ||
        /(основн(ые|ых|ым)?\s+средств|(?:^|[^a-zа-яё])ос(?:$|[^a-zа-яё])|амортиз|depreciat|fixed\s*asset)/i.test(text));
}
function hasExplicitMonthCloseSignalInText(userMessage) {
    const text = String(userMessage ?? "").toLowerCase();
    return /(закрыти[ея]\s+месяц|закрытие\s+счетов|регламентн|косвенн|затрат|распределени|рбп|финансовых\s+результат|month\s*close|period\s*close|close\s+operation)/i.test(text);
}
function inferP0FocusNarrativeDomain(userMessage, results, units, focusDomainHint) {
    const fromHint = p0NarrativeDomainFromHint(focusDomainHint);
    const fromMessage = inferNarrativeDomainFromText(userMessage);
    const strongFromMessage = Boolean(fromMessage && hasStrongNarrativeDomainSignalInText(userMessage, fromMessage));
    const fromDomainGuard = inferP0NarrativeDomainFromDomainGuards(results);
    const fixedAssetOnlySignal = hasFixedAssetAmortizationSignalInText(userMessage) && !hasExplicitMonthCloseSignalInText(userMessage);
    if (fromHint && fromMessage && fromHint !== fromMessage) {
        return strongFromMessage ? fromMessage : fromHint;
    }
    if (fromHint) {
        return fromHint;
    }
    if (fromDomainGuard === "month_close_costs_20_44" && fixedAssetOnlySignal) {
        return null;
    }
    if (fromDomainGuard && fromMessage && fromDomainGuard !== fromMessage) {
        return strongFromMessage ? fromMessage : fromDomainGuard;
    }
    if (fromDomainGuard) {
        return fromDomainGuard;
    }
    if (strongFromMessage) {
        return fromMessage;
    }
    if (fromMessage) {
        return fromMessage;
    }
    const semanticScopes = collectSemanticProfileScopes(results);
    const messageAccounts = extractAccountNumbersFromNarrativeText(userMessage);
    const hasExplicitP0AccountSignal = [...messageAccounts, ...semanticScopes.accounts].some((item) => isSettlementAccountToken(item) || isVatAccountToken(item) || isCloseCostsAccountToken(item));
    // Domain lock is only applied when we have an explicit P0 signal from the query/profile.
    if (!hasExplicitP0AccountSignal) {
        return null;
    }
    const fromUnits = inferP0NarrativeDomain(units);
    if (fromUnits) {
        return fromUnits;
    }
    if (semanticScopes.accounts.some((item) => isSettlementAccountToken(item))) {
        return "settlements_60_62";
    }
    if (semanticScopes.accounts.some((item) => isVatAccountToken(item))) {
        return "vat_document_register_book";
    }
    if (semanticScopes.accounts.some((item) => isCloseCostsAccountToken(item))) {
        return "month_close_costs_20_44";
    }
    if (semanticScopes.domains.some((item) => item.includes("bank_settlement") || item.includes("customer_settlement") || item === "settlements")) {
        return "settlements_60_62";
    }
    if (semanticScopes.domains.some((item) => item.includes("vat_flow"))) {
        return "vat_document_register_book";
    }
    if (semanticScopes.domains.some((item) => item.includes("period_close") || item.includes("deferred_expense") || item.includes("fixed_asset"))) {
        return "month_close_costs_20_44";
    }
    return null;
}
function domainNarrativeAnchor(domain) {
    if (domain === "settlements_60_62") {
        return "Оплата отражена, но ожидаемое закрытие расчета не подтверждено.";
    }
    if (domain === "vat_document_register_book") {
        return "По НДС переход от документа к регистру и книге подтвержден не полностью.";
    }
    if (domain === "month_close_costs_20_44") {
        return "Затраты накоплены, но распределение и закрытие месяца подтверждены частично.";
    }
    return null;
}
function buildMechanismNarrativeFromUnit(unit) {
    const candidates = [
        unit.mechanism_summary,
        unit.business_lifecycle_interpretation,
        unit.business_defect_class,
        unit.failed_expected_edge,
        unit.missing_transition,
        unit.invalid_transition,
        unit.lifecycle_defect_type
    ].filter((value) => typeof value === "string" && value.trim().length > 0);
    for (const candidate of candidates) {
        const stripped = candidate.replace(/^mechanism candidate:\s*/i, "").trim();
        const defectMapped = mapDefectTokenToNarrative(stripped);
        if (defectMapped) {
            return ensureSentence(defectMapped);
        }
        const humanizedToken = humanizeTechnicalToken(stripped);
        if (humanizedToken && !hasUserFacingLeakage(humanizedToken)) {
            return ensureSentence(humanizedToken);
        }
        const cleaned = sanitizeUserText(stripped);
        if (!cleaned) {
            continue;
        }
        const core = cleaned.replace(/[.,;:!?]+$/g, "");
        if (TECHNICAL_TOKEN_PATTERN.test(core) && /_/.test(core)) {
            continue;
        }
        if (hasUserFacingLeakage(core)) {
            continue;
        }
        return ensureSentence(cleaned);
    }
    const unitTypeNarrative = mapProblemUnitTypeToNarrative(unit.problem_unit_type);
    return unitTypeNarrative ? ensureSentence(unitTypeNarrative) : null;
}
function buildProblemCentricMechanismNarrative(input) {
    if (input.mode === "out_of_scope") {
        return "Запрос вне доступного учетного контура.";
    }
    if (input.mode === "route_mismatch") {
        return "Текущий результат не совпал с предметом вопроса, нужен более точный фокус.";
    }
    if (input.mode === "empty") {
        return "По заданному условию проблемный механизм в текущем срезе не подтвержден.";
    }
    if (input.mode === "no_grounded") {
        return "Подтвержденной опоры для механизма проблемы пока недостаточно.";
    }
    const narrativeDomain = input.forcedDomain ?? inferP0NarrativeDomain(input.units);
    const domainAnchor = domainNarrativeAnchor(narrativeDomain);
    const unitNarratives = dedupeNarrativeLines(input.units
        .map((unit) => buildMechanismNarrativeFromUnit(unit))
        .filter((value) => Boolean(value)), 4);
    const primary = (input.domainLockMiss ? null : unitNarratives[0]) ?? (domainAnchor ? ensureSentence(domainAnchor) : "");
    if (!primary) {
        if (input.mode === "clarification_required") {
            return "Есть признаки проблемы, но без уточнения периода и объекта вывод будет ненадежным и ограниченным.";
        }
        if (input.weakUnits) {
            return "Есть признаки проблемы, но подтверждение механизма пока частичное, поэтому вывод ограничен.";
        }
        return "Есть признаки проблемы в связанном контуре, требуется первичная проверка.";
    }
    const withoutDot = primary.replace(/[.!?]+$/u, "");
    if (input.domainLockMiss && domainAnchor) {
        return `${withoutDot}; по текущей опоре подтверждение частичное, нужна отдельная проверка расчетной связки.`;
    }
    if (input.mode === "clarification_required") {
        return `${withoutDot}, но для уверенного вывода нужны уточнения по периоду и объекту проверки; текущий вывод ограничен.`;
    }
    if (input.weakUnits) {
        return `${withoutDot}; подтверждение пока частичное, вывод ограничен.`;
    }
    return primary;
}
function humanizeFactForDirectAnswer(value) {
    if (!value) {
        return null;
    }
    const cleaned = sanitizeSupportLine(value);
    if (!cleaned) {
        return null;
    }
    const mapped = mapDefectTokenToNarrative(cleaned) ?? humanizeTechnicalToken(cleaned);
    if (mapped && !hasUserFacingLeakage(mapped)) {
        return ensureSentence(mapped);
    }
    const plain = sanitizeUserText(cleaned);
    if (!plain) {
        return null;
    }
    if (/^(?:record|entity|document)\b/i.test(plain)) {
        return null;
    }
    if (/^[\p{L}]+\s*\([^)]+\)\.?$/u.test(plain)) {
        return null;
    }
    if (/^\d+\.\s+/u.test(plain)) {
        return null;
    }
    const core = plain.replace(/[.,;:!?]+$/g, "");
    if (TECHNICAL_TOKEN_PATTERN.test(core) && /_/.test(core)) {
        return null;
    }
    return ensureSentence(plain);
}
function buildDirectAnswer(input) {
    const topFact = humanizeFactForDirectAnswer(firstMeaningfulFact(input.retrievalResults));
    const domainAnchor = domainNarrativeAnchor(input.focusDomain);
    const topFactDomain = topFact ? inferNarrativeDomainFromText(topFact) : null;
    const topFactAligned = Boolean(topFact) && (!input.focusDomain || topFactDomain === input.focusDomain);
    const preferredFact = topFactAligned ? topFact : null;
    if (input.mode === "focused_grounded") {
        return preferredFact ?? domainAnchor ?? "Проблема подтверждена на текущей опоре и готова к точечной проверке.";
    }
    if (input.mode === "broad_partial") {
        if (preferredFact) {
            return `${preferredFact.replace(/[.!?]+$/u, "")}; подтверждение пока частичное.`;
        }
        if (domainAnchor) {
            return `${domainAnchor.replace(/[.!?]+$/u, "")}; подтверждение пока частичное.`;
        }
        return "Есть признаки проблемы, но опора частичная и вывод ограничен.";
    }
    if (input.mode === "clarification_required") {
        return "Есть признаки проблемы, но без уточнений по периоду и объекту вывод ненадежен.";
    }
    if (input.mode === "out_of_scope") {
        return "Могу отвечать только в пределах данных доступного учетного контура.";
    }
    if (input.mode === "route_mismatch") {
        return "Предмет результата не совпал с предметом вопроса; нужен более точный фокус.";
    }
    if (input.mode === "empty") {
        return "В текущем срезе данных проблемный механизм по условию не подтвержден.";
    }
    if (input.mode === "no_grounded") {
        return "Недостаточно подтвержденной опоры для уверенного вывода.";
    }
    if (input.policySignals.minimum_evidence_failed) {
        return "Минимальная опора не набрана, поэтому вывод ограничен.";
    }
    return "Не удалось сформировать обоснованный ответ; нужно уточнение запроса.";
}
function buildProblemCentricAnswerSummary(input) {
    if (input.graphEnriched && input.summary?.graph_summary && input.summary.graph_summary.bound_units > 0) {
        if (input.mode === "clarification_required") {
            return "Выявлены связанные проблемные контуры, но для надежного вывода нужны предметные уточнения.";
        }
        return `Выявлены связанные проблемные контуры: подтверждены разрывы и конфликты между участками цепочки (${input.summary.graph_summary.bound_units} из ${input.summary.graph_summary.total_units} узлов).`;
    }
    if (input.lifecycleEnriched && input.summary?.lifecycle_enriched_units && input.summary.lifecycle_enriched_units > 0) {
        if (input.mode === "clarification_required") {
            return "Выявлены lifecycle-дефекты, но для надежного вывода нужны предметные уточнения.";
        }
        return `Выделены lifecycle-узлы с подтвержденными нарушениями переходов: ${input.summary.lifecycle_enriched_units}.`;
    }
    if (input.mode === "clarification_required") {
        return "Выявлены проблемные кластеры, но для надежного вывода требуется уточнение фокуса.";
    }
    if (input.weakUnits) {
        return "Сформирован problem-first срез с ограниченной опорой; вывод предварительный и требует проверки.";
    }
    if (input.summary?.units_total && input.summary.units_total > 1) {
        return `Сформирован problem-first срез: выделено ${input.summary.units_total} приоритетных проблемных кластеров.`;
    }
    return "Сформирован problem-first срез: выделен ключевой проблемный кластер и затронутый контур.";
}
function buildProblemCentricDirectAnswer(input) {
    const _lifecycleFlag = input.lifecycleAnswerEnabled;
    void _lifecycleFlag;
    return buildProblemCentricMechanismNarrative({
        mode: input.mode,
        units: input.units,
        weakUnits: input.weakUnits,
        forcedDomain: input.focusDomain,
        domainLockMiss: input.domainLockMiss
    });
}
function buildProblemCentricAnswerStructure(input) {
    const weakUnits = input.selectedUnits.every((item) => item.confidence.grade === "low");
    const lifecycleEnriched = input.lifecycleAnswerEnabled && hasLifecycleResolution(input.selectedUnits);
    const graphEnriched = hasGraphResolution(input.selectedUnits);
    const unitMechanismNotes = uniqueStrings(input.selectedUnits
        .map((item) => item.mechanism_summary)
        .filter((item) => typeof item === "string" && item.trim().length > 0), 6);
    const sourceRefs = uniqueStrings(input.evidenceItems
        .map((item) => item.source_ref?.canonical_ref)
        .filter((item) => typeof item === "string" && item.trim().length > 0), 6);
    const evidenceIds = uniqueStrings(input.evidenceItems.map((item) => item.evidence_id), 10);
    const aggregateEvidenceConfidence = aggregateConfidence(input.retrievalResults, input.evidenceItems);
    const hasCriticalEvidenceLimitation = input.limitationReasonCodes.includes("weak_source_mapping") ||
        input.limitationReasonCodes.includes("insufficient_detail");
    const confidenceLimited = input.mode !== "focused_grounded" ||
        weakUnits ||
        input.domainLockMiss ||
        input.limitationReasonCodes.includes("missing_mechanism") ||
        input.limitationReasonCodes.includes("heuristic_inference") ||
        hasCriticalEvidenceLimitation ||
        aggregateEvidenceConfidence === "low";
    const mechanismStatus = unitMechanismNotes.length === 0
        ? "unresolved"
        : confidenceLimited
            ? "limited"
            : "grounded";
    const problemSpecificLimitations = [];
    if (input.domainLockMiss && input.focusDomain) {
        problemSpecificLimitations.push("Текущая выборка не подтвердила целевой механизм домена в явном виде; вывод ограничен.");
    }
    if (weakUnits) {
        problemSpecificLimitations.push("Problem units remain weak-confidence; conclusions are intentionally limited.");
    }
    if (input.problemSummary?.duplicate_collapses && input.problemSummary.duplicate_collapses > 0) {
        problemSpecificLimitations.push("Part of the problem signal was merged due to duplicate collapse.");
    }
    const limitations = uniqueStrings([
        ...problemSpecificLimitations,
        ...(input.missingAnchors.period ? ["Период в запросе не указан; вывод ограничен и требует проверки в конкретном периоде."] : []),
        ...input.limitationReasonCodes.map((code) => limitationReasonToText(code)),
        ...extractLimitations(input.retrievalResults),
        ...input.groundingCheck.reasons
    ], 10);
    const openUncertainties = uniqueStrings([
        ...input.groundingCheck.missing_requirements,
        ...(input.domainLockMiss ? ["primary_domain_evidence_not_confirmed"] : []),
        ...(input.missingAnchors.period ? ["missing_anchor:period"] : []),
        ...(input.mode === "clarification_required" && input.missingAnchors.account ? ["missing_anchor:account"] : []),
        ...(input.mode === "clarification_required" && input.missingAnchors.documentOrObject
            ? ["missing_anchor:document_or_object"]
            : []),
        ...(input.mode === "clarification_required" && input.missingAnchors.counterparty ? ["missing_anchor:counterparty"] : [])
    ], 8);
    return {
        schema_version: "answer_structure_v1_1",
        answer_summary: buildProblemCentricAnswerSummary({
            mode: input.mode,
            weakUnits,
            summary: input.problemSummary,
            lifecycleEnriched,
            graphEnriched
        }),
        direct_answer: buildProblemCentricDirectAnswer({
            mode: input.mode,
            units: input.selectedUnits,
            weakUnits,
            lifecycleAnswerEnabled: input.lifecycleAnswerEnabled,
            focusDomain: input.focusDomain,
            domainLockMiss: input.domainLockMiss
        }),
        mechanism_block: {
            status: mechanismStatus,
            mechanism_notes: unitMechanismNotes,
            limitation_reason_codes: input.limitationReasonCodes
        },
        evidence_block: {
            evidence_ids: evidenceIds,
            source_refs: sourceRefs,
            mechanism_notes: unitMechanismNotes,
            coverage_note: input.coverageReport.requirements_total > 0 &&
                input.coverageReport.requirements_total === input.coverageReport.requirements_covered &&
                input.coverageReport.requirements_uncovered.length === 0 &&
                input.coverageReport.requirements_partially_covered.length === 0
                ? "coverage_full_or_near_full"
                : "coverage_partial_or_limited",
            ...(input.claimEvidenceLinks.length > 0
                ? {
                    claim_evidence_links: input.claimEvidenceLinks
                }
                : {})
        },
        uncertainty_block: {
            open_uncertainties: openUncertainties,
            limitations
        },
        next_step_block: {
            recommended_actions: buildProblemCentricActions({
                units: input.selectedUnits,
                mode: input.mode,
                missingAnchors: input.missingAnchors,
                coverageReport: input.coverageReport,
                focusDomain: input.focusDomain
            }),
            clarification_questions: buildProblemCentricClarifications({
                units: input.selectedUnits,
                missingAnchors: input.missingAnchors,
                coverageReport: input.coverageReport,
                mode: input.mode
            })
        }
    };
}
function limitationReasonToUserText(code) {
    if (code === "snapshot_only")
        return "Оценка построена на snapshot-срезе и может не включать самые свежие изменения.";
    if (code === "heuristic_inference")
        return "Часть вывода построена эвристически и требует проверки в базе.";
    if (code === "missing_mechanism")
        return "Механизм проблемы подтвержден не полностью.";
    if (code === "weak_source_mapping")
        return "Связка между источниками подтверждена частично.";
    if (code === "insufficient_detail")
        return "В данных не хватает деталей для сильного вывода.";
    return "Есть ограничения по качеству опоры.";
}
function inferNarrativeDomainFromText(value) {
    const text = String(value ?? "").toLowerCase();
    const accountTokens = extractAccountNumbersFromNarrativeText(text);
    const fixedAssetSignal = hasFixedAssetAmortizationSignalInText(text);
    const explicitMonthCloseSignal = hasExplicitMonthCloseSignalInText(text);
    let settlementScore = 0;
    let vatScore = 0;
    let monthCloseScore = 0;
    if (accountTokens.some((token) => isSettlementAccountToken(token))) {
        settlementScore += 3;
    }
    if (accountTokens.some((token) => isVatAccountToken(token))) {
        vatScore += 3;
    }
    if (accountTokens.some((token) => isCloseCostsAccountToken(token))) {
        monthCloseScore += 3;
    }
    if (/(долг|аванс|взаимозач|зачет|зачёт|62\.01|62\.02|60\.01|60\.02|не\s+сход)/i.test(text)) {
        settlementScore += 2;
    }
    if (/(расч[её]т|оплат|плат[её]ж|деньг[аи]|закрыти[ея]\s+расч)/i.test(text)) {
        settlementScore += 2;
    }
    if (/(ндс|vat|сч[её]т(?:а|у|ом|е)?[-\s]?фактур(?:а|ы|е|у|ой)?|книг[аи]|регистр|вычет|налогов(?:ый|ого)?\s+эффект)/i.test(text)) {
        vatScore += 3;
    }
    if (explicitMonthCloseSignal) {
        monthCloseScore += 3;
    }
    if (fixedAssetSignal && !explicitMonthCloseSignal && settlementScore === 0 && vatScore === 0) {
        return null;
    }
    const maxScore = Math.max(settlementScore, vatScore, monthCloseScore);
    if (maxScore <= 0) {
        return null;
    }
    // Tie-break prioritizes explicit VAT and month-close lexical markers over broad settlement wording.
    if (vatScore === maxScore) {
        return "vat_document_register_book";
    }
    if (monthCloseScore === maxScore) {
        return "month_close_costs_20_44";
    }
    if (settlementScore === maxScore) {
        return "settlements_60_62";
    }
    return null;
}
function isIncompleteEvidence(structure) {
    return (structure.mechanism_block.status !== "grounded" ||
        structure.evidence_block.coverage_note !== "coverage_full_or_near_full" ||
        structure.uncertainty_block.limitations.length > 0 ||
        structure.uncertainty_block.open_uncertainties.length > 0);
}
function buildShortSectionLine(structure) {
    const broken = sanitizeUserText(structure.direct_answer) ?? "";
    const domain = inferNarrativeDomainFromText(broken);
    const incomplete = isIncompleteEvidence(structure);
    const shortSeed = `${domain}|${incomplete ? "partial" : "grounded"}|${broken}`;
    if (/вне доступного учетного контура/i.test(broken)) {
        return "Запрос вне доступного учетного контура.";
    }
    if (/не совпал с предметом вопроса|более точный фокус/i.test(broken)) {
        return pickDeterministicBoundaryVariant(shortSeed, [
            "Требуется уточнить фокус, чтобы ответить по нужному участку учета.",
            "Сейчас не хватает точного фокуса вопроса для надежного вывода.",
            "Нужна чуть более точная формулировка фокуса запроса."
        ]);
    }
    if (/ненадежен|уточнен/i.test(broken)) {
        return pickDeterministicBoundaryVariant(shortSeed, [
            "Сигналы есть, но для уверенного вывода нужны уточнения.",
            "Картина пока частичная: подтверждения есть, но не хватает уточнений.",
            "Промежуточный вывод собран, однако без уточнений он остается ограниченным."
        ]);
    }
    if (domain === "settlements_60_62") {
        return incomplete
            ? pickDeterministicBoundaryVariant(shortSeed, [
                "По взаиморасчетам видны признаки неполного закрытия, но картина пока частичная.",
                "Есть подтвержденные сигналы разрыва закрытия расчетов, часть вывода остается ограниченной.",
                "Риск незакрытых взаиморасчетов подтвержден частично и требует уточнения."
            ])
            : pickDeterministicBoundaryVariant(shortSeed, [
                "Проблема с закрытием расчетов подтверждена на текущей опоре.",
                "Разрыв в закрытии взаиморасчетов подтвержден.",
                "По текущей опоре несходимость в закрытии расчетов подтверждена."
            ]);
    }
    if (domain === "vat_document_register_book") {
        return incomplete
            ? pickDeterministicBoundaryVariant(shortSeed, [
                "В цепочке НДС есть подтвержденные отклонения, но пока не по всем звеньям.",
                "Сигналы по НДС подтверждены частично; для полного вывода нужна дополнительная проверка.",
                "Есть частичное подтверждение разрыва в НДС-контуре."
            ])
            : pickDeterministicBoundaryVariant(shortSeed, [
                "Проблема в цепочке НДС подтверждена.",
                "Разрыв в НДС-контуре подтвержден на текущей опоре.",
                "По НДС выявлен и подтвержден проблемный переход в цепочке."
            ]);
    }
    if (domain === "month_close_costs_20_44") {
        return incomplete
            ? pickDeterministicBoundaryVariant(shortSeed, [
                "По закрытию месяца есть проблемные сигналы, но они подтверждены частично.",
                "Контур 20/44 показывает частично подтвержденные отклонения закрытия.",
                "Есть признаки сбоя в закрытии месяца, однако опора пока неполная."
            ])
            : pickDeterministicBoundaryVariant(shortSeed, [
                "Проблема в контуре закрытия месяца подтверждена.",
                "Сбой в закрытии месяца подтвержден на текущей выборке.",
                "Разрыв в контуре 20/44 подтвержден."
            ]);
    }
    return incomplete
        ? pickDeterministicBoundaryVariant(shortSeed, [
            "Есть подтвержденные сигналы, но вывод пока частичный.",
            "Промежуточная проверка выявила проблему, однако опора еще неполная.",
            "Часть признаков подтверждена, для полного вывода нужна допроверка."
        ])
        : pickDeterministicBoundaryVariant(shortSeed, [
            "Проблема подтверждена на текущей опоре.",
            "Текущая опора подтверждает наличие проблемы.",
            "Подтверждение проблемы по текущей выборке получено."
        ]);
}
function humanizeCompositeDirectAnswer(value) {
    const raw = String(value ?? "").trim();
    if (!raw) {
        return null;
    }
    const tokenPattern = /\b[a-z][a-z0-9_:-]{2,}\b/gi;
    const tokenMappings = uniqueStrings(Array.from(raw.matchAll(tokenPattern))
        .map((match) => humanizeTechnicalToken(String(match?.[0] ?? "")))
        .filter((item) => Boolean(item))
        .map((item) => ensureSentence(item)), 4);
    const residualRaw = raw
        .replace(tokenPattern, " ")
        .replace(/[()]/g, " ")
        .replace(/\s*[;:]\s*/g, " ")
        .replace(/\s{2,}/g, " ")
        .trim();
    const residualText = sanitizeUserText(residualRaw);
    const lines = [...tokenMappings];
    if (residualText && !hasUserFacingLeakage(residualText)) {
        lines.push(ensureSentence(residualText));
    }
    const compact = dedupeNarrativeLines(lines, 3);
    if (compact.length === 0) {
        return null;
    }
    return compact.join(" ");
}
function buildBrokenSectionLines(structure) {
    const direct = sanitizeUserText(structure.direct_answer);
    if (direct) {
        if (/\b[a-z]+_[a-z0-9_:-]+\b/i.test(direct)) {
            const compositeHumanized = humanizeCompositeDirectAnswer(direct);
            if (compositeHumanized) {
                return [compositeHumanized];
            }
        }
        const mapped = mapDefectTokenToNarrative(direct) ?? humanizeTechnicalToken(direct);
        if (mapped) {
            return [ensureSentence(mapped)];
        }
        if (/[a-z]/i.test(direct) && !/[а-яё]/iu.test(direct)) {
            return ["Ожидаемый переход в учетной цепочке не подтвержден."];
        }
        return [ensureSentence(direct)];
    }
    return ["Есть признаки нарушения в связанной цепочке документов и проводок."];
}
function buildWhySectionLines(structure, context) {
    const noteLines = dedupeNarrativeLines(structure.mechanism_block.mechanism_notes
        .map((item) => sanitizeSupportLine(item))
        .filter((item) => Boolean(item))
        .map((item) => mapDefectTokenToNarrative(item) ?? humanizeTechnicalToken(item) ?? item), 4);
    const domain = context?.focusDomain ?? inferNarrativeDomainFromText(sanitizeUserText(structure.direct_answer) ?? "");
    const mechanismCorpus = `${structure.direct_answer} ${structure.mechanism_block.mechanism_notes.join(" ")} ${structure.evidence_block.mechanism_notes.join(" ")}`;
    const fixedAssetContextSignal = hasFixedAssetContextSignal(context);
    const fixedAssetSignal = fixedAssetContextSignal ||
        ((context?.focusDomain ?? null) !== "settlements_60_62" && hasFixedAssetSignalInStructure(structure, context));
    const rbpSignal = hasRbpContextSignal(context) || hasRbpSignalInText(mechanismCorpus);
    const lines = [...noteLines];
    if (structure.mechanism_block.status === "grounded") {
        lines.push("Признак проблемы повторяется в связанных документах и проводках.");
    }
    else if (structure.mechanism_block.status === "limited") {
        if (domain === "vat_document_register_book") {
            lines.push("Часть НДС-цепочки подтверждена, но один или несколько переходов документ -> счет-фактура -> регистр -> книга не подтверждены.");
        }
        else if (fixedAssetSignal) {
            lines.push("По ОС часть переходов к начислению амортизации подтверждена не полностью, поэтому есть риск пропуска отдельных объектов.");
        }
        else if (rbpSignal) {
            lines.push("По РБП часть списаний к концу периода подтверждена не полностью, поэтому остаток может сохраняться дольше ожидаемого.");
        }
        else if (domain === "month_close_costs_20_44") {
            lines.push("Часть шагов закрытия периода подтверждена, но ключевой переход распределения/закрытия не подтвержден.");
        }
        else {
            lines.push("Часть ожидаемой цепочки подтверждена, но ключевой переход не подтвержден.");
        }
    }
    else {
        lines.push("Сигнал проблемы есть, но механизм подтвержден не полностью.");
    }
    return dedupeNarrativeLines(lines, 3);
}
function extractRequirementIdsFromText(value) {
    const matches = String(value ?? "").match(/\bR\d+\b/gi);
    return uniqueStrings((matches ?? []).map((item) => item.toUpperCase()), 8);
}
function buildCoverageSplitLines(structure, questionType = "unknown") {
    const confirmed = uniqueStrings((structure.evidence_block.claim_evidence_links ?? [])
        .flatMap((item) => extractRequirementIdsFromText(item.claim_ref))
        .map((item) => item.toUpperCase()), 8);
    const unresolved = uniqueStrings(structure.uncertainty_block.open_uncertainties.flatMap((item) => extractRequirementIdsFromText(item)), 8);
    const lines = [];
    if (questionType === "which_chains_are_complete_vs_incomplete") {
        if (confirmed.length > 0) {
            lines.push(`Цепочки подтверждены: ${confirmed.join(", ")}.`);
        }
        if (unresolved.length > 0) {
            lines.push(`Цепочки подтверждены частично или не подтверждены: ${unresolved.join(", ")}.`);
        }
        else if (structure.evidence_block.coverage_note === "coverage_partial_or_limited") {
            lines.push("Часть цепочек подтверждена частично; для остальных не хватает опоры.");
        }
        if (lines.length === 0) {
            lines.push("Цепочки пока не удалось уверенно разделить на полные и неполные.");
        }
        return dedupeNarrativeLines(lines, 3);
    }
    if (confirmed.length > 0) {
        lines.push(`Подтверждено по требованиям: ${confirmed.join(", ")}.`);
    }
    if (unresolved.length > 0) {
        lines.push(`Отдельно не подтверждено или покрыто частично: ${unresolved.join(", ")}.`);
    }
    else if (structure.evidence_block.coverage_note === "coverage_partial_or_limited") {
        lines.push("Подтверждена только часть запроса; оставшаяся часть вынесена в ограничения.");
    }
    return dedupeNarrativeLines(lines, 3);
}
function buildEvidenceSectionLines(structure, questionType = "unknown", context) {
    const evidenceCount = Array.isArray(structure.evidence_block.evidence_ids) ? structure.evidence_block.evidence_ids.length : 0;
    const sourceCount = Array.isArray(structure.evidence_block.source_refs) ? structure.evidence_block.source_refs.length : 0;
    const claimLinks = Array.isArray(structure.evidence_block.claim_evidence_links)
        ? structure.evidence_block.claim_evidence_links.length
        : 0;
    const reliabilityLimited = structure.mechanism_block.status !== "grounded" ||
        structure.uncertainty_block.limitations.length > 0 ||
        structure.uncertainty_block.open_uncertainties.length > 0 ||
        structure.evidence_block.coverage_note === "coverage_partial_or_limited";
    const lines = [];
    const coverageSplitLines = buildCoverageSplitLines(structure, questionType);
    const domain = context?.focusDomain ?? inferNarrativeDomainFromText(sanitizeUserText(structure.direct_answer) ?? "");
    const evidenceCorpus = `${structure.direct_answer} ${structure.mechanism_block.mechanism_notes.join(" ")} ${structure.evidence_block.mechanism_notes.join(" ")}`;
    const fixedAssetContextSignal = hasFixedAssetContextSignal(context);
    const fixedAssetSignal = fixedAssetContextSignal ||
        ((context?.focusDomain ?? null) !== "settlements_60_62" && hasFixedAssetSignalInStructure(structure, context));
    const rbpSignal = hasRbpContextSignal(context) || hasRbpSignalInText(evidenceCorpus);
    if (questionType === "what_is_it_grounded_on") {
        if (domain === "vat_document_register_book") {
            lines.push("Основание собрано по НДС-цепочке: документ, счет-фактура, регистр НДС и запись книги.");
        }
        else if (fixedAssetSignal) {
            lines.push("Основание собрано по ОС: карточка объекта, параметры амортизации, начисление и движения по 01/02.");
        }
        else if (rbpSignal) {
            lines.push("Основание собрано по РБП: объект списания, документ списания и остаток на конец периода.");
        }
        else {
            lines.push("Основание вывода перечислено по подтвержденным документам, регистрам и проводкам.");
        }
    }
    else if (questionType === "prove_or_guess") {
        lines.push("Основание разделено на подтвержденную часть и зону гипотез.");
    }
    else if (questionType === "which_chains_are_complete_vs_incomplete") {
        if (domain === "vat_document_register_book") {
            lines.push("Опора собрана по звеньям НДС-цепочки, чтобы разделить полные и неполные переходы.");
        }
        else if (rbpSignal) {
            lines.push("Опора собрана по РБП-цепочке, чтобы разделить подтвержденное и неподтвержденное списание.");
        }
        else if (fixedAssetSignal) {
            lines.push("Опора собрана по ОС-цепочке, чтобы разделить подтвержденные и неподтвержденные начисления амортизации.");
        }
        else {
            lines.push("Опора собрана так, чтобы разделить цепочки на полные и неполные.");
        }
    }
    if (evidenceCount > 0) {
        lines.push(`Вывод опирается на ${evidenceCount} подтвержденных наблюдений в текущем срезе.`);
    }
    if (sourceCount > 0) {
        lines.push(`Проверены связанные документы и проводки по ${sourceCount} источникам.`);
    }
    if (claimLinks > 0) {
        lines.push("Есть связка между основным выводом и подтверждающими записями.");
    }
    if (structure.evidence_block.coverage_note === "coverage_partial_or_limited" || reliabilityLimited) {
        if (domain === "vat_document_register_book") {
            lines.push("Опора частичная: по НДС-цепочке не подтверждены одно или несколько звеньев.");
        }
        else if (fixedAssetSignal) {
            lines.push("Опора частичная: не по всем объектам ОС подтверждено попадание в начисление амортизации.");
        }
        else if (rbpSignal) {
            lines.push("Опора частичная: не по всем объектам РБП подтверждено списание к концу периода.");
        }
        else if (structure.evidence_block.coverage_note === "coverage_partial_or_limited") {
            lines.push("Опора частичная: часть требований покрыта не полностью.");
        }
        else if (evidenceCount > 0) {
            lines.push("Опора есть, но достаточна только для предварительного вывода.");
        }
    }
    else if (evidenceCount > 0) {
        lines.push("Опора достаточна для первичного вывода.");
    }
    if (lines.length === 0) {
        lines.push("Использована доступная выборка документов и проводок в текущем snapshot.");
    }
    return dedupeNarrativeLines([...lines, ...coverageSplitLines], 6);
}
function buildDefaultChecksByDomain(domain) {
    if (domain === "settlements_60_62") {
        return [
            "Сверьте договор и объект расчетов, затем подтвердите запись в регистре расчетов и документ зачета.",
            "Проверьте связку платеж -> расчетный документ -> проводки по 60/62/76 и факт закрытия хвоста."
        ];
    }
    if (domain === "vat_document_register_book") {
        return [
            "Проверьте связку: исходный документ -> запись регистра НДС -> запись в книге.",
            "Сверьте счет-фактуру и момент отражения вычета в нужном периоде."
        ];
    }
    if (domain === "month_close_costs_20_44") {
        return [
            "Проверьте накопление и распределение затрат по счетам 20-44 перед закрытием месяца.",
            "Сверьте регламентную операцию закрытия и остатки, которые должны быть нулевыми или объясненными."
        ];
    }
    return ["Проверьте связку документов и проводок по проблемному участку в указанном периоде."];
}
function hasFixedAssetAnchorContext(context) {
    if (!context) {
        return false;
    }
    const corpus = [...context.anchors.present, ...context.anchors.used].join(" ").toLowerCase();
    return /(?:doc_type:amortization|account:0[12]|амортиз|основн|(?:^|[^a-zа-яё])ос(?:$|[^a-zа-яё])|fixed\s*asset|depreciat)/i.test(corpus);
}
function hasFixedAssetContextSignal(context) {
    if (!context) {
        return false;
    }
    const corpus = [...context.anchors.present, ...context.anchors.used, context.userMessage ?? ""].join(" ").toLowerCase();
    return (hasFixedAssetAnchorContext(context) ||
        hasFixedAssetAmortizationSignalInText(corpus) ||
        /(?:\bос\b|основн(?:ые|ых)?\s+средств|амортиз|сч(?:е|ё)т\s*0[12])/i.test(corpus));
}
function hasRbpAnchorContext(context) {
    if (!context) {
        return false;
    }
    const corpus = [...context.anchors.present, ...context.anchors.used].join(" ").toLowerCase();
    return /(?:\brbp(?:[_\s-]?writeoff)?\b|рбп|deferred[_\s-]?expense(?:[_\s-]?to[_\s-]?writeoff)?|doc_type:(?:deferred|rbp_writeoff)|счет\s*97|account:97)/i.test(corpus);
}
function hasRbpContextSignal(context) {
    if (!context) {
        return false;
    }
    const corpus = [...context.anchors.present, ...context.anchors.used, context.userMessage ?? ""].join(" ");
    return hasRbpAnchorContext(context) || hasRbpSignalInText(corpus);
}
function hasRbpSignalInText(value) {
    const text = String(value ?? "").toLowerCase();
    return /(?:\brbp(?:[_\s-]?writeoff)?\b|рбп|deferred[_\s-]?expense(?:[_\s-]?to[_\s-]?writeoff)?|счет\s*97|списани[ея]\s+рбп|остат(ок|ки)\s+рбп)/i.test(text);
}
function hasFixedAssetSignalInStructure(structure, context) {
    const corpus = [
        structure.direct_answer,
        ...structure.mechanism_block.mechanism_notes,
        ...structure.evidence_block.mechanism_notes,
        ...(structure.evidence_block.source_refs ?? []),
        ...(structure.evidence_block.evidence_ids ?? []),
        ...(context?.anchors.present ?? []),
        ...(context?.anchors.used ?? [])
    ]
        .filter(Boolean)
        .join(" ");
    if (hasFixedAssetAnchorContext(context) || hasFixedAssetAmortizationSignalInText(corpus)) {
        return true;
    }
    return /(?:asset_card_to_depreciation|fixed_asset|fixed_assets|амортиз|основн(?:ые|ых)?\s+средств|сч(?:е|ё)т\s*0[12]|\b0[12](?:\.\d{2})?\b)/i.test(corpus);
}
function buildFixedAssetChecksByQuestionType(questionType) {
    if (questionType === "what_to_check_first") {
        return [
            "Проверьте по каждому объекту ОС карточку и параметр амортизации (способ, срок, дата начала начисления).",
            "Сверьте ввод в эксплуатацию и попадание объекта в набор начисления амортизации за нужный период.",
            "Подтвердите начисление по объектам проводками и регистром амортизации."
        ];
    }
    if (questionType === "prove_or_guess") {
        return [
            "Разделите доказанные и предположительные участки по цепочке ОС: принятие -> ввод -> начисление амортизации.",
            "Проверьте, какие объекты отсутствуют в наборе начисления или имеют некорректные параметры амортизации."
        ];
    }
    if (questionType === "where_break_is") {
        return [
            "Локализуйте разрыв в цепочке ОС: карточка объекта -> ввод в эксплуатацию -> начисление амортизации.",
            "Сверьте, на каком шаге пропадает подтверждение по конкретным объектам."
        ];
    }
    if (questionType === "what_is_it_grounded_on") {
        return [
            "Перечислите основание: карточка ОС, документ ввода в эксплуатацию, запись регистра амортизации, проводки по начислению."
        ];
    }
    return [
        "Проверьте ОС-контур: объект ОС -> ввод в эксплуатацию -> начисление амортизации по счетам 01/02.",
        "Сверьте параметр амортизации и наличие начисления по каждому объекту ОС в периоде."
    ];
}
function buildRbpChecksByQuestionType(questionType) {
    if (questionType === "what_to_check_first") {
        return [
            "Проверьте список объектов РБП, которые должны были списаться к концу периода.",
            "Сверьте документ списания РБП и движение по счету 97 по каждому объекту.",
            "Проверьте остаток РБП после списания и причину, если часть суммы остается активной."
        ];
    }
    if (questionType === "prove_or_guess") {
        return [
            "Разделите по РБП доказанное и гипотезу: где списание подтверждено, а где есть только косвенные признаки.",
            "Проверьте, для каких объектов РБП нет подтверждения списания на конец периода."
        ];
    }
    if (questionType === "where_break_is") {
        return [
            "Локализуйте разрыв в РБП-цепочке: объект РБП -> документ списания -> движение по счету 97.",
            "Проверьте, на каком шаге исчезает подтверждение списания."
        ];
    }
    if (questionType === "what_is_it_grounded_on") {
        return [
            "Перечислите основание по РБП: объект, документ списания, движение по счету 97, остаток на конец периода."
        ];
    }
    if (questionType === "which_chains_are_complete_vs_incomplete") {
        return [
            "Разделите РБП-цепочки на: списание подтверждено, подтверждено частично, не подтверждено.",
            "Проверьте, где к концу периода остается РБП без подтвержденного списания."
        ];
    }
    return [
        "Проверьте РБП-контур: объект РБП -> документ списания -> движение по счету 97.",
        "Сверьте остаток РБП на конец периода и причину, если часть суммы не списана."
    ];
}
function buildQuestionTypeDomainChecks(questionType, domain) {
    if (questionType === "what_to_check_first") {
        if (domain === "settlements_60_62") {
            return [
                "Сверьте договор и объект расчетов по спорной операции.",
                "Проверьте регистр расчетов и зачет аванса/взаимозачет.",
                "Подтвердите проводки по 60/62/76 и факт закрытия хвоста."
            ];
        }
        if (domain === "vat_document_register_book") {
            return [
                "Сверьте исходный документ и счет-фактуру.",
                "Проверьте запись в регистре НДС и попадание в книгу.",
                "Подтвердите налоговые проводки по 19/68 в нужном периоде."
            ];
        }
        if (domain === "month_close_costs_20_44") {
            return [
                "Проверьте регламентную операцию закрытия за нужный период.",
                "Сверьте базу распределения затрат и проводки по 20/25/26/44.",
                "Убедитесь, что остатки объяснены или закрыты после операции."
            ];
        }
        return ["Начните с первого подтверждаемого документа и пройдите цепочку без пропусков."];
    }
    if (questionType === "where_break_is") {
        if (domain === "settlements_60_62") {
            return [
                "Локализуйте разрыв в узле: договор -> объект расчетов -> регистр расчетов -> закрывающий документ.",
                "Сверьте, где прерывается переход платеж -> зачет/закрытие -> проводки 60/62/76."
            ];
        }
        if (domain === "vat_document_register_book") {
            return [
                "Локализуйте разрыв в узле: документ -> счет-фактура -> регистр НДС -> книга.",
                "Сверьте, где прерывается переход от исходного документа к налоговой записи."
            ];
        }
        if (domain === "month_close_costs_20_44") {
            return [
                "Локализуйте разрыв в узле: накопление затрат -> правило распределения -> операция закрытия.",
                "Сверьте, на каком шаге исчезает подтверждение перехода к закрытию остатков."
            ];
        }
    }
    if (questionType === "prove_or_guess") {
        if (domain === "settlements_60_62") {
            return [
                "Отдельно отметьте, что доказано документами и проводками, а что остается гипотезой.",
                "Для доказательства проверьте связку платеж -> расчетный документ -> регистр расчетов -> 60/62/76."
            ];
        }
        if (domain === "vat_document_register_book") {
            return [
                "Разделите доказанное и предположительное по цепочке: документ -> счет-фактура -> регистр -> книга.",
                "Подтвердите налоговую запись по 19/68 в нужном периоде."
            ];
        }
        if (domain === "month_close_costs_20_44") {
            return [
                "Разделите доказанные и предположительные участки в цепочке закрытия месяца.",
                "Проверьте подтверждение: операция закрытия -> распределение -> остатки по 20/25/26/44."
            ];
        }
    }
    if (questionType === "what_is_it_grounded_on") {
        if (domain === "settlements_60_62") {
            return [
                "Перечислите основание: платежный документ, расчетный документ, запись регистра расчетов, проводки 60/62/76."
            ];
        }
        if (domain === "vat_document_register_book") {
            return [
                "Перечислите основание: исходный документ, счет-фактура, запись регистра НДС, запись книги, проводки 19/68."
            ];
        }
        if (domain === "month_close_costs_20_44") {
            return [
                "Перечислите основание: операция закрытия, база распределения, проводки по затратам, остатки после закрытия."
            ];
        }
    }
    if (questionType === "which_chains_are_complete_vs_incomplete") {
        if (domain === "settlements_60_62") {
            return [
                "Разделите цепочки на: подтверждена, подтверждена частично, не подтверждена по переходу платеж -> закрытие расчета.",
                "Проверьте разницу между закрытыми и незакрытыми связками по 60/62/76."
            ];
        }
        if (domain === "vat_document_register_book") {
            return [
                "Разделите цепочки на: полная, частичная, неполная по связке документ -> счет-фактура -> регистр -> книга.",
                "Проверьте, где отсутствует подтверждение налоговой записи."
            ];
        }
        if (domain === "month_close_costs_20_44") {
            return [
                "Разделите цепочки закрытия на полные и неполные по шагам распределения и регламентной операции.",
                "Проверьте, какие остатки после закрытия подтверждены, а какие нет."
            ];
        }
    }
    return buildDefaultChecksByDomain(domain);
}
function buildChecksSectionLines(structure, context) {
    const actionLines = dedupeNarrativeLines([
        ...structure.next_step_block.recommended_actions,
        ...structure.next_step_block.clarification_questions
    ]
        .map((item) => sanitizeSupportLine(item))
        .filter((item) => Boolean(item))
        .filter((item) => !hasUserFacingLeakage(item))
        .filter((item) => /[а-яё]/iu.test(item))
        .filter((item) => item.length >= 18)
        .filter((item) => !/\b(?:factual|source-of-record|reference)\b/i.test(item)), 4);
    const broken = sanitizeUserText(structure.direct_answer) ?? "";
    const domain = context?.focusDomain ?? inferNarrativeDomainFromText(broken);
    const questionType = context?.questionType ?? "unknown";
    const effectiveQuestionType = questionType === "unknown" ? "what_to_check_first" : questionType;
    const fixedAssetMechanismSignal = hasFixedAssetAmortizationSignalInText(`${structure.direct_answer} ${structure.mechanism_block.mechanism_notes.join(" ")} ${structure.evidence_block.mechanism_notes.join(" ")}`);
    const domainAndEvidenceCorpus = `${broken} ${structure.mechanism_block.mechanism_notes.join(" ")} ${structure.evidence_block.mechanism_notes.join(" ")}`;
    const fixedAssetContextSignal = hasFixedAssetContextSignal(context);
    const fixedAssetCase = fixedAssetContextSignal ||
        (domain !== "settlements_60_62" && (hasFixedAssetSignalInStructure(structure, context) || fixedAssetMechanismSignal));
    const rbpCase = hasRbpContextSignal(context) || hasRbpSignalInText(domainAndEvidenceCorpus);
    const domainFallback = fixedAssetCase
        ? buildFixedAssetChecksByQuestionType(effectiveQuestionType)
        : rbpCase
            ? buildRbpChecksByQuestionType(effectiveQuestionType)
            : buildQuestionTypeDomainChecks(questionType, domain);
    const hasMissingPeriod = structure.uncertainty_block.open_uncertainties.some((item) => /missing_anchor:period/i.test(String(item ?? "")));
    const lines = [];
    if (questionType === "what_to_check_first") {
        lines.push(...domainFallback.slice(0, 3));
        if (lines.length < 3) {
            lines.push(...actionLines.slice(0, 3 - lines.length));
        }
    }
    else if (questionType === "what_is_it_grounded_on") {
        lines.push(...domainFallback.slice(0, 2));
        lines.push(...actionLines.slice(0, 1));
    }
    else if (questionType === "prove_or_guess" || questionType === "where_break_is") {
        lines.push(...domainFallback.slice(0, 2));
        lines.push(...actionLines.slice(0, 2));
    }
    else {
        if (domain === "settlements_60_62") {
            lines.push(...domainFallback.slice(0, 2));
            lines.push(...actionLines.slice(0, 2));
        }
        else {
            lines.push(...domainFallback.slice(0, 1));
            lines.push(...actionLines.slice(0, 2));
            if (lines.length < 2) {
                lines.push(...domainFallback.slice(1, 2));
            }
        }
    }
    const filteredLines = fixedAssetCase || rbpCase
        ? lines.filter((item) => !/проверьте связку документов и проводок по проблемному участку/i.test(item))
        : lines;
    if (hasMissingPeriod) {
        if (questionType === "what_to_check_first") {
            filteredLines.push("Уточните период, если он не зафиксирован в исходной формулировке вопроса.");
        }
        else if (domain === "settlements_60_62" && filteredLines.length > 0) {
            filteredLines.push("Уточните период проверки, чтобы подтвердить проблему без лишнего шума.");
        }
        else {
            filteredLines.unshift("Уточните период проверки, чтобы подтвердить проблему без лишнего шума.");
        }
    }
    return dedupeNarrativeLines(filteredLines, questionType === "what_to_check_first" ? 3 : 5);
}
function humanizeLimitationToken(value) {
    const raw = String(value ?? "").trim();
    if (!raw) {
        return null;
    }
    if (hasUserFacingLeakage(raw)) {
        return null;
    }
    const normalized = normalizeTechnicalToken(raw);
    if (normalized === "missing_anchor:period")
        return "Период проверки не указан.";
    if (normalized === "missing_anchor:account")
        return "Счет или группа счетов не указаны.";
    if (normalized === "missing_anchor:document_or_object")
        return "Не указан документ или объект для трассировки.";
    if (normalized === "missing_anchor:counterparty")
        return "Не указан контрагент или договор.";
    if (normalized === "primary_domain_evidence_not_confirmed")
        return "Целевой механизм активного домена подтвержден частично; вывод ограничен.";
    if (normalized === "settlement_primary_evidence_not_confirmed")
        return "Опора по расчетному контуру не подтверждена: в приоритете были сигналы из смежных доменов.";
    if (normalized.includes("snapshot"))
        return "Оценка сделана на snapshot-срезе и может не включать часть цепочки.";
    if (normalized.includes("heuristic"))
        return "Часть вывода основана на эвристике.";
    if (normalized.includes("weak_source_mapping"))
        return "Связка между источниками подтверждена частично.";
    if (normalized.includes("missing_mechanism"))
        return "Механизм проблемы подтвержден не полностью.";
    if (normalized.includes("insufficient_detail"))
        return "Недостаточно деталей для сильного вывода.";
    if (normalized.includes("duplicate_collapse"))
        return "Часть дублирующихся сигналов объединена в одну проблему.";
    if (/problem units remain weak-confidence/i.test(raw))
        return "Надежность problem-сигнала низкая, поэтому вывод ограничен.";
    if (/source mapping is weak/i.test(raw))
        return "Связка между источниками подтверждена частично.";
    if (/mechanism is unresolved/i.test(raw))
        return "Механизм проблемы подтвержден не полностью.";
    if (/minimum evidence gate failed/i.test(raw))
        return "Минимальная опора не набрана для уверенного вывода.";
    if (/coverage is partial/i.test(raw))
        return "Покрытие требований частичное.";
    if (/broad query support is limited/i.test(raw))
        return "Запрос широкий, поэтому вывод ограничен частичной опорой.";
    if (/broad ranking output was tightened/i.test(raw))
        return "Часть ранжирования ограничена, чтобы избежать ложной точности.";
    if (/weak mechanism evidence/i.test(raw))
        return "Доказательность механизма слабая, нужен ручной контроль.";
    if (/evidence is snapshot-only/i.test(raw))
        return "Оценка сделана на snapshot-срезе и может не включать самые свежие изменения.";
    if (/source-of-record/i.test(raw))
        return "Часть цепочки нужно подтвердить в исходной учетной базе.";
    if (/[a-z]/i.test(raw) && !/[а-яё]/iu.test(raw))
        return null;
    const cleaned = sanitizeUserText(raw);
    if (!cleaned) {
        return null;
    }
    if (hasUserFacingLeakage(cleaned)) {
        return null;
    }
    const core = cleaned.replace(/[.,;:!?]+$/g, "");
    if (TECHNICAL_TOKEN_PATTERN.test(core) && /_/.test(core)) {
        return null;
    }
    return ensureSentence(cleaned);
}
function buildLimitationsSectionLines(structure) {
    const limitationLines = dedupeNarrativeLines([
        ...structure.mechanism_block.limitation_reason_codes.map((code) => limitationReasonToUserText(code)),
        ...structure.uncertainty_block.limitations.map((item) => humanizeLimitationToken(item)),
        ...structure.uncertainty_block.open_uncertainties.map((item) => humanizeLimitationToken(item))
    ].filter((item) => Boolean(item)), 5);
    if (limitationLines.length > 0) {
        return limitationLines;
    }
    if (isIncompleteEvidence(structure)) {
        return ["Вывод ограничен: часть цепочки пока не подтверждена в текущем срезе."];
    }
    return ["Существенных ограничений в текущем срезе не выявлено."];
}
function domainNameForQuestionType(domain) {
    if (domain === "settlements_60_62")
        return "\u0440\u0430\u0441\u0447\u0435\u0442\u043d\u043e\u0433\u043e \u043a\u043e\u043d\u0442\u0443\u0440\u0430";
    if (domain === "vat_document_register_book")
        return "\u0446\u0435\u043f\u043e\u0447\u043a\u0438 \u041d\u0414\u0421";
    if (domain === "month_close_costs_20_44")
        return "\u043a\u043e\u043d\u0442\u0443\u0440\u0430 \u0437\u0430\u043a\u0440\u044b\u0442\u0438\u044f \u043c\u0435\u0441\u044f\u0446\u0430";
    return "\u0432\u044b\u0431\u0440\u0430\u043d\u043d\u043e\u0433\u043e \u0443\u0447\u0430\u0441\u0442\u043a\u0430";
}
function buildQuestionTypeShortLine(context) {
    const domainName = domainNameForQuestionType(context.focusDomain);
    if (context.questionType === "where_break_is") {
        return `\u041b\u043e\u043a\u0430\u043b\u0438\u0437\u043e\u0432\u0430\u043d \u043d\u0430\u0438\u0431\u043e\u043b\u0435\u0435 \u0432\u0435\u0440\u043e\u044f\u0442\u043d\u044b\u0439 \u0443\u0437\u0435\u043b \u0440\u0430\u0437\u0440\u044b\u0432\u0430 \u0432\u043d\u0443\u0442\u0440\u0438 ${domainName}.`;
    }
    if (context.questionType === "prove_or_guess") {
        return "\u0412\u044b\u0432\u043e\u0434 \u0440\u0430\u0437\u0434\u0435\u043b\u0435\u043d \u043d\u0430 \u0434\u043e\u043a\u0430\u0437\u0430\u043d\u043d\u0443\u044e \u0447\u0430\u0441\u0442\u044c \u0438 \u0433\u0438\u043f\u043e\u0442\u0435\u0437\u0443.";
    }
    if (context.questionType === "what_is_it_grounded_on") {
        if (hasRbpContextSignal(context)) {
            return "Ниже перечислены основания вывода по РБП: списание, остаток и подтверждение на конец периода.";
        }
        if (hasFixedAssetAnchorContext(context)) {
            return "Ниже перечислены основания вывода по ОС/амортизации по данным учета.";
        }
        if (context.focusDomain === "vat_document_register_book") {
            return "Ниже перечислены основания вывода по НДС-цепочке по данным учета.";
        }
        return "\u041d\u0438\u0436\u0435 \u043f\u0435\u0440\u0435\u0447\u0438\u0441\u043b\u0435\u043d\u044b \u043e\u0441\u043d\u043e\u0432\u0430\u043d\u0438\u044f \u0432\u044b\u0432\u043e\u0434\u0430 \u043f\u043e \u0434\u0430\u043d\u043d\u044b\u043c \u0443\u0447\u0435\u0442\u0430.";
    }
    if (context.questionType === "which_chains_are_complete_vs_incomplete") {
        return "\u0426\u0435\u043f\u043e\u0447\u043a\u0438 \u0440\u0430\u0437\u0434\u0435\u043b\u0435\u043d\u044b \u043d\u0430 \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u043d\u044b\u0435, \u0447\u0430\u0441\u0442\u0438\u0447\u043d\u043e \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u043d\u044b\u0435 \u0438 \u043d\u0435\u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u043d\u044b\u0435.";
    }
    if (context.questionType === "what_to_check_first") {
        return `\u041a\u043e\u0440\u043e\u0442\u043a\u0438\u0439 \u043c\u0430\u0440\u0448\u0440\u0443\u0442 \u043f\u0435\u0440\u0432\u044b\u0445 \u043f\u0440\u043e\u0432\u0435\u0440\u043e\u043a \u0432\u043d\u0443\u0442\u0440\u0438 ${domainName}.`;
    }
    if (context.questionType === "why_breaks") {
        if (context.focusDomain === "settlements_60_62") {
            return "Наиболее вероятная причина: переход от оплаты к закрытию расчета подтвержден не полностью.";
        }
        if (context.focusDomain === "vat_document_register_book") {
            return "Наиболее вероятная причина: переход документа НДС к регистру и книге подтвержден частично.";
        }
        if (context.focusDomain === "month_close_costs_20_44") {
            return "Наиболее вероятная причина: цепочка распределения затрат и закрытия месяца подтверждена не полностью.";
        }
        if (hasFixedAssetAnchorContext(context)) {
            return "Наиболее вероятная причина: по ОС часть переходов от параметров амортизации к начислению подтверждена не полностью.";
        }
        return "Наиболее вероятный механизм проблемы подтвержден частично и требует первичной проверки.";
    }
    if (context.questionType === "unknown" && hasFixedAssetAnchorContext(context)) {
        return "Риск неполного начисления амортизации подтвержден частично и требует проверки по объектам ОС.";
    }
    return null;
}
function buildQuestionTypeBrokenLine(context) {
    if (context.questionType !== "where_break_is") {
        return null;
    }
    if (context.focusDomain === "settlements_60_62") {
        return "\u0412\u0435\u0440\u043e\u044f\u0442\u043d\u044b\u0439 \u0443\u0437\u0435\u043b \u0440\u0430\u0437\u0440\u044b\u0432\u0430: \u043f\u0440\u0438\u0432\u044f\u0437\u043a\u0430 \u043e\u043f\u043b\u0430\u0442\u044b \u043a \u043e\u0431\u044a\u0435\u043a\u0442\u0443 \u0440\u0430\u0441\u0447\u0435\u0442\u043e\u0432 \u0438 \u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u0443 \u0437\u0430\u043a\u0440\u044b\u0442\u0438\u044f.";
    }
    if (context.focusDomain === "vat_document_register_book") {
        return "\u0412\u0435\u0440\u043e\u044f\u0442\u043d\u044b\u0439 \u0443\u0437\u0435\u043b \u0440\u0430\u0437\u0440\u044b\u0432\u0430: \u0441\u0432\u044f\u0437\u043a\u0430 \u0438\u0441\u0445\u043e\u0434\u043d\u043e\u0433\u043e \u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u0430, \u0441\u0447\u0435\u0442\u0430-\u0444\u0430\u043a\u0442\u0443\u0440\u044b \u0438 \u0437\u0430\u043f\u0438\u0441\u0438 \u043a\u043d\u0438\u0433\u0438.";
    }
    if (context.focusDomain === "month_close_costs_20_44") {
        return "\u0412\u0435\u0440\u043e\u044f\u0442\u043d\u044b\u0439 \u0443\u0437\u0435\u043b \u0440\u0430\u0437\u0440\u044b\u0432\u0430: \u043f\u0435\u0440\u0435\u0445\u043e\u0434 \u043e\u0442 \u043d\u0430\u043a\u043e\u043f\u043b\u0435\u043d\u0438\u044f \u0437\u0430\u0442\u0440\u0430\u0442 \u043a \u0440\u0430\u0441\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d\u0438\u044e/\u0437\u0430\u043a\u0440\u044b\u0442\u0438\u044e.";
    }
    return "\u0412\u0435\u0440\u043e\u044f\u0442\u043d\u044b\u0439 \u0443\u0437\u0435\u043b \u0440\u0430\u0437\u0440\u044b\u0432\u0430 \u043b\u043e\u043a\u0430\u043b\u0438\u0437\u043e\u0432\u0430\u043d \u0447\u0430\u0441\u0442\u0438\u0447\u043d\u043e; \u043d\u0443\u0436\u043d\u0430 \u0442\u043e\u0447\u0435\u0447\u043d\u0430\u044f \u0441\u0432\u0435\u0440\u043a\u0430.";
}
function buildQuestionTypeWhyLine(context) {
    if (context.questionType === "where_break_is") {
        return "\u0424\u043e\u043a\u0443\u0441 \u043e\u0442\u0432\u0435\u0442\u0430: \u043d\u0435 \u043e\u0431\u0449\u0438\u0439 \u043c\u0435\u0445\u0430\u043d\u0438\u0437\u043c, \u0430 \u0442\u043e\u0447\u043a\u0430 \u0440\u0430\u0437\u0440\u044b\u0432\u0430 \u0432 \u0446\u0435\u043f\u043e\u0447\u043a\u0435.";
    }
    if (context.questionType === "prove_or_guess") {
        return "\u041e\u0442\u0434\u0435\u043b\u044c\u043d\u043e \u043f\u043e\u043a\u0430\u0437\u0430\u043d\u043e, \u0447\u0442\u043e \u0443\u0436\u0435 \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u043e, \u0430 \u0447\u0442\u043e \u043f\u043e\u043a\u0430 \u043e\u0441\u0442\u0430\u0435\u0442\u0441\u044f \u0433\u0438\u043f\u043e\u0442\u0435\u0437\u043e\u0439.";
    }
    if (context.questionType === "which_chains_are_complete_vs_incomplete") {
        return "\u0426\u0435\u043f\u043e\u0447\u043a\u0438 \u0440\u0430\u0437\u0434\u0435\u043b\u0435\u043d\u044b \u043d\u0430 \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043d\u043d\u044b\u0435 \u0438 \u043d\u0435\u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043d\u043d\u044b\u0435 \u043f\u043e \u0442\u0435\u043a\u0443\u0449\u0435\u0439 \u043e\u043f\u043e\u0440\u0435.";
    }
    if (context.questionType === "what_is_it_grounded_on") {
        if (hasRbpContextSignal(context)) {
            return "Фокус ответа по РБП: подтверждение списания и остатка на конец периода, а не общий close-narrative.";
        }
        if (hasFixedAssetAnchorContext(context)) {
            return "Фокус ответа по ОС: подтверждение попадания объектов в начисление амортизации.";
        }
        if (context.focusDomain === "vat_document_register_book") {
            return "Фокус ответа по НДС: подтверждение переходов между документом, счетом-фактурой, регистром и книгой.";
        }
        return "\u0424\u043e\u043a\u0443\u0441 \u043e\u0442\u0432\u0435\u0442\u0430 \u0441\u043c\u0435\u0449\u0435\u043d \u0432 \u0434\u043e\u043a\u0430\u0437\u0430\u0442\u0435\u043b\u044c\u043d\u044b\u0435 \u0438\u0441\u0442\u043e\u0447\u043d\u0438\u043a\u0438, \u0430 \u043d\u0435 \u0432 \u043e\u0431\u0449\u0438\u0439 narrative.";
    }
    return null;
}
function buildQuestionTypeEvidenceLine(context) {
    if (context.questionType === "what_is_it_grounded_on") {
        if (hasRbpContextSignal(context)) {
            return "Опора перечислена по РБП-объектам, документам списания и остаткам на конец периода.";
        }
        if (hasFixedAssetAnchorContext(context)) {
            return "Опора перечислена по ОС-объектам, параметрам амортизации и движениям начисления.";
        }
        if (context.focusDomain === "vat_document_register_book") {
            return "Опора перечислена по НДС-звеньям: документ, счет-фактура, регистр и книга.";
        }
        return "\u0412 \u044d\u0442\u043e\u043c \u043e\u0442\u0432\u0435\u0442\u0435 \u0432 \u043f\u0440\u0438\u043e\u0440\u0438\u0442\u0435\u0442\u0435 \u043f\u043e\u043a\u0430\u0437\u0430\u043d\u044b \u0438\u043c\u0435\u043d\u043d\u043e \u043e\u0441\u043d\u043e\u0432\u0430\u043d\u0438\u044f \u0432\u044b\u0432\u043e\u0434\u0430.";
    }
    if (context.questionType === "prove_or_guess") {
        return "\u0421\u0438\u043b\u0430 \u0432\u044b\u0432\u043e\u0434\u0430 \u043e\u0446\u0435\u043d\u0435\u043d\u0430 \u043f\u043e \u043f\u0440\u044f\u043c\u043e\u0439 \u043e\u043f\u043e\u0440\u0435, \u0430 \u043d\u0435 \u043f\u043e \u0434\u043e\u0433\u0430\u0434\u043a\u0430\u043c.";
    }
    if (context.questionType === "which_chains_are_complete_vs_incomplete") {
        if (context.focusDomain === "vat_document_register_book") {
            return "Опора собрана по НДС-звеньям, чтобы разделить полные и неполные переходы.";
        }
        if (hasRbpContextSignal(context)) {
            return "Опора собрана по РБП-цепочке, чтобы разделить подтвержденное и неподтвержденное списание.";
        }
        if (hasFixedAssetAnchorContext(context)) {
            return "Опора собрана по ОС-цепочке, чтобы разделить подтвержденные и неподтвержденные начисления амортизации.";
        }
        return "\u041e\u043f\u043e\u0440\u0430 \u0441\u043e\u0431\u0440\u0430\u043d\u0430 \u0442\u0430\u043a, \u0447\u0442\u043e\u0431\u044b \u0447\u0435\u0441\u0442\u043d\u043e \u0440\u0430\u0437\u0434\u0435\u043b\u0438\u0442\u044c \u043f\u043e\u043b\u043d\u044b\u0435 \u0438 \u043d\u0435\u043f\u043e\u043b\u043d\u044b\u0435 \u0446\u0435\u043f\u043e\u0447\u043a\u0438.";
    }
    return null;
}
function formatAnchorList(anchors, prefix) {
    if (anchors.length === 0) {
        return null;
    }
    return `${prefix}: ${anchors.join(", ")}.`;
}
function buildQuestionTypeCheckLine(context) {
    if (context.questionType === "what_to_check_first") {
        return "\u041f\u0440\u043e\u0432\u0435\u0440\u044c\u0442\u0435 \u043f\u0443\u043d\u043a\u0442\u044b \u043f\u043e \u043f\u043e\u0440\u044f\u0434\u043a\u0443: \u0448\u0430\u0433 1 -> \u0448\u0430\u0433 2 -> \u0448\u0430\u0433 3.";
    }
    if (context.questionType === "where_break_is") {
        return "\u041b\u043e\u043a\u0430\u043b\u0438\u0437\u0430\u0446\u0438\u044e \u0440\u0430\u0437\u0440\u044b\u0432\u0430 \u043d\u0430\u0447\u043d\u0438\u0442\u0435 \u0441 \u0443\u0437\u043b\u0430, \u0433\u0434\u0435 \u043f\u0435\u0440\u0435\u0445\u043e\u0434 \u043f\u0435\u0440\u0435\u0441\u0442\u0430\u043b \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0430\u0442\u044c\u0441\u044f.";
    }
    if (context.questionType === "prove_or_guess") {
        return "\u041f\u0435\u0440\u0432\u044b\u043c \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0435\u043c \u043e\u0442\u0434\u0435\u043b\u0438\u0442\u0435 \u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u0430\u043b\u044c\u043d\u043e \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u043d\u044b\u0435 \u0444\u0430\u043a\u0442\u044b \u043e\u0442 \u0433\u0438\u043f\u043e\u0442\u0435\u0437.";
    }
    if (context.questionType === "what_is_it_grounded_on") {
        if (hasRbpContextSignal(context)) {
            return "Сначала перечислите по РБП: объект, документ списания и остаток после списания на конец периода.";
        }
        if (hasFixedAssetAnchorContext(context)) {
            return "Сначала перечислите по ОС: объект, параметры амортизации и подтверждение начисления за период.";
        }
        if (context.focusDomain === "vat_document_register_book") {
            return "Сначала перечислите по НДС: документ, счет-фактуру, запись регистра и запись книги.";
        }
        return "\u0421\u043d\u0430\u0447\u0430\u043b\u0430 \u043f\u0435\u0440\u0435\u0447\u0438\u0441\u043b\u0438\u0442\u0435 \u043e\u043f\u043e\u0440\u043d\u044b\u0435 \u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u044b \u0438 \u0440\u0435\u0433\u0438\u0441\u0442\u0440\u044b, \u0437\u0430\u0442\u0435\u043c \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0430\u044e\u0449\u0438\u0435 \u043f\u0440\u043e\u0432\u043e\u0434\u043a\u0438.";
    }
    if (context.questionType === "which_chains_are_complete_vs_incomplete") {
        if (context.focusDomain === "vat_document_register_book") {
            return "Сначала разложите НДС-цепочку по шагам: документ -> счет-фактура -> регистр -> книга.";
        }
        if (hasRbpContextSignal(context)) {
            return "Сначала разложите РБП-цепочку на подтвержденное списание, частичное и неподтвержденное.";
        }
        if (hasFixedAssetAnchorContext(context)) {
            return "Сначала разложите ОС-цепочку на подтвержденное начисление, частичное и неподтвержденное.";
        }
        return "\u0421\u043d\u0430\u0447\u0430\u043b\u0430 \u0440\u0430\u0437\u043b\u043e\u0436\u0438\u0442\u0435 \u0446\u0435\u043f\u043e\u0447\u043a\u0438 \u043d\u0430 \u043f\u043e\u043b\u043d\u044b\u0435, \u0447\u0430\u0441\u0442\u0438\u0447\u043d\u043e \u043f\u043e\u043b\u043d\u044b\u0435 \u0438 \u043d\u0435\u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u043d\u044b\u0435.";
    }
    return null;
}
function buildQuestionTypeLimitationLine(context) {
    if (context.questionType === "prove_or_guess") {
        return "\u0414\u043b\u044f \u0444\u043e\u0440\u043c\u0430\u0442\u0430 \u00ab\u0434\u043e\u043a\u0430\u0437\u0430\u043d\u043e \u0438\u043b\u0438 \u0433\u0438\u043f\u043e\u0442\u0435\u0437\u0430\u00bb \u0432\u0441\u0435 \u043d\u0435\u0434\u043e\u043a\u0430\u0437\u0430\u043d\u043d\u044b\u0435 \u0447\u0430\u0441\u0442\u0438 \u043e\u0442\u0434\u0435\u043b\u0435\u043d\u044b \u0432 \u043e\u0433\u0440\u0430\u043d\u0438\u0447\u0435\u043d\u0438\u044f.";
    }
    if (context.questionType === "which_chains_are_complete_vs_incomplete") {
        return "\u0414\u0435\u043b\u0435\u043d\u0438\u0435 \u043d\u0430 \u00abcomplete/incomplete\u00bb \u0437\u0430\u0432\u0438\u0441\u0438\u0442 \u043e\u0442 \u043f\u043e\u043b\u043d\u043e\u0442\u044b \u0446\u0435\u043f\u043e\u0447\u043a\u0438 \u0432 \u0442\u0435\u043a\u0443\u0449\u0435\u043c \u0441\u0440\u0435\u0437\u0435.";
    }
    if (context.questionType === "where_break_is") {
        return "\u0422\u043e\u0447\u043d\u0430\u044f \u043b\u043e\u043a\u0430\u043b\u0438\u0437\u0430\u0446\u0438\u044f \u043c\u043e\u0436\u0435\u0442 \u0441\u043c\u0435\u0449\u0430\u0442\u044c\u0441\u044f, \u0435\u0441\u043b\u0438 \u0447\u0430\u0441\u0442\u044c \u043f\u0435\u0440\u0435\u0445\u043e\u0434\u043e\u0432 \u0432 \u0446\u0435\u043f\u043e\u0447\u043a\u0435 \u043d\u0435 \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u0430.";
    }
    if (context.questionType === "what_is_it_grounded_on") {
        return "\u0412 \u043e\u0441\u043d\u043e\u0432\u0430\u043d\u0438\u0435 \u0432\u043a\u043b\u044e\u0447\u0435\u043d\u044b \u0442\u043e\u043b\u044c\u043a\u043e \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u043d\u044b\u0435 \u0438\u0441\u0442\u043e\u0447\u043d\u0438\u043a\u0438; \u043d\u0435\u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u043d\u044b\u0435 \u0432\u044b\u043d\u0435\u0441\u0435\u043d\u044b \u0432 \u043e\u0433\u0440\u0430\u043d\u0438\u0447\u0435\u043d\u0438\u044f.";
    }
    if (context.questionType === "what_to_check_first") {
        return "\u041c\u0430\u0440\u0448\u0440\u0443\u0442 \u043f\u0435\u0440\u0432\u0438\u0447\u043d\u044b\u0439 \u0438 \u043c\u043e\u0436\u0435\u0442 \u0443\u0442\u043e\u0447\u043d\u044f\u0442\u044c\u0441\u044f \u043f\u043e\u0441\u043b\u0435 \u043f\u0435\u0440\u0432\u043e\u0433\u043e \u0448\u0430\u0433\u0430.";
    }
    return null;
}
function applyQuestionTypeAndAnchorPolicy(input) {
    const nextShort = buildQuestionTypeShortLine(input.context) ?? input.shortLine;
    const nextBroken = dedupeNarrativeLines([buildQuestionTypeBrokenLine(input.context), ...input.brokenLines].filter((item) => Boolean(item)), 4);
    const nextWhy = dedupeNarrativeLines([buildQuestionTypeWhyLine(input.context), ...input.whyLines].filter((item) => Boolean(item)), 4);
    const anchorUsedLine = formatAnchorList(input.context.anchors.used, "\u0412 \u043e\u043f\u043e\u0440\u0435 \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u043d\u044b \u044f\u043a\u043e\u0440\u044f \u0432\u043e\u043f\u0440\u043e\u0441\u0430");
    const anchorUnusedLine = formatAnchorList(input.context.anchors.unused, "\u042f\u043a\u043e\u0440\u044f \u0438\u0437 \u0432\u043e\u043f\u0440\u043e\u0441\u0430 \u0431\u0435\u0437 \u043f\u0440\u044f\u043c\u043e\u0433\u043e \u043f\u043e\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043d\u0438\u044f");
    const nextEvidence = dedupeNarrativeLines([buildQuestionTypeEvidenceLine(input.context), ...input.evidenceLines, anchorUsedLine].filter((item) => Boolean(item)), input.context.questionType === "what_to_check_first" ? 4 : 7);
    const nextChecks = dedupeNarrativeLines([buildQuestionTypeCheckLine(input.context), ...input.checkLines].filter((item) => Boolean(item)), input.context.questionType === "what_to_check_first" ? 3 : 5);
    const nextLimitations = dedupeNarrativeLines([buildQuestionTypeLimitationLine(input.context), anchorUnusedLine, ...input.limitationLines].filter((item) => Boolean(item)), 6);
    return {
        shortLine: ensureSentence(nextShort),
        brokenLines: nextBroken,
        whyLines: nextWhy,
        evidenceLines: nextEvidence,
        checkLines: nextChecks,
        limitationLines: nextLimitations
    };
}
const RBP_WORDING_PATTERN = /(?:\bрбп\b|deferred[_\s-]?expense|сч(?:е|ё)т\s*97|объект\w*\s+рбп|списани[ея]\s+рбп|остат(?:ок|ки)\s+рбп|документ\s+списани[яе])/iu;
const FA_WORDING_PATTERN = /(?:\bос\b|основн(?:ые|ых)?\s+средств|амортиз|сч(?:е|ё)т\s*0[12]|01\/02|карточк\w*\s+ос|объект\w*\s+ос|ввод\w*\s+в\s+эксплуатац|fixed\s*asset|depreciat)/iu;
function hasRbpWordingPhrase(value) {
    return RBP_WORDING_PATTERN.test(String(value ?? ""));
}
function hasFaWordingPhrase(value) {
    return FA_WORDING_PATTERN.test(String(value ?? ""));
}
function resolveDomainWordingMode(structure, context) {
    if (!context) {
        return "neutral";
    }
    const userMessage = String(context.userMessage ?? "");
    const explicitRbpFromMessage = hasRbpSignalInText(userMessage);
    const explicitFaFromMessage = hasFixedAssetAmortizationSignalInText(userMessage);
    if (explicitRbpFromMessage && !explicitFaFromMessage) {
        return "rbp";
    }
    if (explicitFaFromMessage && !explicitRbpFromMessage) {
        return "fa_amortization";
    }
    const anchorRbp = hasRbpAnchorContext(context);
    const anchorFa = hasFixedAssetAnchorContext(context);
    if (anchorRbp && !anchorFa) {
        return "rbp";
    }
    if (anchorFa && !anchorRbp) {
        return "fa_amortization";
    }
    const structureCorpus = [
        structure.direct_answer,
        ...structure.mechanism_block.mechanism_notes,
        ...structure.evidence_block.mechanism_notes,
        ...(structure.evidence_block.source_refs ?? []),
        ...(context.anchors.present ?? []),
        ...(context.anchors.used ?? [])
    ]
        .filter(Boolean)
        .join(" ");
    const structureRbp = hasRbpSignalInText(structureCorpus);
    const structureFa = hasFixedAssetAmortizationSignalInText(structureCorpus);
    const rbpScore = [explicitRbpFromMessage, anchorRbp, structureRbp].filter(Boolean).length;
    const faScore = [explicitFaFromMessage, anchorFa, structureFa].filter(Boolean).length;
    if (rbpScore > faScore) {
        return "rbp";
    }
    if (faScore > rbpScore) {
        return "fa_amortization";
    }
    return "neutral";
}
function enforceDomainWordingIsolation(payload, structure, context) {
    const mode = resolveDomainWordingMode(structure, context);
    if (mode === "neutral" || !context) {
        return payload;
    }
    const effectiveQuestionType = context.questionType === "unknown" ? "what_to_check_first" : context.questionType;
    const isForbidden = mode === "rbp" ? hasFaWordingPhrase : hasRbpWordingPhrase;
    const filterLines = (lines) => lines.filter((line) => !isForbidden(line));
    const shortFallback = mode === "rbp"
        ? "Признаки по РБП подтверждены частично и требуют проверки списания к концу периода."
        : "Риск неполного начисления амортизации по объектам ОС подтвержден частично.";
    const whyFallback = mode === "rbp"
        ? ["По РБП часть списаний к концу периода подтверждена не полностью, поэтому остаток может сохраняться дольше ожидаемого."]
        : ["По ОС часть переходов к начислению амортизации подтверждена не полностью, поэтому есть риск пропуска отдельных объектов."];
    const evidenceFallback = mode === "rbp"
        ? ["Основание собрано по РБП: объект списания, документ списания и остаток на конец периода."]
        : ["Основание собрано по ОС: карточка объекта, параметры амортизации, начисление и движения по 01/02."];
    const checkFallback = mode === "rbp"
        ? buildRbpChecksByQuestionType(effectiveQuestionType).slice(0, 2)
        : buildFixedAssetChecksByQuestionType(effectiveQuestionType).slice(0, 2);
    const filteredShort = isForbidden(payload.shortLine) ? shortFallback : payload.shortLine;
    const filteredBroken = dedupeNarrativeLines(filterLines(payload.brokenLines), 4);
    const filteredWhy = dedupeNarrativeLines([...filterLines(payload.whyLines), ...(filterLines(payload.whyLines).length === 0 ? whyFallback : [])], 4);
    const filteredEvidence = dedupeNarrativeLines([...filterLines(payload.evidenceLines), ...(filterLines(payload.evidenceLines).length === 0 ? evidenceFallback : [])], 7);
    const filteredChecks = dedupeNarrativeLines([...filterLines(payload.checkLines), ...(filterLines(payload.checkLines).length === 0 ? checkFallback : [])], effectiveQuestionType === "what_to_check_first" ? 3 : 5);
    const filteredLimitations = dedupeNarrativeLines(filterLines(payload.limitationLines), 6);
    return {
        shortLine: ensureSentence(filteredShort),
        brokenLines: filteredBroken.length > 0 ? filteredBroken : payload.brokenLines,
        whyLines: filteredWhy.length > 0 ? filteredWhy : whyFallback,
        evidenceLines: filteredEvidence.length > 0 ? filteredEvidence : evidenceFallback,
        checkLines: filteredChecks.length > 0 ? filteredChecks : checkFallback,
        limitationLines: filteredLimitations.length > 0 ? filteredLimitations : payload.limitationLines
    };
}
function renderPolicyReply(structure, context) {
    const questionType = context?.questionType ?? "unknown";
    const shortLine = ensureSentence(buildShortSectionLine(structure));
    const brokenLines = buildBrokenSectionLines(structure);
    const whyLines = buildWhySectionLines(structure, context);
    const evidenceLines = buildEvidenceSectionLines(structure, questionType, context);
    const checkLines = buildChecksSectionLines(structure, context);
    const limitationLines = buildLimitationsSectionLines(structure);
    const enrichedBase = context
        ? applyQuestionTypeAndAnchorPolicy({
            shortLine,
            brokenLines,
            whyLines,
            evidenceLines,
            checkLines,
            limitationLines,
            context
        })
        : {
            shortLine,
            brokenLines,
            whyLines,
            evidenceLines,
            checkLines,
            limitationLines
        };
    const enriched = enforceDomainWordingIsolation(enrichedBase, structure, context);
    return renderStage4ContractReply({
        shortLine: enriched.shortLine,
        checkedLines: enriched.evidenceLines,
        foundLines: [...enriched.brokenLines, ...enriched.whyLines],
        unresolvedLines: enriched.limitationLines,
        nextStepLines: enriched.checkLines,
        nextStepTitle: "Что проверить первым"
    });
}
function shouldUseSoftPolicyReply(input) {
    if (input.mode === "focused_grounded" || input.mode === "route_mismatch" || input.mode === "backend_error" || input.mode === "out_of_scope") {
        return false;
    }
    if (input.mode === "clarification_required" || input.mode === "no_grounded" || input.mode === "empty") {
        return true;
    }
    if (input.mode !== "broad_partial") {
        return false;
    }
    const hasCoverageGaps = input.coverageReport.requirements_uncovered.length > 0 ||
        input.coverageReport.requirements_partially_covered.length > 0 ||
        input.coverageReport.clarification_needed_for.length > 0 ||
        input.coverageReport.out_of_scope_requirements.length > 0;
    const weakEvidenceSignals = input.policySignals.broad_query_detected ||
        input.policySignals.broad_result_flag ||
        input.policySignals.minimum_evidence_failed ||
        input.aggregateEvidenceConfidence === "low" ||
        input.hasCriticalEvidenceLimitation ||
        input.limitationReasonCodes.includes("weak_source_mapping") ||
        input.limitationReasonCodes.includes("insufficient_detail") ||
        input.limitationReasonCodes.includes("missing_mechanism");
    return hasCoverageGaps || weakEvidenceSignals;
}
function renderSoftPolicyReply(input) {
    const questionType = input.context?.questionType ?? "unknown";
    const shortLine = ensureSentence(buildShortSectionLine(input.structure));
    const foundLines = dedupeNarrativeLines([...buildBrokenSectionLines(input.structure), ...buildWhySectionLines(input.structure, input.context)], 3);
    const evidenceLines = dedupeNarrativeLines(buildEvidenceSectionLines(input.structure, questionType, input.context), 3);
    const limitationLines = dedupeNarrativeLines(buildLimitationsSectionLines(input.structure), 3);
    const checkLines = dedupeNarrativeLines(buildChecksSectionLines(input.structure, input.context), 3);
    const clarificationLines = dedupeNarrativeLines(input.structure.next_step_block.clarification_questions ?? [], 2);
    const actionLines = dedupeNarrativeLines([...checkLines, ...(input.structure.next_step_block.recommended_actions ?? []), ...clarificationLines], 3);
    const modeLine = input.mode === "clarification_required"
        ? "Чтобы дать точный ответ, нужно уточнить несколько ориентиров."
        : input.mode === "no_grounded" || input.mode === "empty"
            ? "Сейчас подтвержденной опоры недостаточно для прямого вывода."
            : "Есть рабочие сигналы, но часть вывода пока ограничена.";
    return renderStage4ContractReply({
        shortLine,
        checkedLines: evidenceLines.length > 0
            ? evidenceLines
            : ["Подтвержденная опора собрана частично; для полного вывода нужна дополнительная проверка."],
        foundLines: foundLines.length > 0 ? foundLines : ["Пока подтверждена только часть сигнала, без финальной фиксации причины."],
        unresolvedLines: limitationLines.length > 0 ? [modeLine, ...limitationLines] : [modeLine, "Для полного вывода не хватает деталей по части требований."],
        nextStepLines: actionLines.length > 0
            ? actionLines
            : ["Уточните период, объект или контрагента, чтобы завершить проверку в следующем ходе."],
        nextStepTitle: "Что могу сделать сейчас"
    });
}
function composeAssistantAnswerV11(input) {
    const fallbackType = fallbackFromSummary(input.routeSummary);
    const questionType = input.questionTypeHint ?? "unknown";
    const anchorUsage = evaluateCompanyAnchorUsage(input.companyAnchors, input.retrievalResults);
    const okResults = input.retrievalResults.filter((item) => item.status === "ok");
    const partialResults = input.retrievalResults.filter((item) => item.status === "partial");
    const emptyResults = input.retrievalResults.filter((item) => item.status === "empty");
    const errorResults = input.retrievalResults.filter((item) => item.status === "error");
    const evidenceItems = flattenEvidence(input.retrievalResults);
    const policySignals = aggregatePolicySignals(input.retrievalResults);
    const limitationReasonCodes = collectLimitationReasonCodes(evidenceItems);
    const sourceRefs = uniqueStrings(evidenceItems
        .map((item) => item.source_ref?.canonical_ref)
        .filter((item) => typeof item === "string" && item.trim().length > 0), 8);
    const mechanismNotes = uniqueStrings(evidenceItems
        .map((item) => item.mechanism_note)
        .filter((item) => typeof item === "string" && item.trim().length > 0), 6);
    const lifecycleAnswerEnabled = Boolean(input.enableLifecycleAnswerV1);
    const problemUnits = flattenProblemUnits(input.retrievalResults);
    const problemUnitSummary = selectProblemUnitSummary(input.retrievalResults);
    const problemHeavyUnits = problemUnits.filter((item) => PROBLEM_HEAVY_TYPES.has(item.problem_unit_type));
    const focusNarrativeDomain = inferP0FocusNarrativeDomain(input.userMessage, input.retrievalResults, problemHeavyUnits, input.focusDomainHint);
    const focusDomainGrounding = evaluateP0DomainEvidenceGrounding(input.retrievalResults, focusNarrativeDomain);
    const focusDomainGroundingBlocked = Boolean(focusNarrativeDomain && focusDomainGrounding.blocked);
    const rankedProblemUnits = rankProblemUnitsForAnswer(problemHeavyUnits, lifecycleAnswerEnabled, focusNarrativeDomain);
    const domainAlignedProblemUnits = focusNarrativeDomain === null
        ? rankedProblemUnits
        : rankedProblemUnits.filter((unit) => isProblemUnitAlignedWithNarrativeDomain(unit, focusNarrativeDomain));
    const domainLockMissBase = Boolean(focusNarrativeDomain &&
        rankedProblemUnits.length > 0 &&
        domainAlignedProblemUnits.length === 0);
    const domainLockMiss = domainLockMissBase || focusDomainGroundingBlocked;
    const selectedProblemUnits = (focusNarrativeDomain === null ? rankedProblemUnits : domainAlignedProblemUnits).slice(0, 4);
    const claimEvidenceLinks = buildClaimEvidenceLinks(input.retrievalResults);
    const aggregateEvidenceConfidence = aggregateConfidence(input.retrievalResults, evidenceItems);
    const lowConfidenceSignals = evidenceItems.filter((item) => item.confidence === "low").length;
    const lowConfidenceShare = evidenceItems.length > 0 ? lowConfidenceSignals / evidenceItems.length : 0;
    const lowConfidenceConcentration = lowConfidenceShare >= 0.6;
    const hasSupport = okResults.length > 0 ||
        partialResults.length > 0 ||
        evidenceItems.length > 0 ||
        input.retrievalResults.some((item) => item.items.length > 0);
    const hasCoverageGaps = input.coverageReport.requirements_uncovered.length > 0 ||
        input.coverageReport.requirements_partially_covered.length > 0 ||
        input.coverageReport.clarification_needed_for.length > 0 ||
        input.coverageReport.out_of_scope_requirements.length > 0;
    const hasCriticalEvidenceLimitation = limitationReasonCodes.includes("weak_source_mapping") ||
        limitationReasonCodes.includes("insufficient_detail");
    const hasNonLowRouteConfidence = input.retrievalResults.some((item) => item.status === "ok" && item.confidence !== "low");
    const focusedStrong = okResults.length > 0 &&
        input.groundingCheck.status === "grounded" &&
        !hasCoverageGaps &&
        !policySignals.broad_query_detected &&
        !policySignals.broad_result_flag &&
        !policySignals.minimum_evidence_failed &&
        !hasCriticalEvidenceLimitation &&
        (aggregateEvidenceConfidence !== "low" || hasNonLowRouteConfidence);
    const decision = buildPolicyDecision({
        fallbackType,
        coverageReport: input.coverageReport,
        groundingCheck: input.groundingCheck,
        okResults,
        partialResults,
        emptyResults,
        errorResults,
        hasSupport,
        focusedStrong,
        policySignals
    });
    const guardedDecision = focusDomainGroundingBlocked &&
        decision.mode !== "out_of_scope" &&
        decision.mode !== "route_mismatch" &&
        decision.mode !== "backend_error"
        ? {
            mode: "clarification_required",
            fallback_type: "clarification",
            reply_type: "clarification_required"
        }
        : decision;
    const missingAnchors = detectMissingAnchors(input.userMessage, input.retrievalResults, {
        normalizationPeriodExplicit: Boolean(input.normalizationPeriodExplicit),
        companyAnchors: input.companyAnchors ?? null
    });
    const useBoundaryFallbackReply = shouldUseBoundaryFallbackReply({
        mode: guardedDecision.mode,
        groundingCheck: input.groundingCheck,
        coverageReport: input.coverageReport,
        okResultsCount: okResults.length,
        partialResultsCount: partialResults.length,
        focusDomain: focusNarrativeDomain,
        focusDomainGroundingBlocked,
        aggregateEvidenceConfidence,
        hasCriticalEvidenceLimitation
    });
    const hasProblemWeakSignal = policySignals.narrowing_strength !== "strong" ||
        policySignals.minimum_evidence_failed ||
        limitationReasonCodes.includes("missing_mechanism") ||
        limitationReasonCodes.includes("weak_source_mapping") ||
        limitationReasonCodes.includes("insufficient_detail") ||
        aggregateEvidenceConfidence === "low" ||
        domainLockMiss ||
        lowConfidenceConcentration;
    const hardBlockedMode = guardedDecision.mode === "out_of_scope" ||
        guardedDecision.mode === "route_mismatch" ||
        guardedDecision.mode === "backend_error";
    const problemCentricModeEligible = guardedDecision.mode === "broad_partial" ||
        guardedDecision.mode === "clarification_required" ||
        (guardedDecision.mode === "focused_grounded" && hasProblemWeakSignal);
    const shouldUseProblemCentricAnswer = Boolean(input.enableProblemCentricAnswerV1) &&
        !useBoundaryFallbackReply &&
        !hardBlockedMode &&
        problemCentricModeEligible &&
        (!focusedStrong || hasProblemWeakSignal) &&
        (selectedProblemUnits.length > 0 || domainLockMiss);
    if (shouldUseProblemCentricAnswer) {
        const problemCentricStructure = buildProblemCentricAnswerStructure({
            mode: guardedDecision.mode,
            selectedUnits: selectedProblemUnits,
            problemSummary: problemUnitSummary,
            evidenceItems,
            claimEvidenceLinks,
            limitationReasonCodes,
            groundingCheck: input.groundingCheck,
            retrievalResults: input.retrievalResults,
            missingAnchors,
            coverageReport: input.coverageReport,
            lifecycleAnswerEnabled,
            focusDomain: focusNarrativeDomain,
            domainLockMiss
        });
        const lifecycleModeActive = lifecycleAnswerEnabled && selectedProblemUnits.length > 0 && hasLifecycleResolution(selectedProblemUnits);
        return {
            assistant_reply: renderPolicyReply(problemCentricStructure, {
                questionType,
                focusDomain: focusNarrativeDomain,
                anchors: anchorUsage,
                userMessage: input.userMessage
            }),
            fallback_type: guardedDecision.fallback_type,
            reply_type: guardedDecision.reply_type,
            answer_structure_v11: problemCentricStructure,
            problem_centric_answer_applied: true,
            problem_units_used_count: selectedProblemUnits.length,
            problem_answer_mode: lifecycleModeActive ? "stage3_lifecycle_aware_v1" : "stage2_problem_centric_v1",
            problem_unit_ids_used: selectedProblemUnits.map((item) => item.problem_unit_id)
        };
    }
    const clarificationQuestions = buildClarificationQuestions({
        mode: guardedDecision.mode,
        missingAnchors,
        coverageReport: input.coverageReport,
        policySignals
    });
    const recommendedActions = buildRecommendedActions({
        mode: guardedDecision.mode,
        coverageReport: input.coverageReport,
        policySignals,
        limitationReasonCodes,
        sourceRefs
    });
    const limitations = uniqueStrings([
        ...limitationReasonCodes.map((code) => limitationReasonToText(code)),
        ...extractLimitations(input.retrievalResults),
        ...input.groundingCheck.reasons,
        ...(focusDomainGroundingBlocked
            ? ["Целевой механизм активного домена подтвержден частично; часть первичной опоры пришла из смежного контура."]
            : []),
        ...(anchorUsage.unused.length > 0
            ? [
                `Часть якорей запроса пока не подтверждена в опоре: ${anchorUsage.unused.slice(0, 5).join(", ")}.`
            ]
            : []),
        ...(policySignals.minimum_evidence_failed ? ["Minimum evidence gate failed for current scope."] : []),
        ...(policySignals.broad_query_detected && policySignals.narrowing_strength === "weak"
            ? ["Broad query remains weakly narrowed; precision is intentionally limited."]
            : [])
    ], 10);
    const openUncertainties = uniqueStrings([
        ...input.groundingCheck.missing_requirements,
        ...(guardedDecision.mode === "clarification_required" && missingAnchors.period ? ["missing_anchor:period"] : []),
        ...(guardedDecision.mode === "clarification_required" && missingAnchors.account ? ["missing_anchor:account"] : []),
        ...(guardedDecision.mode === "clarification_required" && missingAnchors.documentOrObject ? ["missing_anchor:document_or_object"] : []),
        ...(guardedDecision.mode === "clarification_required" && missingAnchors.counterparty ? ["missing_anchor:counterparty"] : []),
        ...(focusDomainGroundingBlocked ? ["primary_domain_evidence_not_confirmed"] : [])
    ], 8);
    const confidenceLimited = guardedDecision.mode !== "focused_grounded" ||
        limitationReasonCodes.includes("missing_mechanism") ||
        limitationReasonCodes.includes("heuristic_inference") ||
        limitationReasonCodes.includes("weak_source_mapping") ||
        limitationReasonCodes.includes("insufficient_detail") ||
        aggregateEvidenceConfidence === "low" ||
        focusDomainGroundingBlocked;
    const mechanismStatus = mechanismNotes.length === 0
        ? "unresolved"
        : confidenceLimited
            ? "limited"
            : "grounded";
    const answerStructure = {
        schema_version: "answer_structure_v1_1",
        answer_summary: buildAnswerSummary(guardedDecision.mode),
        direct_answer: buildDirectAnswer({
            mode: guardedDecision.mode,
            retrievalResults: input.retrievalResults,
            policySignals,
            focusDomain: focusNarrativeDomain
        }),
        mechanism_block: {
            status: mechanismStatus,
            mechanism_notes: mechanismNotes,
            limitation_reason_codes: limitationReasonCodes
        },
        evidence_block: {
            evidence_ids: uniqueStrings(evidenceItems.map((item) => item.evidence_id), 10),
            source_refs: sourceRefs,
            mechanism_notes: mechanismNotes,
            coverage_note: input.coverageReport.requirements_total > 0 &&
                input.coverageReport.requirements_total === input.coverageReport.requirements_covered &&
                input.coverageReport.requirements_uncovered.length === 0 &&
                input.coverageReport.requirements_partially_covered.length === 0
                ? "coverage_full_or_near_full"
                : "coverage_partial_or_limited",
            ...(claimEvidenceLinks.length > 0
                ? {
                    claim_evidence_links: claimEvidenceLinks
                }
                : {})
        },
        uncertainty_block: {
            open_uncertainties: openUncertainties,
            limitations
        },
        next_step_block: {
            recommended_actions: recommendedActions,
            clarification_questions: clarificationQuestions
        }
    };
    const finalAssistantReply = useBoundaryFallbackReply
        ? buildBoundaryFallbackReply({
            userMessage: input.userMessage,
            focusDomain: focusNarrativeDomain,
            missingAnchors,
            coverageReport: input.coverageReport
        })
        : shouldUseSoftPolicyReply({
            mode: guardedDecision.mode,
            policySignals,
            limitationReasonCodes,
            aggregateEvidenceConfidence,
            coverageReport: input.coverageReport,
            hasCriticalEvidenceLimitation
        })
            ? renderSoftPolicyReply({
                structure: answerStructure,
                context: {
                    questionType,
                    focusDomain: focusNarrativeDomain,
                    anchors: anchorUsage,
                    userMessage: input.userMessage
                },
                mode: guardedDecision.mode
            })
            : renderPolicyReply(answerStructure, {
                questionType,
                focusDomain: focusNarrativeDomain,
                anchors: anchorUsage,
                userMessage: input.userMessage
            });
    return {
        assistant_reply: finalAssistantReply,
        fallback_type: guardedDecision.fallback_type,
        reply_type: guardedDecision.reply_type,
        answer_structure_v11: answerStructure,
        problem_centric_answer_applied: false,
        problem_units_used_count: 0,
        problem_answer_mode: "stage1_policy_v11"
    };
}
function composeExplainableAnswer(input, scopeLabel) {
    const graphInsight = collectGraphCausalInsight(input.retrievalResults);
    const facts = extractTopFacts(input.retrievalResults);
    const whyIncludedRaw = extractWhyIncluded(input.retrievalResults);
    const selectionReasonsRaw = extractSelectionReasons(input.retrievalResults);
    const whyIncluded = whyIncludedRaw.length > 0 ? whyIncludedRaw : buildFallbackWhyIncluded(input.retrievalResults);
    const selectionReasons = selectionReasonsRaw.length > 0 ? selectionReasonsRaw : buildFallbackSelectionReasons(input.retrievalResults);
    const riskFactors = extractRiskFactors(input.retrievalResults);
    const interpretation = extractBusinessInterpretation(input.retrievalResults);
    const limitations = uniqueStrings([...extractLimitations(input.retrievalResults), ...input.groundingCheck.reasons]);
    const graphFirstChecks = buildGraphFirstChecks(graphInsight);
    const nextSteps = uniqueStrings([...graphFirstChecks, ...suggestNextStep(input.requirements, input.coverageReport)], 8);
    const graphCausalLines = buildGraphCausalLines(graphInsight);
    const lead = buildGraphProblemFirstLead(graphInsight, scopeLabel);
    const uncertaintyLines = uniqueStrings([
        ...limitations,
        ...(scopeLabel === "partial" ? ["Покрытие частичное: часть вывода требует дополнительной проверки."] : []),
        graphInsight.active
            ? graphInsight.looks_systemic
                ? "Сигнал устойчивый: разрыв повторяется в связанном контуре."
                : "Сигнал ограниченный: часть признаков может быть шумом."
            : "Сигнал ограниченный: сильных graph/lifecycle-индикаторов в верхнем слое мало."
    ], 8);
    return sanitizeUserFacingReply([
        lead,
        facts.length > 0 ? "Подтвержденные наблюдения:\n" + formatList(facts) : "",
        graphCausalLines.length > 0 ? "Почему это похоже на проблему:\n" + formatList(graphCausalLines) : "",
        whyIncluded.length > 0 ? "Что поддерживает вывод:\n" + formatList(whyIncluded) : "",
        selectionReasons.length > 0 ? "Как отбирались сигналы:\n" + formatList(selectionReasons) : "",
        riskFactors.length > 0 ? "Ключевые признаки проблемы:\n" + formatList(riskFactors) : "",
        interpretation.length > 0 ? "Почему это важно для учета:\n" + formatList(interpretation) : "",
        uncertaintyLines.length > 0 ? "Ограничения и уверенность:\n" + formatList(uncertaintyLines) : "",
        nextSteps.length > 0 ? "Что проверить первым делом:\n" + formatList(nextSteps) : ""
    ]
        .filter(Boolean)
        .join("\n\n"));
}
function sanitizeAssistantReplyForUserFacing(value) {
    return sanitizeUserFacingReply(value);
}
function composeAssistantAnswer(input) {
    if (input.enableAnswerPolicyV11) {
        return composeAssistantAnswerV11(input);
    }
    const fallbackType = fallbackFromSummary(input.routeSummary);
    const okResults = input.retrievalResults.filter((item) => item.status === "ok");
    const partialResults = input.retrievalResults.filter((item) => item.status === "partial");
    const emptyResults = input.retrievalResults.filter((item) => item.status === "empty");
    const errorResults = input.retrievalResults.filter((item) => item.status === "error");
    const legacyEvidenceItems = flattenEvidence(input.retrievalResults);
    const legacyLimitationReasonCodes = collectLimitationReasonCodes(legacyEvidenceItems);
    const hasBroadMinimumEvidenceSignal = input.retrievalResults.some((item) => summaryBoolean(item, "broad_guard_applied") && summaryBoolean(item, "minimum_evidence_failed"));
    const hasBroadClarificationSignal = input.retrievalResults.some((item) => summaryBoolean(item, "broad_guard_applied") &&
        summaryBoolean(item, "minimum_evidence_failed") &&
        summaryString(item, "degraded_to") === "clarification");
    if (fallbackType === "out_of_scope" && input.coverageReport.requirements_covered === 0) {
        return {
            assistant_reply: "Я могу отвечать только по данным вашей учетной базы. Этот запрос выходит за рамки доступного контура.",
            fallback_type: "out_of_scope",
            reply_type: "out_of_scope"
        };
    }
    if (input.groundingCheck.status === "route_mismatch_blocked") {
        return {
            assistant_reply: [
                "Не отправляю финальный ответ, потому что предмет результата не совпал с предметом вопроса.",
                "Уточните формулировку (например, нужный счет или участок учета), и я выполню повторный проход."
            ].join("\n\n"),
            fallback_type: "partial",
            reply_type: "route_mismatch_blocked"
        };
    }
    if (input.groundingCheck.status === "no_grounded_answer" && okResults.length === 0 && !hasBroadMinimumEvidenceSignal) {
        return {
            assistant_reply: "Пока не удалось собрать предметно подтвержденный ответ по вашему вопросу. Нужны дополнительные уточнения по периоду или объекту проверки.",
            fallback_type: fallbackType,
            reply_type: "no_grounded_answer"
        };
    }
    if (hasBroadClarificationSignal && okResults.length === 0 && partialResults.length === 0) {
        return {
            assistant_reply: "Запрос слишком широкий для надежного вывода по текущей опоре. Уточните период, участок учета или объект проверки, после чего я дам предметный результат.",
            fallback_type: "clarification",
            reply_type: "clarification_required"
        };
    }
    if (fallbackType === "clarification" && okResults.length === 0 && partialResults.length === 0) {
        return {
            assistant_reply: "Уточните, пожалуйста, период, счет, документ или контрагента, чтобы корректно закрыть все части вопроса.",
            fallback_type: "clarification",
            reply_type: "clarification_required"
        };
    }
    if (errorResults.length > 0 && okResults.length === 0 && partialResults.length === 0) {
        return {
            assistant_reply: "Не удалось получить данные из контура. Попробуйте повторить запрос или уточнить формулировку.",
            fallback_type: fallbackType,
            reply_type: "backend_error"
        };
    }
    if (partialResults.length > 0 && okResults.length === 0) {
        return {
            assistant_reply: composeExplainableAnswer(input, "partial"),
            fallback_type: "partial",
            reply_type: "partial_coverage"
        };
    }
    if (okResults.length === 0 && partialResults.length === 0 && emptyResults.length > 0) {
        return {
            assistant_reply: "По заданному условию в текущем срезе данных явных проблемных записей не найдено.",
            fallback_type: fallbackType,
            reply_type: "empty_but_valid"
        };
    }
    const hasPartialCoverage = input.coverageReport.requirements_uncovered.length > 0 ||
        input.coverageReport.requirements_partially_covered.length > 0 ||
        input.coverageReport.clarification_needed_for.length > 0 ||
        input.coverageReport.out_of_scope_requirements.length > 0 ||
        input.groundingCheck.status === "partial" ||
        errorResults.length > 0 ||
        legacyLimitationReasonCodes.includes("weak_source_mapping") ||
        legacyLimitationReasonCodes.includes("missing_mechanism");
    if (okResults.length > 0 && hasPartialCoverage) {
        return {
            assistant_reply: composeExplainableAnswer(input, "partial"),
            fallback_type: "partial",
            reply_type: "partial_coverage"
        };
    }
    if (okResults.length > 0) {
        return {
            assistant_reply: composeExplainableAnswer(input, "full"),
            fallback_type: "none",
            reply_type: "factual_with_explanation"
        };
    }
    return {
        assistant_reply: "По текущему запросу не удалось построить обоснованный ответ. Уточните формулировку и попробуйте снова.",
        fallback_type: "unknown",
        reply_type: "backend_error"
    };
}