BPOS-TMP-REPO/apps/api/src/modules/loop-engine/__tests__/cmmn.test.ts

/** CMMN 子集解析、生命周期与 DMN —— domain 测试零 mock(AM 03 / 04) */
import { describe, expect, it } from 'vitest';
import type { DmnDecisionTable, DmnModel } from '@contracts';
import type { CaseRuntime } from '../internal/domain/lifecycle.ts';
import { CmmnParseError, parseCmmn } from '../internal/domain/cmmn-parse.ts';
import {
  autoCompleteReady,
  canTransitionItem,
  IllegalTransitionError,
  initialRuntime,
  markWorldTouched,
  mayCompleteCase,
  mayTerminateCase,
  navigate,
  occur,
  publishEnabled,
  reenter,
  transitionItem,
} from '../internal/domain/lifecycle.ts';
import { deduceGaps, evaluateTable, evaluationOrder } from '../internal/domain/dmn.ts';

/** 渠道寻源 A3 的极简案例模型 —— 取自 MVP 示例(S1 接需核史 → S2 选渠定策 → S3 发询比价) */
const XML = `<?xml version="1.0"?>
<definitions xmlns="http://www.omg.org/spec/CMMN/20151109/MODEL">
  <case id="sourcing">
    <caseFileModel>
      <caseFileItem id="inquiry" name="询价请求"/>
      <caseFileItem id="quotes" name="供应商回价单"/>
    </caseFileModel>
    <casePlanModel id="plan" name="渠道寻源" autoComplete="true">
      <sentry id="s_after_inquiry">
        <onPart id="op1" caseFileItemRef="inquiry"><standardEvent>create</standardEvent></onPart>
      </sentry>
      <sentry id="s_semantic">
        <onPart id="op2" caseFileItemRef="quotes"><standardEvent>create</standardEvent></onPart>
        <ifPart id="ip1"><condition>semantic: 回价是否可信</condition></ifPart>
      </sentry>
      <stage id="S1" name="接需核史" autoComplete="true">
        <entryCriterion id="ec1" sentryRef="s_after_inquiry"/>
        <humanTask id="T1" name="人工查历史报价">
          <itemControl><manualActivationRule id="m1"/></itemControl>
        </humanTask>
        <decisionTask id="D1" name="判定采用策略" decisionRef="strategy"/>
        <planningTable id="pt1">
          <humanTask id="T2" name="人工渠道资质核实"/>
        </planningTable>
      </stage>
      <milestone id="M1" name="策略已定"/>
      <timerEventListener id="TL1" name="时限预警">
        <timerExpression>P4D</timerExpression>
      </timerEventListener>
    </casePlanModel>
  </case>
</definitions>`;

describe('parseCmmn —— 子集封顶', () => {
  const model = parseCmmn(XML);

  it('读出案计划与自动完成', () => {
    expect(model.name).toBe('渠道寻源');
    expect(model.autoComplete).toBe(true);
  });

  it('读出任务数据(CaseFileItem)', () => {
    expect(model.fileItems.map((f) => f.id)).toEqual(['inquiry', 'quotes']);
  });

  it('读出全部计划项与类型', () => {
    expect(model.items.map((i) => `${i.id}:${i.type}`)).toEqual([
      'S1:stage',
      'T1:humanTask',
      'D1:decisionTask',
      'T2:humanTask',
      'M1:milestone',
      'TL1:timerEventListener',
    ]);
  });

  it('manualActivationRule 被识别 —— Enabled ≠ Active', () => {
    expect(model.items.find((i) => i.id === 'T1')?.manualActivation).toBe(true);
    expect(model.items.find((i) => i.id === 'D1')?.manualActivation).toBe(false);
  });

  it('planning table 里的项标为裁量项', () => {
    expect(model.items.find((i) => i.id === 'T2')?.discretionary).toBe(true);
    expect(model.items.find((i) => i.id === 'T1')?.discretionary).toBe(false);
  });

  it('entryCriterion 关到 sentry 的 onPart', () => {
    const stage = model.items.find((i) => i.id === 'S1');
    expect(stage?.entryCriteria[0]?.onParts[0]).toEqual({ kind: 'file', ref: 'inquiry', event: 'create' });
  });

  it('decisionRef 与 timerExpression', () => {
    expect(model.items.find((i) => i.id === 'D1')?.decisionRef).toBe('strategy');
    expect(model.items.find((i) => i.id === 'TL1')?.timerExpression).toBe('P4D');
  });

  it('表外构件直接报错 —— 不静默忽略', () => {
    const bad = XML.replace('<milestone id="M1" name="策略已定"/>', '<eventListener id="X"/>');
    expect(() => parseCmmn(bad)).toThrow(CmmnParseError);
  });

  it('标签不匹配报错', () => {
    expect(() => parseCmmn('<definitions><case id="a"></definitions>')).toThrow(CmmnParseError);
  });
});

