/**
 * 内容完整性与引擎流程验证（不走浏览器）：
 * 1. 章节 JSON 的选择点 ID、维度标签与 docs/story-framework.md 第 4 节一一对应；
 * 2. 节点图完整（startNodeId 存在、所有 next 跳转有效、全部节点可达）；
 * 3. 用 MockJevClient + 内存 EventStore 跑通三章 → 16 个选择点全部落事件 → Jev 7 维打分；
 * 4. 追问补全流程：缺失检测 → 追问事件 / 跳过事件（"记不清了"合法）→ 回答合并进讲述文本；
 * 5. EventStore 各实现（含 SqliteEventStore）的 append-only 性质（接口层面断言无 update/delete；
 *    SQLite 实连只能在 Tauri 运行时内进行，Node 下不实例化）。
 * 6. 同意门（ADR-0004）：consent 事件存证、幂等、跨会话跳过；
 * 7. 条件文本：flag 推导（附录 A）、【若】标记零泄漏、差分显隐、条件不满足节点跳过无死路；
 * 8. 删除全部个人数据（ADR-0004 数据删除权）：purge 后事件列表为空、进度清空、
 *    consent 存证删除后回到未同意态、可重新同意并继续走剧情。
 * 运行：pnpm verify
 */
import { readFileSync } from 'node:fs';
import { CONSENT_VERSION, StoryEngine } from '../src/engine/engine';
import { LocalStorageEventStore } from '../src/engine/eventStore';
import type { EventStore, StoryEvent } from '../src/engine/eventStore';
import { choiceFlags, deriveFlags, narrationFlags } from '../src/engine/flags';
import { buildState } from '../src/engine/scoring';
import { MemoryProgressStore } from '../src/engine/progress';
import { SqliteEventStore } from '../src/engine/sqliteEventStore';
import type { Chapter, ChoiceNode, IdentityProfile, NarrationNode } from '../src/engine/types';
import { FOLLOW_UP_DIMENSIONS } from '../src/engine/types';
import { MockJevClient } from '../src/services/jev';
import type { JevAnswer, JevQuestion } from '../src/services/jev';

// story-framework.md 第 4 节的权威选择点地图（ID → 期望维度标签）
const EXPECTED: Record<string, string[]> = {
  'C1-01': [],
  'C1-02': ['attachment', 'self_disclosure'],
  'C1-03': ['values'],
  'C1-04': ['values', 'conflict_style'],
  'C1-05': ['culture'],
  'C1-06': ['risk'],
  'C2-01': ['values', 'conflict_style'],
  'C2-02': ['values', 'emotional_stability'],
  'C2-03': ['risk', 'conflict_style'],
  'C2-04': ['culture'],
  'C2-05': ['attachment', 'reciprocity'],
  'C2-06': ['conflict_style', 'values'],
  'C3-01': ['culture'],
  'C3-02': [],
  'C3-03': ['values'],
  'C3-04': ['conflict_style', 'values'],
  'C3-05': ['mate_preference'],
  'C3-06': ['attachment', 'mate_preference'],
};

class MemoryStore implements EventStore {
  events: StoryEvent[] = [];
  async append(e: StoryEvent) {
    this.events.push(e);
  }
  async list(sessionId?: string) {
    return sessionId ? this.events.filter((e) => e.sessionId === sessionId) : [...this.events];
  }
  async purge() {
    this.events = [];
  }
}

const chapters = [1, 2, 3].map(
  (i) => JSON.parse(readFileSync(new URL(`../content/chapters/chapter${i}.json`, import.meta.url), 'utf8')) as Chapter,
);

let failures = 0;
function check(ok: boolean, msg: string) {
  if (!ok) {
    failures++;
    console.error(`✗ ${msg}`);
  } else {
    console.log(`✓ ${msg}`);
  }
}

