825 lines
34 KiB
JavaScript
825 lines
34 KiB
JavaScript
"use strict";
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.LifecycleRegistry = void 0;
|
||
exports.classifyLifecycleDefect = classifyLifecycleDefect;
|
||
exports.resolveLifecycle = resolveLifecycle;
|
||
exports.enrichProblemUnitLifecycle = enrichProblemUnitLifecycle;
|
||
exports.rankLifecycleProblemUnits = rankLifecycleProblemUnits;
|
||
const stage3Lifecycle_1 = require("../types/stage3Lifecycle");
|
||
function clampUnitScore(value) {
|
||
if (!Number.isFinite(value)) {
|
||
return 0;
|
||
}
|
||
if (value <= 0)
|
||
return 0;
|
||
if (value >= 1)
|
||
return 1;
|
||
return Number(value.toFixed(2));
|
||
}
|
||
function lifecycleConfidenceGrade(score) {
|
||
if (score >= 0.75)
|
||
return "high";
|
||
if (score >= 0.45)
|
||
return "medium";
|
||
return "low";
|
||
}
|
||
function uniqueStrings(values, limit = 16) {
|
||
return Array.from(new Set(values.map((item) => item.trim()).filter(Boolean))).slice(0, limit);
|
||
}
|
||
function includesAny(source, patterns) {
|
||
return patterns.some((pattern) => pattern.test(source));
|
||
}
|
||
function hasToken(values, pattern) {
|
||
return values.some((value) => pattern.test(value));
|
||
}
|
||
function defaultExpectedState(domain) {
|
||
if (domain === "bank_settlement")
|
||
return "settlement_closed";
|
||
if (domain === "customer_settlement")
|
||
return "receivable_closed";
|
||
if (domain === "deferred_expense")
|
||
return "fully_written_off";
|
||
if (domain === "fixed_asset")
|
||
return "depreciation_active";
|
||
if (domain === "vat_flow")
|
||
return "vat_deducted";
|
||
return "close_completed";
|
||
}
|
||
const LIFECYCLE_DOMAIN_MODELS = {
|
||
bank_settlement: {
|
||
schema_version: stage3Lifecycle_1.LIFECYCLE_MODEL_SCHEMA_VERSION,
|
||
lifecycle_domain: "bank_settlement",
|
||
lifecycle_object_types: ["payment_settlement_link"],
|
||
states: [
|
||
{
|
||
state_code: "initiated_payment",
|
||
state_label: "Платеж инициирован",
|
||
state_class: "initial",
|
||
entry_conditions: ["payment_order_created"],
|
||
exit_conditions: ["bank_recorded"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Есть инициирование платежа."
|
||
},
|
||
{
|
||
state_code: "bank_recorded",
|
||
state_label: "Платеж отражен банком",
|
||
state_class: "active",
|
||
entry_conditions: ["bank_statement_recorded"],
|
||
exit_conditions: ["settlement_linked"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Движение денег зафиксировано, ожидается расчетное закрытие."
|
||
},
|
||
{
|
||
state_code: "settlement_closed",
|
||
state_label: "Расчет закрыт",
|
||
state_class: "terminal",
|
||
entry_conditions: ["payment_to_settlement_linked"],
|
||
exit_conditions: [],
|
||
is_terminal: true,
|
||
is_problematic: false,
|
||
business_meaning: "Платеж доведен до расчетного результата."
|
||
},
|
||
{
|
||
state_code: "stale_unlinked_payment",
|
||
state_label: "Платеж завис без закрытия",
|
||
state_class: "problematic",
|
||
entry_conditions: ["bank_recorded", "missing_link"],
|
||
exit_conditions: ["settlement_closed"],
|
||
is_terminal: false,
|
||
is_problematic: true,
|
||
business_meaning: "Платеж отражен, но ожидаемая связь по расчету не завершена."
|
||
},
|
||
{
|
||
state_code: "misclosed_payment",
|
||
state_label: "Платеж закрыт некорректно",
|
||
state_class: "problematic",
|
||
entry_conditions: ["wrong_document_type_or_posting_mismatch"],
|
||
exit_conditions: ["settlement_closed"],
|
||
is_terminal: false,
|
||
is_problematic: true,
|
||
business_meaning: "Формальное закрытие есть, но путь закрытия неверный."
|
||
}
|
||
],
|
||
transitions: [
|
||
{
|
||
from_state: "initiated_payment",
|
||
to_state: "bank_recorded",
|
||
transition_type: "expected",
|
||
required_evidence: ["bank_statement_recorded"],
|
||
optional_evidence: ["payment_order"],
|
||
forbidden_conditions: [],
|
||
business_meaning: "Платеж должен появиться во выписке."
|
||
},
|
||
{
|
||
from_state: "bank_recorded",
|
||
to_state: "settlement_closed",
|
||
transition_type: "expected",
|
||
required_evidence: ["payment_to_settlement_link"],
|
||
optional_evidence: ["document_to_posting"],
|
||
forbidden_conditions: ["wrong_document_type"],
|
||
business_meaning: "После выписки должен закрываться расчет."
|
||
}
|
||
],
|
||
defects: []
|
||
},
|
||
customer_settlement: {
|
||
schema_version: stage3Lifecycle_1.LIFECYCLE_MODEL_SCHEMA_VERSION,
|
||
lifecycle_domain: "customer_settlement",
|
||
lifecycle_object_types: ["receivable_chain"],
|
||
states: [
|
||
{
|
||
state_code: "invoice_issued",
|
||
state_label: "Реализация отражена",
|
||
state_class: "initial",
|
||
entry_conditions: ["realization_document_exists"],
|
||
exit_conditions: ["payment_recorded"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Возникла дебиторская позиция."
|
||
},
|
||
{
|
||
state_code: "payment_recorded",
|
||
state_label: "Оплата отражена",
|
||
state_class: "active",
|
||
entry_conditions: ["payment_document_exists"],
|
||
exit_conditions: ["receivable_closed"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Оплата есть, ожидается корректное закрытие."
|
||
},
|
||
{
|
||
state_code: "receivable_closed",
|
||
state_label: "Дебиторка закрыта",
|
||
state_class: "terminal",
|
||
entry_conditions: ["closing_document_linked"],
|
||
exit_conditions: [],
|
||
is_terminal: true,
|
||
is_problematic: false,
|
||
business_meaning: "Дебиторская позиция закрыта корректно."
|
||
},
|
||
{
|
||
state_code: "stale_receivable",
|
||
state_label: "Дебиторка зависла",
|
||
state_class: "problematic",
|
||
entry_conditions: ["unresolved_settlement"],
|
||
exit_conditions: ["receivable_closed"],
|
||
is_terminal: false,
|
||
is_problematic: true,
|
||
business_meaning: "Позиция остается незавершенной дольше ожидаемого."
|
||
}
|
||
],
|
||
transitions: [
|
||
{
|
||
from_state: "invoice_issued",
|
||
to_state: "payment_recorded",
|
||
transition_type: "expected",
|
||
required_evidence: ["payment_document_exists"],
|
||
optional_evidence: [],
|
||
forbidden_conditions: [],
|
||
business_meaning: "После реализации ожидается оплата/зачет."
|
||
},
|
||
{
|
||
from_state: "payment_recorded",
|
||
to_state: "receivable_closed",
|
||
transition_type: "expected",
|
||
required_evidence: ["closing_document_linked"],
|
||
optional_evidence: ["register_movement_exists"],
|
||
forbidden_conditions: ["cross_branch_inconsistency"],
|
||
business_meaning: "Оплата должна завершаться корректным закрытием расчета."
|
||
}
|
||
],
|
||
defects: []
|
||
},
|
||
deferred_expense: {
|
||
schema_version: stage3Lifecycle_1.LIFECYCLE_MODEL_SCHEMA_VERSION,
|
||
lifecycle_domain: "deferred_expense",
|
||
lifecycle_object_types: ["deferred_expense_item"],
|
||
states: [
|
||
{
|
||
state_code: "recognized",
|
||
state_label: "РБП признан",
|
||
state_class: "initial",
|
||
entry_conditions: ["deferred_expense_created"],
|
||
exit_conditions: ["writeoff_started"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "РБП поставлен на учет."
|
||
},
|
||
{
|
||
state_code: "partially_written_off",
|
||
state_label: "Частичное списание",
|
||
state_class: "active",
|
||
entry_conditions: ["partial_writeoff_exists"],
|
||
exit_conditions: ["fully_written_off"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Списание идет по графику."
|
||
},
|
||
{
|
||
state_code: "fully_written_off",
|
||
state_label: "РБП полностью списан",
|
||
state_class: "terminal",
|
||
entry_conditions: ["full_writeoff_exists"],
|
||
exit_conditions: [],
|
||
is_terminal: true,
|
||
is_problematic: false,
|
||
business_meaning: "РБП завершил lifecycle."
|
||
},
|
||
{
|
||
state_code: "overdue_writeoff",
|
||
state_label: "Просроченное списание",
|
||
state_class: "problematic",
|
||
entry_conditions: ["period_boundary", "missing_link"],
|
||
exit_conditions: ["fully_written_off"],
|
||
is_terminal: false,
|
||
is_problematic: true,
|
||
business_meaning: "РБП живет дольше допустимого окна."
|
||
}
|
||
],
|
||
transitions: [],
|
||
defects: []
|
||
},
|
||
fixed_asset: {
|
||
schema_version: stage3Lifecycle_1.LIFECYCLE_MODEL_SCHEMA_VERSION,
|
||
lifecycle_domain: "fixed_asset",
|
||
lifecycle_object_types: ["fixed_asset_card"],
|
||
states: [
|
||
{
|
||
state_code: "capitalized",
|
||
state_label: "Капвложения отражены",
|
||
state_class: "initial",
|
||
entry_conditions: ["capitalization_document_exists"],
|
||
exit_conditions: ["accepted_for_accounting"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Объект зафиксирован как вложение."
|
||
},
|
||
{
|
||
state_code: "accepted_for_accounting",
|
||
state_label: "Принят к учету",
|
||
state_class: "active",
|
||
entry_conditions: ["acceptance_document_exists"],
|
||
exit_conditions: ["depreciation_active"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Объект переведен в основной контур учета."
|
||
},
|
||
{
|
||
state_code: "depreciation_active",
|
||
state_label: "Амортизация активна",
|
||
state_class: "active",
|
||
entry_conditions: ["depreciation_register_movement"],
|
||
exit_conditions: ["disposed"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Жизненный цикл ОС идет штатно."
|
||
},
|
||
{
|
||
state_code: "contradictory_asset_state",
|
||
state_label: "Противоречивый статус ОС",
|
||
state_class: "problematic",
|
||
entry_conditions: ["posting_mismatch_or_wrong_path"],
|
||
exit_conditions: ["depreciation_active"],
|
||
is_terminal: false,
|
||
is_problematic: true,
|
||
business_meaning: "Статус ОС формально есть, но смыслово противоречив."
|
||
},
|
||
{
|
||
state_code: "disposed",
|
||
state_label: "Выбыл",
|
||
state_class: "terminal",
|
||
entry_conditions: ["disposal_document_exists"],
|
||
exit_conditions: [],
|
||
is_terminal: true,
|
||
is_problematic: false,
|
||
business_meaning: "Жизненный цикл ОС завершен."
|
||
}
|
||
],
|
||
transitions: [],
|
||
defects: []
|
||
},
|
||
vat_flow: {
|
||
schema_version: stage3Lifecycle_1.LIFECYCLE_MODEL_SCHEMA_VERSION,
|
||
lifecycle_domain: "vat_flow",
|
||
lifecycle_object_types: ["vat_document_chain"],
|
||
states: [
|
||
{
|
||
state_code: "vat_registered",
|
||
state_label: "НДС отражен документно",
|
||
state_class: "initial",
|
||
entry_conditions: ["invoice_registered"],
|
||
exit_conditions: ["vat_reflected"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Сформирован первичный документный слой НДС."
|
||
},
|
||
{
|
||
state_code: "vat_reflected",
|
||
state_label: "НДС отражен в учете",
|
||
state_class: "active",
|
||
entry_conditions: ["vat_register_movement"],
|
||
exit_conditions: ["vat_deducted"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "НДС проходит штатную стадию отражения."
|
||
},
|
||
{
|
||
state_code: "vat_deducted",
|
||
state_label: "НДС принят к вычету",
|
||
state_class: "terminal",
|
||
entry_conditions: ["deduction_confirmed"],
|
||
exit_conditions: [],
|
||
is_terminal: true,
|
||
is_problematic: false,
|
||
business_meaning: "НДС-цепочка завершена корректно."
|
||
},
|
||
{
|
||
state_code: "vat_conflict",
|
||
state_label: "Конфликт НДС-цепочки",
|
||
state_class: "problematic",
|
||
entry_conditions: ["cross_branch_inconsistency"],
|
||
exit_conditions: ["vat_reflected"],
|
||
is_terminal: false,
|
||
is_problematic: true,
|
||
business_meaning: "Бухгалтерская и налоговая ветки расходятся."
|
||
}
|
||
],
|
||
transitions: [],
|
||
defects: []
|
||
},
|
||
period_close: {
|
||
schema_version: stage3Lifecycle_1.LIFECYCLE_MODEL_SCHEMA_VERSION,
|
||
lifecycle_domain: "period_close",
|
||
lifecycle_object_types: ["period_close_blocker"],
|
||
states: [
|
||
{
|
||
state_code: "preclose_checks",
|
||
state_label: "Предзакрытие",
|
||
state_class: "active",
|
||
entry_conditions: ["period_scope_detected"],
|
||
exit_conditions: ["close_ready"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Идет проверка готовности периода."
|
||
},
|
||
{
|
||
state_code: "close_ready",
|
||
state_label: "Готов к закрытию",
|
||
state_class: "active",
|
||
entry_conditions: ["no_blockers_detected"],
|
||
exit_conditions: ["close_completed"],
|
||
is_terminal: false,
|
||
is_problematic: false,
|
||
business_meaning: "Период может быть закрыт."
|
||
},
|
||
{
|
||
state_code: "close_completed",
|
||
state_label: "Закрытие завершено",
|
||
state_class: "terminal",
|
||
entry_conditions: ["close_operation_done"],
|
||
exit_conditions: [],
|
||
is_terminal: true,
|
||
is_problematic: false,
|
||
business_meaning: "Период закрыт."
|
||
},
|
||
{
|
||
state_code: "close_blocked",
|
||
state_label: "Закрытие заблокировано",
|
||
state_class: "problematic",
|
||
entry_conditions: ["period_close_risk_or_stale_state"],
|
||
exit_conditions: ["close_ready"],
|
||
is_terminal: false,
|
||
is_problematic: true,
|
||
business_meaning: "Есть lifecycle-дефекты, влияющие на закрытие."
|
||
},
|
||
{
|
||
state_code: "close_contradicted",
|
||
state_label: "Закрыт формально, но с противоречием",
|
||
state_class: "problematic",
|
||
entry_conditions: ["misclosed_or_cross_branch_conflict"],
|
||
exit_conditions: ["close_completed"],
|
||
is_terminal: false,
|
||
is_problematic: true,
|
||
business_meaning: "Формальное закрытие не согласовано с фактическими ветками."
|
||
}
|
||
],
|
||
transitions: [],
|
||
defects: []
|
||
}
|
||
};
|
||
const SHARED_DEFECTS = [
|
||
{
|
||
defect_code: "missing_expected_transition",
|
||
defect_class: "path",
|
||
severity_hint: "medium",
|
||
business_meaning: "Ожидаемый переход не произошел.",
|
||
evidence_requirements: ["expected_state", "missing_transition_signal"],
|
||
period_impact_potential: "indirect"
|
||
},
|
||
{
|
||
defect_code: "invalid_transition",
|
||
defect_class: "path",
|
||
severity_hint: "high",
|
||
business_meaning: "Переход произошел по некорректному пути.",
|
||
evidence_requirements: ["invalid_transition_signal"],
|
||
period_impact_potential: "indirect"
|
||
},
|
||
{
|
||
defect_code: "stale_active_state",
|
||
defect_class: "timing",
|
||
severity_hint: "high",
|
||
business_meaning: "Объект завис в активном состоянии.",
|
||
evidence_requirements: ["stale_marker", "missing_transition_signal"],
|
||
period_impact_potential: "direct"
|
||
},
|
||
{
|
||
defect_code: "contradictory_state",
|
||
defect_class: "consistency",
|
||
severity_hint: "high",
|
||
business_meaning: "Статусы объекта противоречат друг другу.",
|
||
evidence_requirements: ["contradiction_signal"],
|
||
period_impact_potential: "direct"
|
||
},
|
||
{
|
||
defect_code: "premature_terminal_state",
|
||
defect_class: "closure",
|
||
severity_hint: "medium",
|
||
business_meaning: "Терминальное состояние наступило преждевременно.",
|
||
evidence_requirements: ["terminal_state", "missing_required_previous_state"],
|
||
period_impact_potential: "indirect"
|
||
},
|
||
{
|
||
defect_code: "misclosed_state",
|
||
defect_class: "closure",
|
||
severity_hint: "high",
|
||
business_meaning: "Контур формально закрыт, но закрыт неверно.",
|
||
evidence_requirements: ["wrong_closure_path"],
|
||
period_impact_potential: "direct"
|
||
},
|
||
{
|
||
defect_code: "orphan_intermediate_state",
|
||
defect_class: "path",
|
||
severity_hint: "medium",
|
||
business_meaning: "Промежуточная стадия осталась без корректного продолжения.",
|
||
evidence_requirements: ["intermediate_state_without_next"],
|
||
period_impact_potential: "indirect"
|
||
},
|
||
{
|
||
defect_code: "cross_branch_state_conflict",
|
||
defect_class: "consistency",
|
||
severity_hint: "high",
|
||
business_meaning: "Состояния соседних веток учета противоречат друг другу.",
|
||
evidence_requirements: ["cross_branch_conflict_signal"],
|
||
period_impact_potential: "direct"
|
||
}
|
||
];
|
||
for (const domain of stage3Lifecycle_1.STAGE3_LIFECYCLE_DOMAINS) {
|
||
LIFECYCLE_DOMAIN_MODELS[domain].defects = SHARED_DEFECTS;
|
||
}
|
||
class LifecycleRegistryImpl {
|
||
models;
|
||
constructor(models) {
|
||
this.models = models;
|
||
}
|
||
listDomains() {
|
||
return stage3Lifecycle_1.STAGE3_LIFECYCLE_DOMAINS.slice();
|
||
}
|
||
getDomain(domain) {
|
||
return this.models[domain];
|
||
}
|
||
}
|
||
exports.LifecycleRegistry = new LifecycleRegistryImpl(LIFECYCLE_DOMAIN_MODELS);
|
||
function inferLifecycleDomain(input) {
|
||
const unitTokens = [
|
||
input.unit.problem_unit_type,
|
||
input.unit.business_defect_class,
|
||
input.unit.mechanism_summary,
|
||
input.unit.failed_expected_edge ?? "",
|
||
input.unit.expected_state ?? "",
|
||
input.unit.actual_state ?? "",
|
||
...input.unit.affected_accounts,
|
||
...input.unit.affected_entities,
|
||
...input.unit.affected_documents,
|
||
...input.unit.affected_counterparties,
|
||
...input.candidates.flatMap((item) => item.anomaly_patterns),
|
||
...input.candidates.flatMap((item) => item.relation_pattern_hits)
|
||
]
|
||
.join(" ")
|
||
.toLowerCase();
|
||
if (includesAny(unitTokens, [/\bnds\b/, /\bvat\b/, /\btax\b/, /cross[_\s-]?branch/, /\b19\b/, /\b68\b/])) {
|
||
return "vat_flow";
|
||
}
|
||
if (includesAny(unitTokens, [/\bperiod\b/, /\bclose\b/, /закрыт/, /reporting/]) || input.unit.problem_unit_type === "period_risk_cluster") {
|
||
return "period_close";
|
||
}
|
||
if (includesAny(unitTokens, [/deferred/, /writeoff/, /рбп/, /\b97\b/])) {
|
||
return "deferred_expense";
|
||
}
|
||
if (includesAny(unitTokens, [/fixed[_\s-]?asset/, /амортиз/, /ос\b/, /\b01\b/, /\b02\b/, /\b08\b/])) {
|
||
return "fixed_asset";
|
||
}
|
||
if (includesAny(unitTokens, [/buyer/, /customer/, /дебитор/, /\b62\b/])) {
|
||
return "customer_settlement";
|
||
}
|
||
return "bank_settlement";
|
||
}
|
||
function inferCurrentState(domain, input) {
|
||
const explicitActual = input.unit.actual_state?.trim();
|
||
if (explicitActual) {
|
||
return explicitActual;
|
||
}
|
||
const anomalies = input.candidates.flatMap((item) => item.anomaly_patterns).map((item) => item.toLowerCase());
|
||
const relations = input.candidates.flatMap((item) => item.relation_pattern_hits).map((item) => item.toLowerCase());
|
||
const hasStale = hasToken(anomalies, /(no_continuation|stale|tail|missing_link|broken_lifecycle|partially_linked)/);
|
||
const hasInvalid = hasToken(anomalies, /(posting_mismatch|wrong_document_type|cross_domain_inconsistency|misclose|cross_branch)/);
|
||
if (domain === "bank_settlement") {
|
||
if (hasInvalid)
|
||
return "misclosed_payment";
|
||
if (hasStale)
|
||
return "stale_unlinked_payment";
|
||
if (hasToken(relations, /payment_to_settlement/))
|
||
return "bank_recorded";
|
||
return "initiated_payment";
|
||
}
|
||
if (domain === "customer_settlement") {
|
||
if (hasStale)
|
||
return "stale_receivable";
|
||
if (hasToken(relations, /payment|settlement/))
|
||
return "payment_recorded";
|
||
return "invoice_issued";
|
||
}
|
||
if (domain === "deferred_expense") {
|
||
if (hasStale)
|
||
return "overdue_writeoff";
|
||
if (hasToken(relations, /writeoff|partial/))
|
||
return "partially_written_off";
|
||
return "recognized";
|
||
}
|
||
if (domain === "fixed_asset") {
|
||
if (hasInvalid)
|
||
return "contradictory_asset_state";
|
||
if (hasToken(relations, /depreciation|amort/))
|
||
return "depreciation_active";
|
||
if (hasToken(relations, /accept|учет/))
|
||
return "accepted_for_accounting";
|
||
return "capitalized";
|
||
}
|
||
if (domain === "vat_flow") {
|
||
if (hasInvalid || hasToken(anomalies, /cross_branch|inconsistency/))
|
||
return "vat_conflict";
|
||
if (hasToken(relations, /invoice_to_vat|vat/))
|
||
return "vat_reflected";
|
||
return "vat_registered";
|
||
}
|
||
if (hasInvalid)
|
||
return "close_contradicted";
|
||
if (hasStale || input.unit.period_impact?.impact_class === "close_risk")
|
||
return "close_blocked";
|
||
return "preclose_checks";
|
||
}
|
||
function inferExpectedState(domain, input) {
|
||
const explicitExpected = input.unit.expected_state?.trim();
|
||
if (explicitExpected) {
|
||
return explicitExpected;
|
||
}
|
||
return defaultExpectedState(domain);
|
||
}
|
||
function inferMissingTransition(input) {
|
||
if (typeof input.unit.failed_expected_edge === "string" && input.unit.failed_expected_edge.trim().length > 0) {
|
||
return input.unit.failed_expected_edge.trim();
|
||
}
|
||
const anomalies = input.candidates.flatMap((item) => item.anomaly_patterns).join(" ").toLowerCase();
|
||
if (/(missing_link|no_continuation|broken_lifecycle|tail|unresolved)/.test(anomalies)) {
|
||
return "expected_transition_not_observed";
|
||
}
|
||
return null;
|
||
}
|
||
function inferInvalidTransition(input) {
|
||
const anomalies = input.candidates.flatMap((item) => item.anomaly_patterns).join(" ").toLowerCase();
|
||
if (/(cross_branch|cross_domain_inconsistency)/.test(anomalies)) {
|
||
return "cross_branch_conflict_transition";
|
||
}
|
||
if (/(wrong_document_type|posting_mismatch|misclose)/.test(anomalies)) {
|
||
return "invalid_document_or_posting_transition";
|
||
}
|
||
return null;
|
||
}
|
||
function classifyLifecycleDefect(input) {
|
||
const current = input.currentState.toLowerCase();
|
||
if (input.invalidTransition?.includes("cross_branch")) {
|
||
return "cross_branch_state_conflict";
|
||
}
|
||
if (input.invalidTransition) {
|
||
if (current.includes("misclosed") || input.domain === "period_close") {
|
||
return "misclosed_state";
|
||
}
|
||
return "invalid_transition";
|
||
}
|
||
if (input.missingTransition) {
|
||
if (current.includes("stale") || current.includes("overdue") || input.periodCloseSensitive) {
|
||
return "stale_active_state";
|
||
}
|
||
return "missing_expected_transition";
|
||
}
|
||
if (current.includes("contradict")) {
|
||
return "contradictory_state";
|
||
}
|
||
if (current.includes("closed") && !input.expectedState.toLowerCase().includes("closed")) {
|
||
return "premature_terminal_state";
|
||
}
|
||
if (input.currentState !== input.expectedState && !input.currentState.toLowerCase().includes("closed")) {
|
||
return "orphan_intermediate_state";
|
||
}
|
||
return null;
|
||
}
|
||
function resolutionConfidence(unitConfidence, input) {
|
||
let score = unitConfidence.score;
|
||
if (input.hasExplicitStates)
|
||
score += 0.1;
|
||
if (input.hasDefectSignal)
|
||
score += 0.08;
|
||
if (input.candidateCount >= 2)
|
||
score += 0.05;
|
||
if (input.hasSnapshotLimitations)
|
||
score -= 0.12;
|
||
const normalized = clampUnitScore(score);
|
||
return {
|
||
score: normalized,
|
||
grade: lifecycleConfidenceGrade(normalized)
|
||
};
|
||
}
|
||
function staleDurationHint(domain, defect, input) {
|
||
const anomalies = input.candidates.flatMap((item) => item.anomaly_patterns).join(" ").toLowerCase();
|
||
if (defect !== "stale_active_state") {
|
||
return undefined;
|
||
}
|
||
if (/(period_boundary|period|close_risk)/.test(anomalies) || domain === "period_close") {
|
||
return "period_boundary_exceeded";
|
||
}
|
||
return "unknown_snapshot_window";
|
||
}
|
||
function lifecycleInterpretation(input) {
|
||
const base = `Текущая стадия: ${input.currentState}; ожидаемая стадия: ${input.expectedState}.`;
|
||
if (input.defect === "stale_active_state") {
|
||
return `${base} Объект завис во времени и не дошел до ожидаемого перехода.`;
|
||
}
|
||
if (input.defect === "misclosed_state") {
|
||
return `${base} Контур закрыт формально, но путь закрытия противоречит бухгалтерской логике.`;
|
||
}
|
||
if (input.defect === "cross_branch_state_conflict") {
|
||
return `${base} Между ветками домена ${input.domain} обнаружено противоречие состояний.`;
|
||
}
|
||
if (input.defect === "missing_expected_transition") {
|
||
return `${base} Не зафиксирован ожидаемый переход (${input.missingTransition ?? "unknown_transition"}).`;
|
||
}
|
||
if (input.defect === "invalid_transition") {
|
||
return `${base} Зафиксирован некорректный переход (${input.invalidTransition ?? "invalid_transition"}).`;
|
||
}
|
||
return `${base} Lifecycle-разрешение не выявило критичный дефект, но состояние требует наблюдения.`;
|
||
}
|
||
function resolveLifecycle(input) {
|
||
const lifecycle_domain = inferLifecycleDomain(input);
|
||
const currentState = inferCurrentState(lifecycle_domain, input);
|
||
const expectedState = inferExpectedState(lifecycle_domain, input);
|
||
const missingTransition = inferMissingTransition(input);
|
||
const invalidTransition = inferInvalidTransition(input);
|
||
const defect = classifyLifecycleDefect({
|
||
domain: lifecycle_domain,
|
||
currentState,
|
||
expectedState,
|
||
missingTransition,
|
||
invalidTransition,
|
||
periodCloseSensitive: input.unit.period_impact?.impact_class === "close_risk"
|
||
});
|
||
const evidenceIds = uniqueStrings(input.unit.evidence_pack, 8);
|
||
const limitations = uniqueStrings([
|
||
...input.unit.snapshot_limitations,
|
||
...(input.candidates.some((item) => item.confidence_hint === "low") ? ["low_confidence_candidates_present"] : []),
|
||
...(input.unit.actual_state ? [] : ["actual_state_inferred"]),
|
||
...(input.unit.expected_state ? [] : ["expected_state_inferred"])
|
||
], 8);
|
||
const confidence = resolutionConfidence(input.unit.confidence, {
|
||
hasExplicitStates: Boolean(input.unit.actual_state || input.unit.expected_state),
|
||
hasDefectSignal: Boolean(defect || missingTransition || invalidTransition),
|
||
candidateCount: input.candidates.length,
|
||
hasSnapshotLimitations: limitations.length > 0
|
||
});
|
||
return {
|
||
lifecycle_object_id: `lcobj-${input.unit.problem_unit_id}`,
|
||
lifecycle_domain,
|
||
resolved_current_state: currentState,
|
||
resolved_expected_state: expectedState,
|
||
resolved_previous_states: [],
|
||
missing_transitions: missingTransition ? [missingTransition] : [],
|
||
invalid_transitions: invalidTransition ? [invalidTransition] : [],
|
||
detected_defects: defect ? [defect] : [],
|
||
state_confidence: confidence,
|
||
resolution_evidence: evidenceIds,
|
||
snapshot_limitations: limitations
|
||
};
|
||
}
|
||
function lifecycleRanking(defect, input) {
|
||
let score = input.unit.severity.score;
|
||
const basis = ["base_problem_severity"];
|
||
if (defect === "cross_branch_state_conflict") {
|
||
score += 0.55;
|
||
basis.push("cross_branch_conflict_weight");
|
||
}
|
||
else if (defect === "misclosed_state") {
|
||
score += 0.45;
|
||
basis.push("misclosed_state_weight");
|
||
}
|
||
else if (defect === "stale_active_state") {
|
||
score += 0.35;
|
||
basis.push("stale_duration_weight");
|
||
}
|
||
else if (defect === "invalid_transition") {
|
||
score += 0.3;
|
||
basis.push("invalid_transition_weight");
|
||
}
|
||
else if (defect === "missing_expected_transition") {
|
||
score += 0.25;
|
||
basis.push("missing_transition_weight");
|
||
}
|
||
if (input.staleDuration) {
|
||
score += 0.15;
|
||
basis.push("stale_duration_present");
|
||
}
|
||
if (input.unit.period_impact?.impact_class === "close_risk") {
|
||
score += 0.22;
|
||
basis.push("period_close_impact");
|
||
}
|
||
if (input.resolution.state_confidence.grade === "high") {
|
||
score += 0.08;
|
||
basis.push("state_confidence_weight");
|
||
}
|
||
return {
|
||
lifecycle_ranking_score: Number(score.toFixed(2)),
|
||
lifecycle_ranking_basis: basis
|
||
};
|
||
}
|
||
function enrichProblemUnitLifecycle(input) {
|
||
const resolution = resolveLifecycle(input);
|
||
const defect = resolution.detected_defects[0] ?? null;
|
||
const staleDuration = staleDurationHint(resolution.lifecycle_domain, defect, input);
|
||
const ranking = lifecycleRanking(defect, {
|
||
unit: input.unit,
|
||
resolution,
|
||
staleDuration
|
||
});
|
||
return {
|
||
...input.unit,
|
||
lifecycle_domain: resolution.lifecycle_domain,
|
||
lifecycle_object_id: resolution.lifecycle_object_id,
|
||
current_lifecycle_state: resolution.resolved_current_state,
|
||
expected_lifecycle_state: resolution.resolved_expected_state,
|
||
...(resolution.missing_transitions.length > 0
|
||
? {
|
||
missing_transition: resolution.missing_transitions[0]
|
||
}
|
||
: {}),
|
||
...(resolution.invalid_transitions.length > 0
|
||
? {
|
||
invalid_transition: resolution.invalid_transitions[0]
|
||
}
|
||
: {}),
|
||
...(defect
|
||
? {
|
||
lifecycle_defect_type: defect
|
||
}
|
||
: {}),
|
||
...(staleDuration
|
||
? {
|
||
stale_duration: staleDuration
|
||
}
|
||
: {}),
|
||
lifecycle_confidence: resolution.state_confidence,
|
||
business_lifecycle_interpretation: lifecycleInterpretation({
|
||
domain: resolution.lifecycle_domain,
|
||
currentState: resolution.resolved_current_state,
|
||
expectedState: resolution.resolved_expected_state,
|
||
defect,
|
||
missingTransition: resolution.missing_transitions[0] ?? null,
|
||
invalidTransition: resolution.invalid_transitions[0] ?? null
|
||
}),
|
||
lifecycle_resolution: resolution,
|
||
lifecycle_ranking_score: ranking.lifecycle_ranking_score,
|
||
lifecycle_ranking_basis: ranking.lifecycle_ranking_basis
|
||
};
|
||
}
|
||
function rankLifecycleProblemUnits(units) {
|
||
return units
|
||
.slice()
|
||
.sort((left, right) => {
|
||
const rankDiff = (right.lifecycle_ranking_score ?? 0) - (left.lifecycle_ranking_score ?? 0);
|
||
if (rankDiff !== 0)
|
||
return rankDiff;
|
||
const severityDiff = right.severity.score - left.severity.score;
|
||
if (severityDiff !== 0)
|
||
return severityDiff;
|
||
return right.confidence.score - left.confidence.score;
|
||
});
|
||
}
|