describe('生命周期 —— 语义忠实,引擎不得私改迁移拓扑', () => {
  it('计划项八态的合法迁移', () => {
    expect(canTransitionItem('Available', 'Enabled')).toBe(true);
    expect(canTransitionItem('Enabled', 'Active')).toBe(true);
    expect(canTransitionItem('Active', 'Completed')).toBe(true);
    expect(canTransitionItem('Enabled', 'Completed')).toBe(false);
    expect(canTransitionItem('Completed', 'Active')).toBe(false);
  });

  it('非法迁移抛错', () => {
    const model = parseCmmn(XML);
    const runtime = initialRuntime(model);
    expect(() => transitionItem(runtime, 'T1', 'Completed')).toThrow(IllegalTransitionError);
  });

  it('里程碑只有一条主迁移 Available →(occur)→ Completed', () => {
    const model = parseCmmn(XML);
    const next = occur(initialRuntime(model), 'M1');
    expect(next.items.find((i) => i.id === 'M1')?.state).toBe('Completed');
    expect(next.milestones).toEqual(['M1']);
  });

  it('驳回是迁移不是状态:新实例重新入场', () => {
    const model = parseCmmn(XML);
    let runtime = transitionItem(initialRuntime(model), 'T1', 'Enabled');
    runtime = transitionItem(runtime, 'T1', 'Active');
    const next = reenter(runtime, 'T1');
    expect(next.items.find((i) => i.id === 'T1')).toEqual({ id: 'T1', state: 'Available', instance: 2 });
  });

  describe('markWorldTouched —— finish 前的证据(AM 12.2 原理一)', () => {
    it('标一个项 —— 其余项原样不动', () => {
      const model = parseCmmn(XML);
      const next = markWorldTouched(initialRuntime(model), 'T1');
      expect(next.items.find((i) => i.id === 'T1')?.worldTouched).toBe(true);
      expect(next.items.find((i) => i.id !== 'T1')?.worldTouched).toBeUndefined();
    });

    it('驳回重新入场是新实例 —— 标记不带过去,得重新证明真触达过', () => {
      const model = parseCmmn(XML);
      const touched = markWorldTouched(initialRuntime(model), 'T1');
      const next = reenter(touched, 'T1');
      expect(next.items.find((i) => i.id === 'T1')?.worldTouched).toBeUndefined();
    });
  });
});

describe('终局唯放行与 Harness —— AI 不得产生终局迁移', () => {
  it('Completed 只出自放行', () => {
    expect(mayCompleteCase('release')).toBe(true);
    expect(mayCompleteCase('harness')).toBe(false);
    expect(mayCompleteCase('owner')).toBe(false);
  });
  it('Terminated 只出自 Harness / 负责人 / 治理台', () => {
    expect(mayTerminateCase('harness')).toBe(true);
    expect(mayTerminateCase('owner')).toBe(true);
    expect(mayTerminateCase('governance')).toBe(true);
    expect(mayTerminateCase('release')).toBe(false);
  });
});