// --- 1. 结构校验 ---
const seenPoints = new Map<string, string[]>();
for (const ch of chapters) {
  const ids = new Set(ch.nodes.map((n) => n.id));
  check(ids.has(ch.startNodeId), `${ch.id}: startNodeId 存在`);
  const reachable = new Set<string>([ch.startNodeId]);
  for (let changed = true; changed; ) {
    changed = false;
    for (const n of ch.nodes) {
      if (!reachable.has(n.id)) continue;
      const nexts: string[] =
        n.type === 'choice'
          ? n.options.map((o) => o.next)
          : n.type === 'chapterEnd'
            ? []
            : [n.next];
      for (const nx of nexts) {
        check(ids.has(nx), `${ch.id}/${n.id}: next "${nx}" 有效`);
        if (!reachable.has(nx)) {
          reachable.add(nx);
          changed = true;
        }
      }
    }
  }
  check(reachable.size === ch.nodes.length, `${ch.id}: 全部 ${ch.nodes.length} 个节点可达`);
  for (const n of ch.nodes) {
    if (n.type === 'choice' || n.type === 'narration' || n.type === 'identity') {
      check(!seenPoints.has(n.pointId), `${n.pointId}: 选择点 ID 全局唯一`);
      seenPoints.set(n.pointId, n.dimensions);
    }
  }
}

// --- 2. 与母本选择点地图对照 ---
const expectedIds = Object.keys(EXPECTED).sort();
const actualIds = [...seenPoints.keys()].sort();
check(JSON.stringify(actualIds) === JSON.stringify(expectedIds), `选择点 ID 集合与母本一致（${actualIds.length} 个）`);
for (const [id, dims] of Object.entries(EXPECTED)) {
  check(
    JSON.stringify(seenPoints.get(id) ?? null) === JSON.stringify(dims),
    `${id}: 维度标签 ${JSON.stringify(seenPoints.get(id))} == 母本 ${JSON.stringify(dims)}`,
  );
}

// --- 3. V 类讲述点变体结构 ---
const narrationNodes = chapters.flatMap((c) => c.nodes.filter((n) => n.type === 'narration')) as NarrationNode[];
check(narrationNodes.map((n) => n.pointId).sort().join(',') === 'C1-02,C2-02,C2-05,C3-02', '三个语音讲述点 + C3-02 私密路径节点均存在');
for (const n of narrationNodes) {
  check(n.variants.length >= 2, `${n.pointId}: 有 ${n.variants.length} 个预写场景变体`);
  check(
    n.variants.every((v) => v.signature && v.variantId && v.label),
    `${n.pointId}: 情绪签名 → variantId 映射完整`,
  );
}
check(narrationNodes.find((n) => n.pointId === 'C3-02')?.variantFrom === 'C1-02', 'C3-02 变体由 C1-02 驱动（variantFrom）');
for (const n of narrationNodes) {
  check(
    n.pointId === 'C3-02' ? n.followUp.maxQuestions === 0 && Object.keys(n.followUps).length === 0 : FOLLOW_UP_DIMENSIONS.every((d) => typeof n.followUps?.[d] === 'string' && n.followUps[d]!.length > 0),
    `${n.pointId}: 六维 followUps 追问模板齐全`,
  );
}

/** 自动遍历解谜点时提交真实两题答案，其他选择点无需行为参数。 */
function puzzleBehavior(node: ChoiceNode) {
  return node.puzzle ? { answers: node.puzzle.questions.map((q) => q.answer), hintsUsed: 0 } : undefined;
}

// --- 4. Mock 模式端到端跑通三章 ---
const store = new MemoryStore();
const jev = new MockJevClient();
const engine = new StoryEngine(chapters, store, jev);
let guard = 0;
while (!engine.state.finished && guard++ < 200) {
  const node = engine.currentNode();
  if (node.type === 'choice') {
    await engine.choose(node.options[0].id, puzzleBehavior(node));
  } else if (node.type === 'identity') {
    const profile = await engine.extractIdentity('我叫阿黎，29岁，在杭州做互联网产品经理，硕士学历');
    await engine.confirmIdentity(profile);
  } else if (node.type === 'narration') {
    // C2-05 走"沉默"路径验证合法选项，其余讲述；Mock 检测到缺失维度则回答追问
    if ((node as NarrationNode).pointId === 'C2-05') await engine.skipNarration();
    else if ((node as NarrationNode).pointId === 'C3-02') await engine.resolvePrivateIllusion('farewell_done');
    else {
      await engine.submitNarration('（验证用占位讲述）');
      if (engine.state.pendingFollowUp) await engine.answerFollowUp('（验证用追问回答）');
    }
  } else {
    await engine.advance();
  }
}
check(engine.state.finished, '三章流程跑通（Mock 模式）');
const eventPoints = store.events
  .filter((e) => e.kind === 'choice' || e.kind === 'narration' || e.kind === 'profile')
  .map((e) => e.pointId)
  .sort();