describe('publishEnabled —— 引擎推进到 Enabled 为止', () => {
  const model = parseCmmn(XML);

  it('前提未满足时不发布', () => {
    const enabled = publishEnabled(model, initialRuntime(model), {}, new Set(), () => true);
    expect(enabled.entries.map((e) => e.id)).not.toContain('S1');
  });

  it('onPart 件到 + 无 ifPart → Enabled', () => {
    const enabled = publishEnabled(model, initialRuntime(model), { inquiry: {} }, new Set(['inquiry']), () => true);
    expect(enabled.entries.map((e) => e.id)).toContain('S1');
  });

  it('父阶段未激活的子项不入场', () => {
    const enabled = publishEnabled(model, initialRuntime(model), { inquiry: {} }, new Set(['inquiry']), () => true);
    expect(enabled.entries.map((e) => e.id)).not.toContain('T1');
  });

  it('manualActivation 的项标出「须 Agent 启动」', () => {
    let runtime = initialRuntime(model);
    runtime = transitionItem(runtime, 'S1', 'Enabled');
    runtime = transitionItem(runtime, 'S1', 'Active');
    const enabled = publishEnabled(model, runtime, { inquiry: {} }, new Set(['inquiry']), () => true);
    expect(enabled.entries.find((e) => e.id === 'T1')?.requiresManualStart).toBe(true);
  });
});

describe('navigate —— 导航即交集,断点即人环', () => {
  it('有交集即择优推进', () => {
    const nav = navigate(
      { entries: [{ id: 'a', name: 'A', type: 'humanTask', requiresManualStart: true, discretionary: false }], inProgress: [], judgements: [], gaps: ['缺报价'], activeStages: [] },
      new Set(['a']),
    );
    expect(nav.kind).toBe('proceed');
  });

  it('交集为空**且手上没开着的活**才是断点 —— 调人或立监听的判定时机', () => {
    const nav = navigate({ entries: [], inProgress: [], judgements: [], gaps: ['缺客户信用'], activeStages: [] }, new Set(['a']));
    expect(nav).toEqual({ kind: 'breakpoint', gaps: ['缺客户信用'] });
  });

  /*
   * 断点的定义是「无路可走」。手上还有开着的活就不算 —— 从前只看 Enabled 集,
   * 局面推进开以后手上全是 Active,每拍都判成断点,而断点的处置是「调人或立监听」:
   * 环于是把没干完的活丢下,去等一个不会来的事件。
   */
  it('Enabled 为空但有进行中的项 → 接着干,不是断点', () => {
    const nav = navigate(
      {
        entries: [],
        inProgress: [{ id: 'w', name: '正在查历史价', type: 'humanTask', requiresManualStart: false, discretionary: false }],
        judgements: [],
        gaps: ['缺分类表'],
        activeStages: [],
      },
      new Set(['nothing']),
    );
    expect(nav).toEqual({ kind: 'proceed', candidates: [{ id: 'w', name: '正在查历史价', type: 'humanTask', requiresManualStart: false, discretionary: false }] });
  });

  it('无缺口即收敛', () => {
    expect(navigate({ entries: [], inProgress: [], judgements: [], gaps: [], activeStages: [] }, new Set()).kind).toBe('converged');
  });
});

describe('autoCompleteReady —— 齐了即收', () => {
  it('必做项未完不收', () => {
    const model = parseCmmn(XML);
    expect(autoCompleteReady(model, initialRuntime(model))).toBe(false);
  });
});

/* ── DMN:三分类规则 P-03 ─────────────────────────────────────────── */

const p03: DmnDecisionTable = {
  id: 'p03',
  label: '三分类规则 P-03',
  hitPolicy: 'FIRST',
  inputs: [
    { name: 'days', expression: 'historyDays' },
    { name: 'stable', expression: 'marketStable' },
  ],
  outputs: [{ name: 'type' }, { name: 'play' }],
  rules: [
    { id: 'r1', when: ['<= 90', 'true'], then: ['A', '直接快答'] },
    { id: 'r2', when: ['-', '-'], then: ['B', '重估后报'] },
  ],
};