check(
  JSON.stringify(eventPoints) === JSON.stringify(expectedIds),
  `事件轨迹覆盖全部 ${expectedIds.length} 个选择点`,
);
const c305 = store.events.find((e) => e.pointId === 'C3-02' && e.kind === 'narration');
const c102 = store.events.find((e) => e.pointId === 'C1-02' && e.kind === 'narration');
check(!!c305?.variantId && c305.variantId === c102?.variantId, 'C3-02 幻境变体复用 C1-02 情绪解析结果');

// C3-01 分题作答：事件、增量 flags 与事件重放结果必须一致。
{
  const puzzle = chapters[2].nodes.find((n) => n.id === 'c3-01') as ChoiceNode;
  check(!!puzzle.puzzle && puzzle.puzzle.questions.length === 2 && puzzle.puzzle.hints.length === 3, 'C3-01：两道独立选择题与三档提示');
  for (const [correctCount, expected] of [[1, 'partial'], [2, 'true'], [0, 'false']] as const) {
    const s = new MemoryStore();
    const e = new StoryEngine(chapters, s, new MockJevClient());
    await e.restore({ sessionId: `c3-01-${correctCount}`, chapterId: 'chapter3', nodeId: puzzle.id, flags: {} });
    const answers = puzzle.puzzle!.questions.map((q, i) => i < correctCount ? q.answer : (q.answer + 1) % q.options.length);
    await e.choose(puzzle.options[0].id, { answers, hintsUsed: 2 });
    const event = s.events.at(-1);
    check(event?.behavior?.answers?.join(',') === answers.join(',') && event.behavior.answerCorrect?.join(',') === [correctCount > 0, correctCount > 1].join(',') && event.behavior.hintsUsed === 2, `C3-01 ${expected}：分题答案、正误与提示数落事件`);
    check(e.state.flags.c3_01_solved === expected && e.state.flags.c3_01_hints_used === '2' && deriveFlags(s.events).c3_01_solved === expected && deriveFlags(s.events).c3_01_hints_used === '2', `C3-01 ${expected}：即时与重放 flags 一致`);
    check(e.state.nodeId === 'c3-01-ok', `C3-01 ${expected}：提交后进入原有温简复原节点`);
  }
}

// --- 5. 画像报告：7 维 score 问题 ---
const criteria = Array.from({ length: 10 }, (_, i) => `${i + 1} 级`);
const dims = ['attachment', 'conflict_style', 'values', 'emotional_stability', 'risk', 'culture', 'mate_preference'];
const answers = await jev.ask(
  store.events,
  Object.fromEntries(dims.map((d) => [d, { type: 'score' as const, instructions: d, criteria }])),
);
check(
  dims.every((d) => answers[d]?.type === 'score' && answers[d].confidence >= 0 && answers[d].confidence <= 1),
  'Jev 7 维 score 打分返回（含 0-1 置信度）',
);

// --- 6. 重玩语义：新轨迹不修改旧事件 ---
const before = store.events.length;
const oldSession = engine.state.sessionId;
engine.replay('chapter1');
check(engine.state.sessionId !== oldSession, '重玩产生新 sessionId');
while (engine.currentNode().type !== 'choice') {
  const n = engine.currentNode();
  if (n.type === 'identity') {
    await engine.confirmIdentity(await engine.extractIdentity('占位自我介绍'));
  } else if (n.type === 'narration') {
    if (n.pointId === 'C3-02') { await engine.resolvePrivateIllusion('farewell_done'); continue; }
    await engine.submitNarration('（验证用占位讲述）');
    if (engine.state.pendingFollowUp) await engine.answerFollowUp('（验证用追问回答）');
  } else {
    await engine.advance();
  }
}
const firstChoice = engine.currentNode() as ChoiceNode;
await engine.choose(firstChoice.options[0].id);
const added = store.events.slice(before);
check(
  added.filter((e) => e.kind === 'profile').length === 1 &&
    added.filter((e) => e.kind === 'narration').length === 1 &&
    added.filter((e) => e.kind === 'choice').length === 1,
  `重玩追加新事件（profile + narration + choice，含追问事件共 ${added.length} 条），旧事件不变`,
);
check((await store.list(oldSession)).length === before, '旧轨迹事件完整保留');

// --- 7. 追问补全流程（可控 noul 概率的 stub 驱动三条路径） ---
/** noul 概率可控的 Jev stub：missing 里的维度返回 0.1（缺失），其余 0.9；非 noul 题走 Mock */
class FixedNoulJev extends MockJevClient {
  constructor(private missing: string[]) {
    super();
  }
  override async ask(state: unknown, questions: Record<string, JevQuestion>): Promise<Record<string, JevAnswer>> {
    const out = await super.ask(state, questions);
    for (const [id, q] of Object.entries(questions)) {
      if (q.type === 'noul') {
        out[id] = { type: 'noul', probability: this.missing.includes(id) ? 0.1 : 0.9, confidence: 0.9 };
      }
    }
    return out;
  }
}

/** 推进到指定节点（途中选择点取第一项、身份点直接确认、讲述点沉默略过） */
async function walkTo(eng: StoryEngine, nodeId: string) {
  let g = 0;
  while (eng.currentNode().id !== nodeId && g++ < 250) {
    const n = eng.currentNode();
    if (n.type === 'choice') await eng.choose(n.options[0].id, puzzleBehavior(n));
    else if (n.type === 'identity') await eng.confirmIdentity(await eng.extractIdentity('占位自我介绍'));
    else if (n.type === 'narration') await eng.skipNarration();
    else await eng.advance();
  }
}

// 7a. 缺失检测 → 追问挂起 → 回答合并
{
  const s = new MemoryStore();
  const eng = new StoryEngine(chapters, s, new FixedNoulJev(['visual']));
  await walkTo(eng, 'c1-02');
  const c102 = chapters[0].nodes.find((n) => n.id === 'c1-02') as NarrationNode;
  const r = await eng.submitNarration('去年夏天我离开了家乡');
  const pending = eng.state.pendingFollowUp;
  check(r === null && pending?.dimension === 'visual', '缺失检测：视觉缺失（最高优先级）→ 追问挂起，不立即落 narration 事件');
  check(pending?.prompt === c102.followUps.visual, '追问话术取自节点 JSON 的 followUps 模板');
  check(eng.state.nodeId === 'c1-02', '追问挂起期间节点不推进');
  let threw = false;
  try {
    await eng.submitNarration('重复提交');
  } catch {
    threw = true;
  }
  check(threw, '追问挂起期间重复提交被拒（预算纪律：一个讲述点一次追问）');
  const res = await eng.answerFollowUp('站台是灰蓝色的');
  const narrationEv = s.events.find((e) => e.kind === 'narration');
  const followupEv = s.events.find((e) => e.kind === 'followup');
  check(!!followupEv && followupEv.followUpDimension === 'visual', '追问回答落 followup 事件（含缺失维度）');
  check(
    !!narrationEv?.transcript?.includes('去年夏天我离开了家乡') && narrationEv.transcript.includes('站台是灰蓝色的'),
    '追问回答合并进讲述文本（state 合并后进情绪签名选择）',
  );
  check(!!res.variant && eng.state.pendingFollowUp === null && eng.state.nodeId === 'c1-d4', '追问收尾：变体解析完成并推进，无第二次追问');
}

// 7b. "记不清了"跳过 → followup_skipped 事件
{
  const s = new MemoryStore();
  const eng = new StoryEngine(chapters, s, new FixedNoulJev(['person']));
  await walkTo(eng, 'c2-02');
  await eng.submitNarration('有件事我一直后悔');
  check(eng.state.pendingFollowUp?.dimension === 'person', '缺失检测：人物缺失 → 追问挂起');
  await eng.skipFollowUp();
  const skipped = s.events.find((e) => e.kind === 'followup_skipped');
  check(!!skipped && skipped.followUpDimension === 'person' && skipped.transcript === null, '跳过落 followup_skipped 事件（对什么沉默也是数据）');
  const narrationEv = s.events.find((e) => e.kind === 'narration' && e.pointId === 'C2-02');
  check(narrationEv?.transcript === '有件事我一直后悔', '跳过后讲述原文不变，流程继续');
}

// 7c. 六维俱全 → 不追问，直接走完
{
  const s = new MemoryStore();
  const eng = new StoryEngine(chapters, s, new FixedNoulJev([]));
  await walkTo(eng, 'c2-02');
  const r = await eng.submitNarration('一段细节齐全的讲述');
  check(r !== null && eng.state.pendingFollowUp === null, '无缺失维度时不触发追问');
  check(!s.events.some((e) => e.kind === 'followup' || e.kind === 'followup_skipped'), '无追问时不产生追问事件');
}