const evalExpr = (expr: string, scope: Readonly<Record<string, unknown>>): unknown => scope[expr];
const evalTest = (cell: string, value: unknown): boolean => {
  const trimmed = cell.trim();
  if (trimmed === '-' || trimmed === '') return true;
  if (trimmed.startsWith('<=')) return Number(value) <= Number(trimmed.slice(2));
  if (trimmed === 'true') return value === true;
  return String(value) === trimmed.replace(/^"|"$/g, '');
};

describe('evaluateTable —— 能算的不问 LLM', () => {
  it('命中首行,留痕带命中规则行', () => {
    const result = evaluateTable(p03, { historyDays: 30, marketStable: true }, evalExpr, evalTest);
    expect(result.kind).toBe('decided');
    if (result.kind === 'decided') {
      expect(result.trace.hitRules).toEqual(['r1']);
      expect(result.trace.outputs).toEqual({ type: 'A', play: '直接快答' });
      expect(result.trace.inputs).toEqual({ days: 30, stable: true });
    }
  });

  it('同输入必同结论 —— 零方差', () => {
    const a = evaluateTable(p03, { historyDays: 30, marketStable: true }, evalExpr, evalTest);
    const b = evaluateTable(p03, { historyDays: 30, marketStable: true }, evalExpr, evalTest);
    expect(a).toEqual(b);
  });

  it('落到兜底行', () => {
    const result = evaluateTable(p03, { historyDays: 200, marketStable: false }, evalExpr, evalTest);
    if (result.kind === 'decided') expect(result.trace.outputs['type']).toBe('B');
  });

  it('输入不齐即 incomplete —— DRD 指出缺什么', () => {
    const result = evaluateTable(p03, { historyDays: 30 }, evalExpr, evalTest);
    expect(result).toEqual({ kind: 'incomplete', missing: ['stable'] });
  });
});

describe('DRD —— 缺口演绎与拓扑序', () => {
  const model: DmnModel = {
    drd: [
      { decision: 'price', requires: ['margin'], inputs: ['basePrice'] },
      { decision: 'margin', requires: [], inputs: ['customerGrade', 'materialType'] },
    ],
    tables: [],
  };

  it('反向遍历给出缺口', () => {
    expect(deduceGaps(model, 'price', new Set(['basePrice']))).toEqual([
      { kind: 'decision', ref: 'margin' },
      { kind: 'input', ref: 'customerGrade' },
      { kind: 'input', ref: 'materialType' },
    ]);
  });

  it('已知项不再算缺口', () => {
    expect(deduceGaps(model, 'price', new Set(['basePrice', 'margin']))).toEqual([]);
  });

  it('拓扑序:先算上游决策', () => {
    expect(evaluationOrder(model, 'price')).toEqual(['margin', 'price']);
  });

  it('成环即报错', () => {
    const cyclic: DmnModel = { drd: [{ decision: 'a', requires: ['b'], inputs: [] }, { decision: 'b', requires: ['a'], inputs: [] }], tables: [] };
    expect(() => evaluationOrder(cyclic, 'a')).toThrow(/成环/);
  });
});

describe('先验迁移再动手 —— 不合法的行动不留痕迹', () => {
  it('Available → Disabled 是非法迁移,transitionItem 抛错', () => {
    const runtime: CaseRuntime = {
      items: [{ id: 'T1', state: 'Available', instance: 1 }],
      milestones: [],
      state: 'Active',
    };
    // 引擎语义忠实:不私改迁移拓扑。AI 提了就拒,拒在**副作用之前**
    expect(() => transitionItem(runtime, 'T1', 'Disabled')).toThrow();
  });

  it('不存在的计划项同样拒 —— AI 可能报一个图上没有的 id', () => {
    const runtime: CaseRuntime = { items: [], milestones: [], state: 'Active' };
    expect(() => transitionItem(runtime, '不存在', 'Active')).toThrow();
  });

  it('Available → Active 合法', () => {
    const runtime: CaseRuntime = {
      items: [{ id: 'T1', state: 'Available', instance: 1 }],
      milestones: [],
      state: 'Active',
    };
    expect(transitionItem(runtime, 'T1', 'Active').items[0]?.state).toBe('Active');
  });
});