// --- 8. append-only：EventStore 实现不存在 update/delete 路径 ---
// （SQLite 实连只能在 Tauri 运行时内进行，这里只做接口层面断言）
for (const cls of [LocalStorageEventStore, SqliteEventStore, MemoryStore]) {
  const props = Object.getOwnPropertyNames(cls.prototype).filter((p) => p !== 'constructor');
  check(
    !props.some((p) => ['update', 'delete', 'remove', 'set'].includes(p)),
    `${cls.name}: 只有 ${props.sort().join('/')}（append-only，无 update/delete）`,
  );
}

// --- 9. 同意门（ADR-0004）：consent 事件存证、幂等、跨会话跳过 ---
{
  const s = new MemoryStore();
  const eng = new StoryEngine(chapters, s, new MockJevClient());
  check(!(await eng.hasConsent()), '同意门：无 consent 事件时需要展示同意门');
  await eng.grantConsent();
  const ev = s.events.find((e) => e.kind === 'consent');
  check(
    !!ev && ev.consentVersion === CONSENT_VERSION && ev.ts > 0,
    `同意动作落 consent 事件（consentVersion=${ev?.consentVersion}，含时间戳）`,
  );
  await eng.grantConsent();
  check(s.events.filter((e) => e.kind === 'consent').length === 1, '重复同意幂等（只存证一次）');
  const eng2 = new StoryEngine(chapters, s, new MockJevClient());
  check(await eng2.hasConsent(), 'consent 事件已存在则同意门跳过（全剧只出现一次）');
}

// --- 10. 条件文本：flag 推导、标记不泄漏、差分显隐、空节点跳过 ---
// 10a. 变量映射表（附录 A）
check(choiceFlags('C2-03', 'c_scout').flag_fresh_collapse === 'true', 'flag 推导：C2-03 c_scout → flag_fresh_collapse=true');
check(choiceFlags('C2-01', 'b_exposure').wenjian_health === 'weak', 'flag 推导：C2-01 b_exposure → wenjian_health=weak');
check(choiceFlags('C2-01', 'a_weakest').wenjian_health === 'recovering', 'flag 推导：C2-01 a_weakest → wenjian_health=recovering');
check(choiceFlags('C2-01', 'd_process').wenjian_health === 'weak', 'flag 推导（S4 修订）：C2-01 d_process → wenjian_health=weak（议事真空期老鬼先行分药）');
check(!('flag_prophecy_heard' in narrationFlags('C2-02', 'intel_full', '（讲述）')), 'flag 推导（S3 修订）：flag_prophecy_heard 已废除，C2-02 四档等价');
check(narrationFlags('C3-02', undefined, null).c3_02_mode === undefined, 'C3-02 不从文本推导模式');
{
  const f = choiceFlags('C3-06', 'c_confide_wenjian');
  check(
    f.c3_06_response === 'c_confide' && f.c3_06_confidant === 'wenjian' && f.flag_arch_doubt === 'true',
    'flag 推导：C3-06 队友子分支 → c_confide / confidant=wenjian / flag_arch_doubt',
  );
}
check(narrationFlags('C2-05', 'wenjian_close_late', '（讲述）').flag_wenjian_secret === 'true', 'flag 推导：C2-05 浅暴露 → flag_wenjian_secret');

/** 走查三章并收集途经节点与渲染文本；picker 可指定选择点的选项 */
async function walkAll(eng: StoryEngine, picker: Record<string, string> = {}) {
  const seen: string[] = [];
  const rendered: string[] = [];
  let guard = 0;
  while (!eng.state.finished && guard++ < 250) {
    const node = eng.currentNode();
    seen.push(node.id);
    if (node.type === 'dialogue') rendered.push(eng.renderText(node.text));
    else if (node.type === 'cutscene') rendered.push(eng.renderText(node.caption));
    else if (node.type === 'choice') rendered.push(eng.renderText(node.prompt), ...node.options.map((o) => eng.renderText(o.label)));
    else if (node.type === 'narration' || node.type === 'identity') rendered.push(eng.renderText(node.prompt));
    if (node.type === 'choice') {
      await eng.choose(picker[node.pointId] ?? node.options[0].id, puzzleBehavior(node));
    } else if (node.type === 'identity') {
      await eng.confirmIdentity(await eng.extractIdentity('占位自我介绍'));
    } else if (node.type === 'narration') {
      if (node.pointId === 'C3-02') await eng.resolvePrivateIllusion(picker.C3_02_SILENT ? 'exit_room' : 'farewell_done');
      else {
        await eng.submitNarration('（验证用占位讲述）');
        if (eng.state.pendingFollowUp) await eng.answerFollowUp('（验证用追问回答）');
      }
    } else {
      await eng.advance();
    }
  }
  return { seen, rendered, finished: eng.state.finished };
}

// 10b. 默认路径（全取首选项）：标记零泄漏 + 条件节点按 flag 跳过
{
  const s = new MemoryStore();
  const eng = new StoryEngine(chapters, s, new MockJevClient());
  const { seen, rendered, finished } = await walkAll(eng);
  check(finished, '条件系统下默认路径三章跑通');
  check(rendered.every((t) => !t.includes('【若')), '渲染输出零【若】标记泄漏（默认路径）');
  check(seen.includes('c2-d1') && !seen.includes('c2-d1v'), '落点 a_safe：变体 A 节点可见、变体 B 节点被跳过');
  check(!seen.includes('c3-d1a'), '未选 c_scout：flag_fresh_collapse 差分节点被跳过（无死路，继续走到 c3-d1b）');
  check(seen.includes('c3-d1b'), '跳过差分节点后落到主线下一节点');
  check(!seen.includes('c3-d6c'), '动机非 d_trust：§3-7 追加句节点被跳过');
  // S4 修订：温简在场/留营的双版本台词移到了 c2-d4f（C2-03 分歧前）
  const d4f = chapters[1].nodes.find((n) => n.id === 'c2-d4f');
  check(
    d4f?.type === 'dialogue' && eng.renderText(d4f.text).includes('你定，我跟着') && !eng.renderText(d4f.text).includes('等信儿'),
    'wenjian_health=recovering：温简在场版台词渲染，留营版不渲染',
  );
}

// 10c. 差分路径：c_scout 塌梁 + b_exposure 温简虚弱 + C3-02 沉默退出
{
  const s = new MemoryStore();
  const eng = new StoryEngine(chapters, s, new MockJevClient());
  const { seen, rendered, finished } = await walkAll(eng, { 'C2-03': 'c_scout', 'C2-01': 'b_exposure', C3_02_SILENT: '1' });
  check(finished, '条件系统下差分路径三章跑通');
  check(seen.includes('c3-d1a'), '选了 c_scout：flag_fresh_collapse 差分节点可见');
  check(eng.state.flags.flag_fresh_collapse === 'true' && eng.state.flags.wenjian_health === 'weak', '引擎 flags 随选择增量更新');
  const d4f = chapters[1].nodes.find((n) => n.id === 'c2-d4f');
  check(
    d4f?.type === 'dialogue' && eng.renderText(d4f.text).includes('在营里等信儿'),
    'wenjian_health=weak：温简留营版（通讯频道）台词渲染',
  );
  const d5a = chapters[1].nodes.find((n) => n.id === 'c2-d5a');
  check(
    d5a?.type === 'dialogue' && eng.renderText(d5a.text).includes('解谜要记录员'),
    'wenjian_health=weak：§2-5 温简归队时刻渲染（他自己背着记录板跟来了）',
  );
  const cut = chapters[2].nodes.find((n) => n.id === 'c3-cutscene');
  check(
    cut?.type === 'cutscene' && eng.renderText(cut.caption).includes('不出来的人'),
    'C3-02 沉默退出：cutscene 追加馆长退出台词（exit_room 内联段）',
  );
  check(rendered.every((t) => !t.includes('【若')), '渲染输出零【若】标记泄漏（差分路径）');
}

// --- 11. 进度持久化与恢复（真机刷新/热更新断点续玩） ---
{
  const s = new MemoryStore();
  const progress = new MemoryProgressStore();
  const eng = new StoryEngine(chapters, s, new MockJevClient(), undefined, progress);
  await walkTo(eng, 'c1-d5'); // 途经 C1-01 身份点与 C1-03 选择点（产生 flag）
  const snap = progress.load();
  check(
    snap?.chapterId === 'chapter1' && snap.nodeId === 'c1-d5',
    `推进后持久化当前位置（${snap?.chapterId}/${snap?.nodeId}）`,
  );
  const eng2 = new StoryEngine(chapters, s, new MockJevClient(), undefined, progress);
  const restored = await eng2.restore(progress.load());
  check(
    restored && eng2.currentNode().id === 'c1-d5' && eng2.state.sessionId === snap?.sessionId,
    '重建引擎从持久化位置恢复（sessionId 一致，事件轨迹续接）',
  );
  check(eng2.state.flags.c1_03_motive === 'a_truth', '恢复后 flags 随快照还原（条件文本不断档）');
  // 内容更新导致持久化节点消失 → 降级该章开头
  const eng3 = new StoryEngine(chapters, s, new MockJevClient(), undefined, progress);
  check(
    (await eng3.restore({ sessionId: 'ghost', chapterId: 'chapter1', nodeId: 'deleted-node', flags: {} })) &&
      eng3.currentNode().id === chapters[0].startNodeId,
    '持久化节点已不存在 → 降级到该章开头（不崩溃）',
  );
  check(!(await eng3.restore({ sessionId: 'ghost', chapterId: 'chapter99', nodeId: 'x', flags: {} })), '持久化章节不存在 → 不恢复');
  // replay：新 sessionId + 持久化位置重置（条件不满足的开场节点会被跳过，落点是跳过后的首个可见节点）
  eng2.replay('chapter2');
  const after = progress.load();
  check(
    after?.chapterId === 'chapter2' &&
      after.nodeId === eng2.state.nodeId &&
      eng2.state.sessionId !== snap?.sessionId,
    'replay 产生新 sessionId 并重置持久化位置到目标章（跳过条件隐藏节点后的首个可见节点）',
  );
}

// --- 12. Jev 调用失败优雅降级（CORS / 网络故障不卡死） ---
class FailingJev extends MockJevClient {
  override async ask(): Promise<Record<string, JevAnswer>> {
    throw new Error('模拟 Jev 故障：CORS / network');
  }
}
{
  // 12a. 讲述流程：缺失检测失败 → 不追问；情绪签名失败 → 沉默/通用档变体；节点照常推进
  const s = new MemoryStore();
  const eng = new StoryEngine(chapters, s, new FailingJev());
  await walkTo(eng, 'c1-02');
  const r = await eng.submitNarration('去年夏天我离开了家乡，站台上都是雾');
  check(r !== null && eng.state.pendingFollowUp === null, 'Jev 故障：缺失检测失败降级为不追问，流程继续');
  check(eng.state.nodeId === 'c1-d4', 'Jev 故障：变体解析失败后节点照常推进');
  const c102 = chapters[0].nodes.find((n) => n.id === 'c1-02') as NarrationNode;
  const silentVariant = c102.variants.find((v) => v.signature.includes('沉默'))!;
  const ev = s.events.find((e) => e.kind === 'narration' && e.pointId === 'C1-02');
  check(ev?.variantId === silentVariant.variantId, 'Jev 故障：情绪签名解析降级到沉默/通用档变体');
  // 12b. 身份抽取失败 → 硬过滤字段全空（称呼走本地启发式仍可预填），UI 直接进可手填确认页，不抛出
  const eng2 = new StoryEngine(chapters, new MemoryStore(), new FailingJev());
  await walkTo(eng2, 'c1-01');
  let profile: IdentityProfile | null = null;
  let threw = false;
  try {
    profile = await eng2.extractIdentity('我叫阿黎，29岁，在杭州');
  } catch {
    threw = true;
  }
  check(
    !threw &&
      profile !== null &&
      profile.city === '' &&
      profile.age === '' &&
      profile.gender === '' &&
      profile.occupation === '' &&
      profile.education === '',
    'Jev 故障：身份抽取降级为空字段进手填确认页（不抛出）',
  );
  await eng2.confirmIdentity(profile!);
  check(eng2.state.nodeId === 'c1-d2', 'Jev 故障：手填确认后流程照常推进');
}

// --- 13. 玩家称呼：{name} 占位符替换、预填启发式、恢复后带回 ---
{
  // 13a. 启发式：只认"我叫/叫我/称呼我 X"，其余句式不瞎猜
  const s = new MemoryStore();
  const eng = new StoryEngine(chapters, s, new MockJevClient());
  await walkTo(eng, 'c1-01');
  const p1 = await eng.extractIdentity('我叫林晚，29岁，在杭州做互联网产品经理，硕士学历');
  check(p1.name === '林晚', `称呼预填：「我叫林晚」→ "${p1.name}"`);
  const p2 = await eng.extractIdentity('29岁，杭州，产品经理');
  check(p2.name === '', '称呼预填：无自报句式 → 留空手填（不硬抽）');
  // 13b. {name} 替换与回退
  await eng.confirmIdentity(p1);
  check(eng.renderText('馆长：{name}，登记完成。') === '馆长：林晚，登记完成。', '{name} 替换为玩家称呼');
  const eng2 = new StoryEngine(chapters, new MemoryStore(), new MockJevClient());
  check(eng2.renderText('馆长：{name}，登记完成。') === '馆长：你，登记完成。', '未设置称呼时 {name} 回退「你」');
  // 13c. 称呼随轨迹事件走：restore 后从该 session 的 profile 事件取回（旧事件缺 name 不崩溃）
  await walkTo(eng, 'c1-d5');
  const d2 = chapters[0].nodes.find((n) => n.id === 'c1-d2');
  check(d2?.type === 'dialogue' && eng.renderText(d2.text).includes('林晚'), '馆长登记台词中的 {name} 渲染为称呼');
  const progress = new MemoryProgressStore();
  progress.save({ sessionId: eng.state.sessionId, chapterId: 'chapter1', nodeId: 'c1-d5', flags: { ...eng.state.flags } });
  const eng3 = new StoryEngine(chapters, s, new MockJevClient(), undefined, progress);
  await eng3.restore(progress.load());
  check(eng3.state.playerName === '林晚', '断点恢复后从 profile 事件取回称呼');
}

// C3-02 的三种路径只落叙事模式，不采集或评分室内讲述。
for (const mode of ['farewell_done', 'farewell_partial', 'exit_room'] as const) {
  const s = new MemoryStore();
  const e = new StoryEngine(chapters, s, new MockJevClient());
  await walkTo(e, 'c3-02');
  const r = await e.resolvePrivateIllusion(mode);
  const recorded = s.events.find((ev) => ev.pointId === 'C3-02');
  check(recorded?.kind === 'narration' && recorded.narrationMode === mode && recorded.transcript === null && recorded.dimensions.length === 0, `问心之室 ${mode}：不留文本或维度标签`);
  check(e.state.flags.c3_02_mode === mode && !buildState(s.events).includes('C3-02'), `问心之室 ${mode}：叙事变量生效且画像隔离`);
  check(r.event.id === recorded?.id && e.state.nodeId === 'c3-cutscene', `问心之室 ${mode}：石门照常开启`);
  const restored = deriveFlags(s.events);
  check(restored.c3_02_mode === mode && restored.c3_02_fantasy_density === e.state.flags.c3_02_fantasy_density, `问心之室 ${mode}：恢复后叙事状态一致`);
}

// --- 14. 删除全部个人数据（ADR-0004 数据删除权）：purge 整库物理清空 + 进度清空 + 回到未同意态 ---
{
  const s = new MemoryStore();
  const progress = new MemoryProgressStore();
  const eng = new StoryEngine(chapters, s, new MockJevClient(), undefined, progress);
  await eng.grantConsent();
  await walkTo(eng, 'c1-d5'); // 途经 C1-01 身份点、C1-02 讲述点、C1-03 选择点
  check((await s.list()).length > 0 && progress.load() !== null, '删除前：事件流与进度快照均非空');
  await s.purge();
  progress.clear();
  check((await s.list()).length === 0, 'purge 后事件列表为空（全部事件物理删除）');
  check(progress.load() === null, 'clear 后进度快照为空');
  check(!(await eng.hasConsent()), 'purge 后 consent 存证一并删除 → 回到未同意状态（同意门重新出现）');
  await s.purge();
  check((await s.list()).length === 0, 'purge 幂等：重复清空不报错且仍为空');
  // 删除后可重新同意并正常继续走剧情（存储清空后仍可 append，事件不串旧轨迹）
  await eng.grantConsent();
  check(s.events.filter((e) => e.kind === 'consent').length === 1, '重新同意：新 consent 存证落库（只存证一次）');
  await walkTo(eng, 'c1-05'); // 从 c1-d5 出发途经 C1-04 选择点
  check(
    s.events.some((e) => e.kind === 'choice') && !s.events.some((e) => e.kind === 'profile'),
    '删除后可正常继续走剧情并落新事件，旧轨迹事件不残留（无已删除的 profile 事件）',
  );
}

if (failures > 0) {
  // 主线失败先退出，避免掩盖原有回归。
  console.error(`\n${failures} 项校验失败`);
  process.exit(1);
}
console.log('\n全部校验通过');
await import('./verify-adaptive');