/**
 * 验证 F073「正文真实增量流式输出」的两块：
 *   第 1 部分 —— **纯逻辑**（不必联网）：增量规整器的前缀不变式 + 流状态机
 *   第 2 部分 —— **协调器级假流**：假 SSE 流喂真实协调器，断言事件通道与去重
 *
 * 为什么规整器要这么较真：它手里攥着一个不变式——
 *   **任一时刻「已发出的增量拼接」=== `normalizeChatMarkdown(已输入的全部文本)`**
 * 只要不变式成立，后端 `answer_end` 的「整块替换」在正常路径上就是纯尾缀追加
 * （不会触发整段重建 → 不会让「思考中」卡片闪现重播）。破了它，观感立刻劣化。
 *
 * 怎么跑（先重新打包，必须带 --loader:.png=dataurl）：
 *   npx esbuild harness/tools/_entry-coordinator.ts --bundle --format=esm \
 *     --outfile=harness/tools/_coordinator.mjs --alias:@=./src \
 *     --define:import.meta.env='{}' --loader:.png=dataurl
 *   node harness/tools/verify-answer-stream.mjs
 */

import {
  ApiChatCoordinator,
  applyAnswerStreamAbort,
  applyAnswerStreamEnd,
  applyAnswerStreamEvent,
  createAnswerStreamState,
  composeAroundStreamBody,
  composeStreamedContent,
  createIncrementalMarkdownNormalizer,
  normalizeChatMarkdown,
  parseAnswerStreamEvent,
  resolveStreamedBodyAfterEnd,
  shouldKeepAnswerOverview,
} from './_coordinator.mjs';

let pass = 0;
let fail = 0;
const check = (name, cond, extra = '') => {
  if (cond) {
    pass++;
    console.log(`  ok   ${name}`);
  } else {
    fail++;
    console.log(`  FAIL ${name}${extra === '' ? '' : ` → ${JSON.stringify(extra)}`}`);
  }
};

/* ================================================================== *
 * 第 1 部分：纯逻辑
 * ================================================================== */
console.log('【1】增量规整器：前缀不变式');

/** 把一串输入分片喂给规整器，返回逐片输出 */
const feed = (chunks) => {
  const normalizer = createIncrementalMarkdownNormalizer();
  const out = [];
  for (const chunk of chunks) out.push(normalizer.push(chunk));
  return { out, normalizer };
};

/**
 * 不变式（流中）：**已发出的文本必须是「规整后全文」的前缀**，
 * 且未发出的差额只能是「**给当前行准备的空行分隔符（可能 1~2 个 \n）+ 当前行的尾巴**」——
 * 也就是「为了判断该行是不是列表项而短暂扣住的一小段」，行尾一到就释放。
 *
 * 这个性质正好保证 `answer_end` 的「整块替换」= 纯尾缀追加（不会整段重建）。
 */
const isPrefixWithHeldLineTail = (got, want) => {
  if (!want.startsWith(got)) return false;
  const held = want.slice(got.length).replace(/^\n+/, ''); // 去掉随行一起扣住的前置空行
  return !held.includes('\n');
};

/** 不变式：每喂一片就核对一次 */
const checkInvariant = (label, chunks, { finish = false } = {}) => {
  const normalizer = createIncrementalMarkdownNormalizer();
  let want = '';
  let got = '';
  let ok = true;
  let at = 0;
  for (let i = 0; i < chunks.length; i++) {
    want += chunks[i];
    got += normalizer.push(chunks[i]);
    if (!isPrefixWithHeldLineTail(got, normalizeChatMarkdown(want))) {
      ok = false;
      at = i;
      break;
    }
  }
  if (ok && finish) {
    got += normalizer.finish();
    if (got !== normalizeChatMarkdown(want)) ok = false;
  }
  check(
    `不变式：${label}`,
    ok,
    ok ? '' : { 第几片: at, 期望: normalizeChatMarkdown(want).slice(-40), 实际: got.slice(-40) }
  );
  return ok;
};

checkInvariant('整段一次 push', ['第一行\n第二行\n第三行']);
checkInvariant('逐字 push（含换行）', [...'第一行\n第二行\n1. a\n2. b']);
checkInvariant('双换行（空行）', ['段落一\n\n段落二']);
checkInvariant('连续有序列表不插空行', ['1. 甲\n2. 乙\n3. 丙']);
checkInvariant('连续无序列表不插空行', ['- 甲\n- 乙']);
checkInvariant('列表后接说明行', ['- 甲\n- 乙\n以上就是全部']);
checkInvariant('伪列表符（2倍）不误判', ['2倍\n3. 真列表']);
checkInvariant('行首恰为列表前缀（- ）', ['前一行\n- ']);
checkInvariant('行首数字未定型（12）', ['前一行\n12']);
checkInvariant('行首数字带点（12.）', ['前一行\n12.']);
checkInvariant('末尾无换行', ['段一\n段二（未完']);
checkInvariant('以换行结尾', ['段一\n']);
checkInvariant('空串与纯空白', ['', ' ', '\n', '  \n']);
checkInvariant('逐字 push 且收尾 finish', [...'甲\n1. 乙\n丙'], { finish: true });

// 逐字 push 与整段 push 的「拼接结果」必须一致（都 finish 掉扣住的尾巴后比）
{
  const text = '第一段\n第二段\n1. 甲\n2. 乙\n收尾说明';
  const wholeFeed = feed([text]);
  wholeFeed.out.push(wholeFeed.normalizer.finish());
  const perCharFeed = feed([...text]);
  perCharFeed.out.push(perCharFeed.normalizer.finish());
  const whole = wholeFeed.out.join('');
  const perChar = perCharFeed.out.join('');
  check('逐字 push 与整段 push 输出一致', whole === perChar, { whole, perChar });
  check('两者的拼接都等于整段规整结果', whole === normalizeChatMarkdown(text));
}

// 种子化伪随机模糊（≥500 轮）
{
  let seed = 20260920;
  const rand = () => {
    seed = (seed * 1103515245 + 12345) % 2147483648;
    return seed / 2147483648;
  };
  const alphabet = ['甲', '乙', '丙', '\n', '\n\n', '- ', '* ', '1', '2', '.', ')', ' ', '。', '12', '-'];
  let bad = null;
  for (let round = 0; round < 500 && !bad; round++) {
    const chunks = [];
    const count = 1 + Math.floor(rand() * 20);
    for (let i = 0; i < count; i++) chunks.push(alphabet[Math.floor(rand() * alphabet.length)]);
    const normalizer = createIncrementalMarkdownNormalizer();
    let want = '';
    let got = '';
    for (const chunk of chunks) {
      want += chunk;
      got += normalizer.push(chunk);
      if (!isPrefixWithHeldLineTail(got, normalizeChatMarkdown(want))) {
        bad = { round, chunks, want, got };
        break;
      }
    }
    if (!bad) {
      got += normalizer.finish();
      if (got !== normalizeChatMarkdown(want)) bad = { round, chunks, want, got, finish: true };
    }
  }
  check('种子化模糊 500 轮（含 finish）不变式恒成立', !bad, bad);
}

// 扣住的部分必须「有界」：只是当前行的一小段，不能无限积压
{
  const normalizer = createIncrementalMarkdownNormalizer();
  let shown = '';
  let want = '';
  for (const chunk of ['第一段\n', '第二段\n', '1', '.', ' ', '甲', '\n', '2', '.', ' ', '乙']) {
    want += chunk;
    shown += normalizer.push(chunk);
    const held = normalizeChatMarkdown(want).slice(shown.length).replace(/^\n+/, '');
    if (held.includes('\n') || held.length > 8) {
      check(`扣住有界（本条 ${JSON.stringify(chunk)}）`, false, { held, shown });
      break;
    }
  }
  check('扣住的只是「可能成为列表项」的短前缀（本例 ≤8 字符且不含换行）', true);
}

console.log('\n【2】流式事件解析（形状不符 → null 走旧路径）');
{
  const start = parseAnswerStreamEvent({ stream_id: 's1', target: 'summary', sequence: 0 }, 'answer_start');
  check('合法的 answer_start', start?.kind === 'start' && start.streamId === 's1' && start.target === 'summary', start);

  check('缺 stream_id → null', parseAnswerStreamEvent({ target: 'summary' }, 'answer_start') === null);
  check('空 stream_id → null', parseAnswerStreamEvent({ stream_id: '  ', target: 'summary' }, 'answer_delta') === null);
  check('target 非法 → null', parseAnswerStreamEvent({ stream_id: 's1', target: 'other' }, 'answer_delta') === null);
  check('非对象 → null', parseAnswerStreamEvent(null, 'answer_delta') === null && parseAnswerStreamEvent([1], 'answer_delta') === null);

  const delta = parseAnswerStreamEvent({ stream_id: 's1', target: 'answer', sequence: '3', text: 123 }, 'answer_delta');
  check('sequence 宽松（字符串也认）', delta?.sequence === 3, delta);
  check('text 非字符串按空串', delta?.text === '', delta);

  const end = parseAnswerStreamEvent({ stream_id: 's1', target: 'summary', text: 'x', status: '怪值' }, 'answer_end');
  check('status 非法 → fallback', end?.kind === 'end' && end.status === 'fallback', end);
  const endOk = parseAnswerStreamEvent({ stream_id: 's1', target: 'summary', text: 'x', status: 'completed' }, 'answer_end');
  check('status=completed 保留', endOk?.status === 'completed');

  const abort = parseAnswerStreamEvent({ stream_id: 's1', target: 'summary', reason: '怪值' }, 'answer_abort');
  check('reason 非法 → generation_failed', abort?.kind === 'abort' && abort.reason === 'generation_failed', abort);
  const abortOk = parseAnswerStreamEvent({ stream_id: 's1', target: 'summary', reason: 'not_finalized' }, 'answer_abort');
  check('reason=not_finalized 保留', abortOk?.reason === 'not_finalized');

  check('未知事件名 → null', parseAnswerStreamEvent({ stream_id: 's1', target: 'summary' }, 'answer_what') === null);
}

console.log('\n【3】流状态机');
{
  const run = (events) => {
    let state = createAnswerStreamState();
    const effects = [];
    for (const ev of events) {
      const r = applyAnswerStreamEvent(state, ev);
      state = r.state;
      effects.push(r.effect.kind);
    }
    return { state, effects };
  };
  const ev = (kind, extra = {}) => ({ kind, streamId: 's1', target: 'summary', sequence: 0, text: '', ...extra });

  // 正常流
  {
    const { state, effects } = run([
      ev('start', { sequence: 0 }),
      ev('delta', { sequence: 1, text: '你好' }),
      ev('delta', { sequence: 2, text: '世界' }),
      ev('end', { sequence: 2, text: '你好，世界' }),
    ]);
    check('正常流：效果序列 start→append→append→replace', JSON.stringify(effects) === JSON.stringify(['start', 'append', 'append', 'replace']), effects);
    check('正常流：end 后 text = 最终全文（整块替换，不拼接）', state.text === '你好，世界' && state.completed === true, state);
  }

  // 序号缺口
  {
    const { state, effects } = run([
      ev('start'),
      ev('delta', { sequence: 1, text: 'a' }),
      ev('delta', { sequence: 5, text: 'b' }),
    ]);
    check('序号缺口：仍拼接、hasGap 置位', state.text === 'ab' && state.hasGap === true, state);
    check('缺口不阻断渲染（仍是 append）', effects[2] === 'append');
  }

  // 重复序号
  {
    const { state } = run([ev('start'), ev('delta', { sequence: 1, text: 'a' }), ev('delta', { sequence: 1, text: 'XX' })]);
    check('重复序号忽略（不重复拼接）', state.text === 'a', state);
  }

  // 过期流
  {
    const { state, effects } = run([
      ev('start'),
      ev('delta', { streamId: 'other', sequence: 1, text: 'X' }),
      ev('end', { streamId: 'other', text: 'X' }),
      ev('abort', { streamId: 'other' }),
    ]);
    check('过期 streamId 的 delta/end/abort 全部 none', effects.slice(1).every((k) => k === 'none'), effects);
    check('过期事件不改状态', state.text === '' && state.completed === false, state);
  }

  // end 之后的 delta
  {
    const { state, effects } = run([ev('start'), ev('end', { text: '定稿' }), ev('delta', { sequence: 9, text: '迟到' })]);
    check('end 之后的 delta 忽略', effects[2] === 'none' && state.text === '定稿', state);
  }

  // abort 复位 + 重新 start
  {
    const { state, effects } = run([
      ev('start'),
      ev('delta', { sequence: 1, text: '草稿' }),
      ev('abort', { reason: 'generation_failed' }),
      ev('start', { streamId: 's2' }),
      ev('delta', { streamId: 's2', sequence: 1, text: '新正文' }),
    ]);
    check('abort 复位（discard 效果 + 状态清空后可再 start）', effects.includes('discard') && state.text === '新正文' && state.streamId === 's2', { effects, state });
  }

  // end 覆盖草稿（fallback 也替换）
  {
    const { state } = run([
      ev('start'),
      ev('delta', { sequence: 1, text: '草稿' }),
      ev('end', { sequence: 1, text: '最终', status: 'fallback' }),
    ]);
    check('fallback 的 end 同样整块替换', state.text === '最终' && state.completed === true, state);
  }

  check('null 事件 → none 且状态不变', (() => {
    const s0 = createAnswerStreamState();
    const r = applyAnswerStreamEvent(s0, null);
    return r.effect.kind === 'none' && r.state === s0;
  })());
}

console.log('\n【3b】应用层的内容对齐（end 替换 / abort 撤稿）');
{
  const BASE = '<scope title="思考中">\n</scope>\n';
  // 新签名：(当前内容, 流式正文, 最终正文) —— 用「流式正文」做后缀匹配，不按基线长度切
  check(
    '正常路径：最终文本以增量拼接为前缀 → 纯尾缀追加（不加空行、不重建）',
    applyAnswerStreamEnd(BASE + '一、说明', '一、说明', '一、说明。二、补充') === BASE + '一、说明。二、补充'
  );
  check(
    '已上屏一长段、最终只多了尾巴 → 不重复整段',
    applyAnswerStreamEnd(BASE + '甲', '甲', '甲乙丙') === BASE + '甲乙丙'
  );
  check(
    '罕见分歧（最终文本与增量拼接不一致）→ 整块重建，且基线里的 <scope> 被剥掉（避免卡片闪现）',
    applyAnswerStreamEnd(BASE + '草稿', '草稿', '完全不同的最终文本') === '完全不同的最终文本'
  );
  check(
    '重建时**基线（流开始前就有的内容）保留**，最终文本接在其后 —— 只有 scope 标记会被剥掉',
    applyAnswerStreamEnd('前言草稿', '草稿', '最终') === '前言最终'
  );
  check(
    '兜底：上屏内容与流式正文对不上（被别的路径改过）→ 不切，直接把最终正文接上（不丢字）',
    applyAnswerStreamEnd('被改过的内容', '对不上的正文', '最终') === '被改过的内容最终'
  );
  check('abort 撤稿：从上屏内容里去掉流式正文', applyAnswerStreamAbort(BASE + '草稿', '草稿') === BASE);
  check('abort 兜底：对不上就不动（宁可多留也不切坏）', applyAnswerStreamAbort('别的内容', '对不上') === '别的内容');
  check('abort：空正文返回原内容', applyAnswerStreamAbort('原内容', '') === '原内容');

  // answer 开场概述该不该显示（实测：后端把正文作为 summary 流式下发，
  // 而 answer 常是同一段开头的**压缩版**——显示会重复开头；但万一是另一段内容就不能丢）
  const body =
    '我们青浦目前能对上的小微企业扶持，主要分两类：一类是面向特定对象的创业扶持（如带动就业补贴、贷款贴息、留创企业开办资助），另一类是市级中小企业公共资助项目；此外还有几款“小微贷”金融产品。\n\n### 具体政策\n- 创业扶持：带动就业补贴';
  // 压缩版的形态与实测一致：**截断在词中间**（正文接着 '###'，概述结尾是半个词 '部分候'）
  const abridged = body.slice(0, 70).replace(/\n+/g, ' ') + ' 部分候…';
  check('压缩版开场（截断在词中间，公共前缀 ≥90%）→ 不显示（避免开头重复）', shouldKeepAnswerOverview(abridged, body) === false, abridged);
  check('真正的另一段内容（不是前缀）→ 必须保留', shouldKeepAnswerOverview('这是另一段完全不同的开场说明。', body) === true);
  check('概述为空 → 不显示', shouldKeepAnswerOverview('', body) === false && shouldKeepAnswerOverview(null, body) === false);
  check('流式正文为空 → 保留概述（不能丢字）', shouldKeepAnswerOverview('开场', '') === true);

  // 流式轮的最终组装：基线 + 卡片 + 正文 + 尾部（卡片在正文**之上**）
  const SCOPE = '<scope title="思考中">\n</scope>\n';
  check(
    '组装顺序：基线 → leading（卡片）→ 正文 → trailing（参考资料）',
    composeStreamedContent(SCOPE + '前言', '【卡片】', '正文正文', '【参考资料】') === '前言\n\n【卡片】\n\n正文正文\n\n【参考资料】',
    composeStreamedContent(SCOPE + '前言', '【卡片】', '正文正文', '【参考资料】')
  );
  check(
    '组装时剥掉基线里的 <scope>（否则卡片会闪现重播）',
    !composeStreamedContent(SCOPE + '前言', '', '正文', '').includes('<scope')
  );
  check('没有卡片时只剩正文（不留空行）', composeStreamedContent('', '', '正文', '') === '正文');
  check('空块被跳过、不产生多余空行', composeStreamedContent('', '', '正文', '') === '正文' && composeStreamedContent('', '', '', '尾') === '尾');
}

console.log('\n【3c】end 之后同步「流式正文」+ 重排（正文上屏两份的 bug，见 verify-answer-stream-payload）');
{
  // 真后端形态：answer_end 的文本比增量拼接**长**（实测 1309 → 1610，末尾补了追问建议）。
  // 不同步 stream.body 的话，重排时后缀匹配失败 → 卡片排在正文后、正文上屏两份。
  const DELTA = '正文前半';
  const FINAL = '正文前半；正文后半（answer_end 才到的尾巴）';
  check('end 之后流式正文更新为最终全文', resolveStreamedBodyAfterEnd(DELTA, FINAL) === FINAL);
  check('最终正文为空 → 保持原值（不能清空而丢正文）', resolveStreamedBodyAfterEnd(DELTA, '') === DELTA);
  check('最终正文为空且原值也空 → 空串', resolveStreamedBodyAfterEnd('', '') === '');
  check(
    '端到端形态：end 同步后重排 → 卡片在正文之前、正文只出现一次',
    (() => {
      const onScreen = applyAnswerStreamEnd('', DELTA, FINAL); // end 把尾巴接上
      const body = resolveStreamedBodyAfterEnd(DELTA, FINAL); // hook 同步流式正文
      const { next, matched } = composeAroundStreamBody(onScreen, body, '【卡片】', '【参考】');
      return matched === true && next === '【卡片】\n\n' + FINAL + '\n\n【参考】' && next.split(FINAL).length - 1 === 1;
    })()
  );
  // 兜底：流式正文与上屏内容错位（本 bug 的原状）——**绝不能把正文再插一份**
  check(
    '兜底：正文不在末尾但在上屏内容里 → 以它为锚点重排，不重复',
    (() => {
      const { next, matched } = composeAroundStreamBody(FINAL, DELTA, '【卡片】', '【参考】');
      return matched === false && next.split(DELTA).length - 1 === 1 && next.startsWith('【卡片】') && next.endsWith('【参考】');
    })()
  );
  check(
    '兜底：锚点之后的内容（answer_end 的尾巴）留在正文与参考资料之间',
    (() => {
      const { next } = composeAroundStreamBody('基线' + FINAL, DELTA, '【卡片】', '【参考】');
      return next === '基线\n\n【卡片】\n\n' + DELTA + '\n\n' + FINAL.slice(DELTA.length) + '\n\n【参考】';
    })()
  );
  check(
    '兜底：正文确实不在上屏内容里 → 补插（不丢字优先）',
    composeAroundStreamBody('别的内容', DELTA, '', '').next === '别的内容\n\n' + DELTA
  );
  // 流式正文为空：没有可对齐的正文，退化成「现有内容 + 卡片 + 参考资料」（与改动前一致）
  const emptyBody = composeAroundStreamBody('已有内容', '', '【卡片】', '【参考】');
  check(
    '流式正文为空 → 退化为「现有内容 → 卡片 → 参考资料」',
    emptyBody.matched === true && emptyBody.next === '已有内容\n\n【卡片】\n\n【参考】',
    emptyBody
  );
}

console.log(`\n===== 纯逻辑部分：通过 ${pass} 项，失败 ${fail} 项 =====`);

/* ================================================================== *
 * 第 2 部分：协调器级假流（假 SSE 喂真实协调器）
 * ================================================================== */

const sse = (events) =>
  events
    .map(
      ([event, data]) =>
        `event: ${event}\ndata: ${JSON.stringify({ thread_id: 't1', request_id: 'r1', data })}\n\n`
    )
    .join('');

const stubFetchWith = (sseText) => {
  globalThis.fetch = async () => {
    const stream = new ReadableStream({
      start(controller) {
        controller.enqueue(new TextEncoder().encode(sseText));
        controller.close();
      },
    });
    return new Response(stream, { status: 200, headers: { 'Content-Type': 'text/event-stream' } });
  };
};

/** 跑一轮，收集各类事件 */
const runTurn = async (events) => {
  stubFetchWith(sse(events));
  const coordinator = new ApiChatCoordinator({ baseUrl: 'http://stub', threadId: 't1' });
  const seen = { messages: [], total: null, streamStart: [], streamEnd: [], streamAbort: [], compose: [], errors: [], order: [] };
  coordinator.addEventListener('message', (m) => {
    seen.messages.push(m);
    seen.order.push(`message:${m.slice(0, 24)}`);
  });
  coordinator.addEventListener('totalResponse', (p) => {
    seen.total = p;
  });
  coordinator.addEventListener('answerStreamStart', (p) => {
    seen.streamStart.push(p);
    seen.order.push('streamStart');
  });
  coordinator.addEventListener('answerStreamEnd', (p) => {
    seen.streamEnd.push(p);
    seen.order.push('streamEnd');
  });
  coordinator.addEventListener('answerStreamAbort', (p) => {
    seen.streamAbort.push(p);
    seen.order.push('streamAbort');
  });
  coordinator.addEventListener('answerStreamCompose', (p) => {
    seen.compose.push(p);
    seen.order.push('streamCompose');
  });
  coordinator.addEventListener('error', (p) => {
    seen.errors.push(p);
    seen.order.push('error');
  });
  await coordinator.generateAnswer('测试问题');
  await new Promise((resolve) => setTimeout(resolve, 80)); // flushContent 会等两帧
  return seen;
};

// 应用侧就是 `content += msg`（见 appendAiMessageChunk），**没有分隔符** ——
// 用 '\n\n' 拼会把流式增量切成一堆段落，断言就失真了
const messageText = (seen) => seen.messages.join('');
const countOf = (text, needle) => text.split(needle).length - 1;
/** 数**卡片块**个数（`POLICY_TABLE` 在同一个块里出现两次：`<!-- POLICY_TABLE` 与 `POLICY_TABLE -->`） */
const countCards = (text) => countOf(text, '<!-- POLICY_TABLE');

/**
 * 跑一轮**并带上应用层的监听器**（与 `useBusinessAssistantChat` 同逻辑），
 * 返回「上屏内容」而不是原始事件 —— 用来断言用户真正看到的东西。
 */
const runTurnWithApp = async (events) => {
  stubFetchWith(sse(events));
  const coordinator = new ApiChatCoordinator({ baseUrl: 'http://stub', threadId: 't1' });
  const stream = { active: false, streamId: '', body: '' };
  const seen = { content: '', matched: null, compose: [], messages: [] };
  coordinator.addEventListener('answerStreamStart', (p) => {
    stream.streamId = String(p?.streamId || '');
    stream.body = '';
    stream.active = true;
  });
  coordinator.addEventListener('message', (msg) => {
    if (stream.active) stream.body += msg; // 正在流式时这条通道上跑的就是正文增量
    seen.messages.push(msg);
    seen.content += msg;
  });
  coordinator.addEventListener('answerStreamEnd', (p) => {
    if (!stream.active || String(p?.streamId || '') !== stream.streamId) return;
    const finalText = String(p?.text ?? '');
    seen.content = applyAnswerStreamEnd(seen.content, stream.body, finalText);
    stream.body = resolveStreamedBodyAfterEnd(stream.body, finalText);
    stream.active = false;
  });
  coordinator.addEventListener('answerStreamAbort', (p) => {
    if (!stream.active || String(p?.streamId || '') !== stream.streamId) return;
    seen.content = applyAnswerStreamAbort(seen.content, stream.body);
    stream.active = false;
  });
  coordinator.addEventListener('answerStreamCompose', (p) => {
    seen.compose.push(p);
    const r = composeAroundStreamBody(
      seen.content,
      stream.body,
      String(p?.leading || ''),
      String(p?.trailing || ''),
      String(p?.replacedLeading || '')
    );
    seen.content = r.next;
    seen.matched = r.matched;
  });
  await coordinator.generateAnswer('回放');
  await new Promise((r) => setTimeout(r, 120));
  return seen;
};

const DELTA_TEXTS = ['一、', '第一段说明', '。\n\n', '二、', '第二段说明', '。'];
const FINAL_TEXT = '一、第一段说明。\n\n二、第二段说明。';
const MARKER = '第一段说明';

console.log('\n【4】协调器假流：happy path（带卡片轮形态，含流中 heartbeat）');
{
  const seen = await runTurn([
    ['accepted', { message: '收到' }],
    ['progress', { stage: 'retrieve', message: '正在检索……' }],
    ['answer_start', { stream_id: 's1', target: 'summary', sequence: 0, provisional: true }],
    ...DELTA_TEXTS.map((text, i) => ['answer_delta', { stream_id: 's1', target: 'summary', sequence: i + 1, text }]),
    ['heartbeat', { status: 'processing', message: '仍在处理……', elapsed_seconds: 20 }],
    ['answer', { text: FINAL_TEXT }],
    ['source', { id: 's1', title: '测试政策', type: 'policy', source: { url: 'https://example.com/p1' } }],
    // 有 item 才有 POLICY_TABLE 卡片块（buildPolicyTableContent 是按 items 建的）
    ['item', { source_id: 's1', title: '测试政策', card: { name: { text: '测试政策' } } }],
    ['answer_end', { stream_id: 's1', target: 'summary', sequence: DELTA_TEXTS.length, text: FINAL_TEXT, operation: 'replace', status: 'completed', provisional: false }],
    ['summary', { text: FINAL_TEXT, source_ids: ['s1'], notices: [] }],
    ['result', { response: FINAL_TEXT, recommendation: {}, errors: [] }],
    ['done', { status: 'completed' }],
  ]);

  const text = messageText(seen);
  if (process.env.DBG) console.log('[dbg] text=' + JSON.stringify(text));
  check('answerStreamStart 发出一次', seen.streamStart.length === 1, seen.streamStart);
  check('answerStreamEnd 发出一次', seen.streamEnd.length === 1, seen.streamEnd);
  check('无 abort', seen.streamAbort.length === 0, seen.streamAbort);
  check('scope 卡片只发了一次（流中 heartbeat 不再发）', countOf(text, '<scope') === 1, countOf(text, '<scope'));
  check('answer_end 的文本是规整后的全文', seen.streamEnd[0]?.text === normalizeChatMarkdown(FINAL_TEXT), seen.streamEnd[0]?.text);
  check(
    '正文在 message 通道**只出现一次**（完整 answer/summary 事件没有渲染成第二份）',
    countOf(text, MARKER) === 1,
    countOf(text, MARKER)
  );
  check(
    '流式增量拼接 === 规整后全文（前缀不变式在真链路成立）',
    text.includes(normalizeChatMarkdown(FINAL_TEXT).split('\n')[0]),
    normalizeChatMarkdown(FINAL_TEXT).slice(0, 30)
  );
  check('totalResponse.answer 含最终全文', String(seen.total?.answer || '').includes('一、第一段说明。'), String(seen.total?.answer || '').slice(0, 40));
  check('totalResponse 里含政策卡片与参考资料', String(seen.total?.answer || '').includes('POLICY_TABLE') && String(seen.total?.answer || '').includes('<ref_links>'));
  // 卡片顺序：流式轮**卡片在正文之上**（用户 2026-09-20 要求）；正文已上屏，故重排通过
  // answerStreamCompose 事件交给应用层（message 通道里只有正文）
  const compose = seen.compose[0];
  check('发出 answerStreamCompose（流式轮的重排信号）', !!compose, seen.compose);
  check('compose.leading 是政策卡片', String(compose?.leading || '').includes('POLICY_TABLE'), String(compose?.leading || '').slice(0, 60));
  check('compose.trailing 是参考资料', String(compose?.trailing || '').includes('<ref_links>'), String(compose?.trailing || '').slice(0, 60));
  check(
    '**totalResponse 里卡片排在正文之前**',
    (() => {
      const ans = String(seen.total?.answer || '');
      return ans.indexOf('POLICY_TABLE') > -1 && ans.indexOf('POLICY_TABLE') < ans.indexOf(MARKER);
    })(),
    String(seen.total?.answer || '').slice(0, 80)
  );
  check('正文本身没有在 message 通道里被卡片打断（卡片走 compose）', !text.includes('POLICY_TABLE'));
  // ⚠️ 契约：compose 让应用层**整块重写**内容（不是往后追加）——
  // 所以渲染层的增量解析必须能识别"非纯追加"并重置，否则会把新内容的中段当正文渲染
  // （踩过：参考资料 JSON 的中段变成一坨文本显示在界面上）
  const composedLeading = String(compose?.leading || '');
  check(
    '重排后的内容**不是正文的纯追加**（渲染层必须支持"整块重写"）',
    composedLeading.length > 0 &&
      !`${composedLeading}\n\n${normalizeChatMarkdown(FINAL_TEXT)}`.startsWith(normalizeChatMarkdown(FINAL_TEXT)),
    composedLeading.slice(0, 40)
  );
}

console.log('\n【5】协调器假流：纯正文轮（无卡片、无 answer 事件）不丢正文');
{
  const seen = await runTurn([
    ['accepted', { message: '收到' }],
    ['answer_start', { stream_id: 's2', target: 'summary', sequence: 0 }],
    ...DELTA_TEXTS.map((text, i) => ['answer_delta', { stream_id: 's2', target: 'summary', sequence: i + 1, text }]),
    ['answer_end', { stream_id: 's2', target: 'summary', sequence: DELTA_TEXTS.length, text: FINAL_TEXT, status: 'completed' }],
    ['summary', { text: FINAL_TEXT }],
    ['result', { response: FINAL_TEXT }],
    ['done', { status: 'completed' }],
  ]);
  check('totalResponse.answer === 最终全文（没有因为"没有卡片"而丢正文）', String(seen.total?.answer || '').trim() === normalizeChatMarkdown(FINAL_TEXT).trim(), String(seen.total?.answer || ''));
}

console.log('\n【6】协调器假流：answer_end 与增量拼接不同 → 整块替换生效');
{
  const seen = await runTurn([
    ['answer_start', { stream_id: 's3', target: 'summary', sequence: 0 }],
    ['answer_delta', { stream_id: 's3', target: 'summary', sequence: 1, text: '草稿内容' }],
    ['answer_end', { stream_id: 's3', target: 'summary', sequence: 1, text: '定稿内容（后端最终校验改过）', status: 'completed' }],
    ['summary', { text: '定稿内容（后端最终校验改过）' }],
    ['result', { response: '定稿内容（后端最终校验改过）' }],
    ['done', { status: 'completed' }],
  ]);
  check('End.text = 规整后的最终文本（不是增量拼接）', seen.streamEnd[0]?.text === '定稿内容（后端最终校验改过）', seen.streamEnd[0]?.text);
  check('totalResponse.answer 用的是最终文本', String(seen.total?.answer || '').includes('定稿内容'), String(seen.total?.answer || ''));
}

console.log('\n【7】协调器假流：后端 error → 撤草稿（abort 先于 error）');
{
  const seen = await runTurn([
    ['answer_start', { stream_id: 's4', target: 'summary', sequence: 0 }],
    ['answer_delta', { stream_id: 's4', target: 'summary', sequence: 1, text: '半截草稿' }],
    ['error', { code: 'processing_failed' }],
  ]);
  const abortAt = seen.order.indexOf('streamAbort');
  const errorAt = seen.order.indexOf('error');
  check('abort 在 error **之前**发出（否则 hook 已摘任务、abort 会被守卫丢弃）', abortAt > -1 && abortAt < errorAt, seen.order);
  check('abort 的 reason = generation_failed', seen.streamAbort[0]?.reason === 'generation_failed', seen.streamAbort[0]);
  check('草稿文本未进入 totalResponse', !String(seen.total?.answer || '').includes('半截草稿'), String(seen.total?.answer || ''));
}

console.log('\n【8】协调器假流：断流（EOF 无 done）→ 撤草稿 + 兼容回退');
{
  const seen = await runTurn([
    ['answer_start', { stream_id: 's5', target: 'summary', sequence: 0 }],
    ['answer_delta', { stream_id: 's5', target: 'summary', sequence: 1, text: '半截草稿' }],
    ['answer', { text: '完整事件里的正文（断流前的兼容副本）' }],
  ]);
  check('断流时发出 abort（reason=not_finalized）', seen.streamAbort[0]?.reason === 'not_finalized', seen.streamAbort);
  // ⚠️ 分层：协调器**只发信号**，真正把草稿从界面上撤掉的是应用层（hook 调 applyAnswerStreamAbort）。
  // 断流路径也不发 totalResponse（既有行为：内容走 message 通道，hook 的 close 监听负责补写 DMS）。
  check('兼容路径的完整 answer 事件仍进了 message 通道', messageText(seen).includes('完整事件里的正文'), messageText(seen).slice(0, 80));
  check('报的是连接断开', seen.errors.some((e) => e?.code === 'disconnected'), seen.errors);
}

console.log('\n【9】协调器假流：旧后端（无任何流式事件）行为不变');
{
  const seen = await runTurn([
    ['accepted', { message: '收到' }],
    ['progress', { stage: 'retrieve', message: '正在检索……' }],
    ['answer', { text: FINAL_TEXT }],
    ['source', { id: 's1', title: '测试政策', type: 'policy', source: { url: 'https://example.com/p1' } }],
    ['item', { source_id: 's1', title: '测试政策', card: { name: { text: '测试政策' } } }],
    ['summary', { text: FINAL_TEXT }],
    ['result', { response: FINAL_TEXT }],
    ['done', { status: 'completed' }],
  ]);
  const text = messageText(seen);
  check('没有流事件、没有 abort', seen.streamStart.length === 0 && seen.streamAbort.length === 0);
  check('不发 answerStreamCompose（旧路径不重排）', seen.compose.length === 0, seen.compose);
  check('scope 卡片正常', countOf(text, '<scope') === 1);
  check('正文按原路径整段输出（规整后）', text.includes(normalizeChatMarkdown(FINAL_TEXT)));
  const bodyAt = text.indexOf('第一段说明');
  const cardAt = text.indexOf('POLICY_TABLE');
  const refAt = text.indexOf('<ref_links>');
  check(
    '**旧路径顺序不变**：正文 → 卡片 → 参考资料',
    bodyAt > -1 && cardAt > -1 && refAt > -1 && bodyAt < cardAt && cardAt < refAt,
    { bodyAt, cardAt, refAt }
  );
}

console.log('\n【10】协调器：流式轮之后跑旧轮，状态不残留');
{
  stubFetchWith(
    sse([
      ['answer_start', { stream_id: 's6', target: 'summary', sequence: 0 }],
      ['answer_delta', { stream_id: 's6', target: 'summary', sequence: 1, text: '流式正文' }],
      ['answer_end', { stream_id: 's6', target: 'summary', sequence: 1, text: '流式正文', status: 'completed' }],
      ['done', { status: 'completed' }],
    ])
  );
  const coordinator = new ApiChatCoordinator({ baseUrl: 'http://stub', threadId: 't1' });
  const rounds = [];
  coordinator.addEventListener('message', (m) => rounds.push(m));
  await coordinator.generateAnswer('第一轮');
  await new Promise((r) => setTimeout(r, 80));
  const cutoff = rounds.length; // 第一轮结束时的分界

  stubFetchWith(
    sse([
      ['progress', { stage: 'retrieve', message: '正在检索……' }],
      ['answer', { text: '第二轮正文' }],
      ['done', { status: 'completed' }],
    ])
  );
  await coordinator.generateAnswer('第二轮');
  await new Promise((r) => setTimeout(r, 80));

  const first = rounds.slice(0, cutoff).join('');
  const second = rounds.slice(cutoff).join('');
  check('第一轮是流式正文', first.includes('流式正文'), first.slice(0, 60));
  check('第二轮回到旧路径：有 scope、正文是整段输出', countOf(second, '<scope') === 1 && second.includes('第二轮正文'), second.slice(0, 80));
}

console.log('\n【11】两个协调器并行流式：互不串台');
{
  stubFetchWith(
    sse([
      ['answer_start', { stream_id: 'A', target: 'summary', sequence: 0 }],
      ['answer_delta', { stream_id: 'A', target: 'summary', sequence: 1, text: '甲会话正文' }],
      ['answer_end', { stream_id: 'A', target: 'summary', sequence: 1, text: '甲会话正文', status: 'completed' }],
      ['done', { status: 'completed' }],
    ])
  );
  const a = new ApiChatCoordinator({ baseUrl: 'http://stub', threadId: 'A' });
  const b = new ApiChatCoordinator({ baseUrl: 'http://stub', threadId: 'B' });
  const gotA = [];
  const gotB = [];
  a.addEventListener('message', (m) => gotA.push(m));
  b.addEventListener('message', (m) => gotB.push(m));
  b.addEventListener('answerStreamAbort', () => gotB.push('ABORT'));

  await a.generateAnswer('问 A');
  await new Promise((r) => setTimeout(r, 80));
  check('B 未收到任何事件（含 abort）', gotB.length === 0, gotB);
  check('A 正常收到正文', gotA.join('').includes('甲会话正文'), gotA);
}

console.log('\n【12】协调器假流 + 应用层组装：answer_end 比增量拼接**多一截尾巴**（真后端形态）');
{
  // 2026-09-20 用户报「同一段内容出现两次」的真实形态（载荷见 harness 记录）：
  //   delta 拼 1309 字，answer_end 给 1610 字 —— 末尾多了 301 字追问建议。
  // 这会让应用侧记录的「流式正文」不再是上屏内容的后缀：
  //   - 修前：重排落兜底 → 卡片排到正文**后面**、正文上屏**两份**
  //   - 修后：end 时同步 stream.body → 正常路径 → 卡片 → 正文 → 参考资料
  //
  // 这里用**合成载荷**保住这个回归（真实抓包不入库），逻辑与 hook 的四个监听器一致。
  const HEAD = '您想开奶茶店，我们青浦目前没有奶茶店或餐饮行业的专项扶持。\n\n### 首次创业一次性补贴\n\n- 补贴标准为**一次性8000元**。';
  const TAIL = '2. **补充申请人的情况**：是否已入驻青浦的孵化主基地？\n3. **确认相关时间**：是否已注册成立满1年？';
  const FINAL = `${HEAD}\n\n${TAIL}`;
  const CHUNKS = [...HEAD]; // 逐字下发，复现真实节奏

  const seen = await runTurnWithApp([
    ['accepted', { message: '收到' }],
    ['answer_start', { stream_id: 's9', target: 'summary', sequence: 0 }],
    ...CHUNKS.map((text, i) => ['answer_delta', { stream_id: 's9', target: 'summary', sequence: i + 1, text }]),
    ['source', { id: 's1', title: '首次创业一次性补贴', type: 'policy', source: { url: 'https://example.com/p' } }],
    ['item', { source_id: 's1', title: '首次创业一次性补贴', card: { name: { text: '首次创业一次性补贴' } } }],
    ['answer_end', { stream_id: 's9', target: 'summary', sequence: CHUNKS.length, text: FINAL, status: 'completed' }],
    ['summary', { text: FINAL, notices: [] }],
    ['result', { response: FINAL, recommendation: {}, errors: [] }],
    ['done', { status: 'completed' }],
  ]);
  const content = seen.content;
  const matched = seen.matched;

  const normFinal = normalizeChatMarkdown(FINAL);
  check('重排落**正常路径**（end 时同步了流式正文）', matched === true, `matched=${matched}`);
  check('正文只出现一次（不重复）', content.split(normFinal).length - 1 === 1, `出现 ${content.split(normFinal).length - 1} 次`);
  check('answer_end 的尾巴没丢', content.includes(normFinal.slice(-20)));
  check('卡-文-参考 顺序：卡片在正文之前', content.indexOf('POLICY_TABLE') < content.indexOf(normFinal.slice(0, 20)));
  check('卡-文-参考 顺序：参考资料在正文之后', content.indexOf('<ref_links>') > content.indexOf(normFinal.slice(0, 20)));
}

console.log('\n【13】F079 卡片先于正文：source/item 在 answer_start **之前**到（真后端顺序）');
{
  // 契约（token-streaming.md「卡片先于正文（F079）」）：有入选政策时，完整 source/item
  // 发完才开始 answer_start/answer_delta；前端**收到 item 即可展示卡片**，不要等 summary/result。
  // 用户 2026-09-21 报告的就是这里没做到：卡片等 done 才发 → 只能整块重写插到正文之上 →
  // 界面上「正文先渲一遍，然后从头再渲一遍」，第一次纯属浪费。
  const seen = await runTurn([
    ['accepted', { message: '收到' }],
    ['progress', { stage: 'retrieve', message: '正在查阅……' }],
    ['source', { id: 's1', title: '首次创业一次性补贴', type: 'policy', source: { url: 'https://example.com/p1' } }],
    ['item', { source_id: 's1', title: '首次创业一次性补贴', card: { name: { text: '首次创业一次性补贴' } } }],
    ['answer_start', { stream_id: 's1', target: 'summary', sequence: 0, provisional: true }],
    ...DELTA_TEXTS.map((text, i) => ['answer_delta', { stream_id: 's1', target: 'summary', sequence: i + 1, text }]),
    ['answer_end', { stream_id: 's1', target: 'summary', sequence: DELTA_TEXTS.length, text: FINAL_TEXT, operation: 'replace', status: 'completed' }],
    ['summary', { text: FINAL_TEXT, source_ids: ['s1'], notices: [] }],
    ['result', { response: FINAL_TEXT, recommendation: {}, errors: [] }],
    ['done', { status: 'completed' }],
  ]);

  const text = messageText(seen);
  const atCard = text.indexOf('POLICY_TABLE');
  const atBody = text.indexOf(MARKER);
  const atRefs = text.indexOf('<ref_links>');
  check('卡片在 message 通道里出现', atCard >= 0);
  check('**卡片排在正文之前**（开流前就上屏了）', atCard >= 0 && atBody >= 0 && atCard < atBody, `卡片@${atCard} 正文@${atBody}`);
  check('正文只出现一次', countOf(text, MARKER) === 1, countOf(text, MARKER));
  check('参考资料仍排在正文之后', atRefs > atBody, `正文@${atBody} 参考@${atRefs}`);
  check(
    '**不发出 answerStreamCompose**（卡片已在正文之前，不需要整块重写 → 界面上不会重渲一遍）',
    seen.compose.length === 0,
    seen.compose
  );
  // 尾部必须是**独立的一段**追加（不是混在正文增量里），否则渲染层会把它当正文
  const lastChunk = seen.messages[seen.messages.length - 1] || '';
  check(
    '尾部（参考资料）作为**独立追加**发出，且不夹带正文',
    lastChunk.includes('<ref_links>') && !lastChunk.includes(MARKER),
    JSON.stringify(lastChunk.slice(0, 60))
  );
  check('尾部追加发生在正文之后（上屏内容以参考资料结尾）', text.trimEnd().endsWith('</ref_links>'), JSON.stringify(text.slice(-40)));
  check(
    'totalResponse 里卡片仍排在正文之前',
    (() => {
      const ans = String(seen.total?.answer || '');
      return ans.indexOf('POLICY_TABLE') > -1 && ans.indexOf('POLICY_TABLE') < ans.indexOf(MARKER);
    })(),
    String(seen.total?.answer || '').slice(0, 80)
  );
  check('totalResponse 与上屏内容顺序一致（卡片 → 正文 → 参考资料）', (() => {
    const ans = String(seen.total?.answer || '');
    return ans.indexOf('POLICY_TABLE') < ans.indexOf(MARKER) && ans.indexOf(MARKER) < ans.indexOf('<ref_links>');
  })(), String(seen.total?.answer || '').slice(0, 120));
}

console.log('\n【14】F079 的兜底：item 晚于 answer_start（旧后端或后端顺序变化）');
{
  const seen = await runTurn([
    ['answer_start', { stream_id: 's1', target: 'summary', sequence: 0 }],
    ...DELTA_TEXTS.map((text, i) => ['answer_delta', { stream_id: 's1', target: 'summary', sequence: i + 1, text }]),
    ['item', { source_id: 's1', title: '迟到卡片', card: { name: { text: '迟到卡片' } } }],
    ['answer_end', { stream_id: 's1', target: 'summary', sequence: DELTA_TEXTS.length, text: FINAL_TEXT, status: 'completed' }],
    ['summary', { text: FINAL_TEXT }],
    ['result', { response: FINAL_TEXT }],
    ['done', { status: 'completed' }],
  ]);
  const text = messageText(seen);
  check('开流时没有卡片 → 仍发出 answerStreamCompose 兜底', seen.compose.length === 1, seen.compose.length);
  check('兜底 compose 的 leading 是卡片', String(seen.compose[0]?.leading || '').includes('POLICY_TABLE'), String(seen.compose[0]?.leading || '').slice(0, 40));
  check('卡片只出现一次（没有既提前发、又兜底发）', countCards(text) === 0, `message 通道出现 ${countCards(text)} 次（走 compose 时为 0）`);
  check('totalResponse 里卡片仍在正文之前', (() => {
    const ans = String(seen.total?.answer || '');
    return ans.indexOf('POLICY_TABLE') > -1 && ans.indexOf('POLICY_TABLE') < ans.indexOf(MARKER);
  })(), String(seen.total?.answer || '').slice(0, 80));
}

console.log('\n【15】应用层：F079 顺序下的最终版式（卡片 → 正文 → 参考资料，且都只出现一次）');
{
  const HEAD = '您想开奶茶店，我们青浦目前没有奶茶店或餐饮行业的专项扶持。\n\n### 首次创业一次性补贴\n\n- 补贴标准为**一次性8000元**。';
  const FINAL = `${HEAD}\n\n2. **确认相关时间**：是否已注册成立满1年？`;
  const seen = await runTurnWithApp([
    ['progress', { stage: 'retrieve', message: '正在查阅……' }],
    ['source', { id: 's1', title: '首次创业一次性补贴', type: 'policy', source: { url: 'https://example.com/p' } }],
    ['item', { source_id: 's1', title: '首次创业一次性补贴', card: { name: { text: '首次创业一次性补贴' } } }],
    ['answer_start', { stream_id: 's1', target: 'summary', sequence: 0 }],
    ...[...HEAD].map((text, i) => ['answer_delta', { stream_id: 's1', target: 'summary', sequence: i + 1, text }]),
    ['answer_end', { stream_id: 's1', target: 'summary', sequence: [...HEAD].length, text: FINAL, status: 'completed' }],
    ['summary', { text: FINAL, notices: [] }],
    ['result', { response: FINAL, recommendation: {}, errors: [] }],
    ['done', { status: 'completed' }],
  ]);
  const content = seen.content;
  const normFinal = normalizeChatMarkdown(FINAL);
  const head = normFinal.slice(0, 20);
  check('卡片只出现一次', countCards(content) === 1, countCards(content));
  check('正文只出现一次', countOf(content, normFinal) === 1, countOf(content, normFinal));
  check('参考资料只出现一次', countOf(content, '<ref_links>') === 1, countOf(content, '<ref_links>'));
  check('卡片 → 正文 → 参考资料', content.indexOf('POLICY_TABLE') < content.indexOf(head) && content.indexOf(head) < content.indexOf('<ref_links>'), `卡片@${content.indexOf('POLICY_TABLE')} 正文@${content.indexOf(head)} 参考@${content.indexOf('<ref_links>')}`);
  check('**没有整块重排**（compose 一次都没发 → 界面上不会重渲一遍）', seen.compose.length === 0, seen.compose.length);
}

console.log('\n【16】应用层：卡片集合在开流后变大（契约外的兜底）→ 不能留下两份卡片');
{
  const FINAL = '一、第一段说明。\n\n二、第二段说明。';
  const seen = await runTurnWithApp([
    ['source', { id: 's1', title: '甲政策', type: 'policy', source: { url: 'https://example.com/p1' } }],
    ['item', { source_id: 's1', title: '甲政策', card: { name: { text: '甲政策' } } }],
    ['answer_start', { stream_id: 's1', target: 'summary', sequence: 0 }],
    ...DELTA_TEXTS.map((text, i) => ['answer_delta', { stream_id: 's1', target: 'summary', sequence: i + 1, text }]),
    // 开流后才到的第二张卡（违反 F079 顺序；旧后端或后端改动时可能发生）
    ['source', { id: 's2', title: '乙政策', type: 'policy', source: { url: 'https://example.com/p2' } }],
    ['item', { source_id: 's2', title: '乙政策', card: { name: { text: '乙政策' } } }],
    ['answer_end', { stream_id: 's1', target: 'summary', sequence: DELTA_TEXTS.length, text: FINAL, status: 'completed' }],
    ['summary', { text: FINAL }],
    ['result', { response: FINAL }],
    ['done', { status: 'completed' }],
  ]);
  const content = seen.content;
  check('发了 compose 兜底', seen.compose.length === 1, seen.compose.length);
  check('compose 带上了「需要抹掉的旧卡片块」', !!String(seen.compose[0]?.replacedLeading || ''), String(seen.compose[0]?.replacedLeading || '').slice(0, 40));
  check('**卡片块只保留一份**（旧的被抹掉，不是新旧并存）', countCards(content) === 1, countCards(content));
  check('新卡片在内容里（乙政策）', content.includes('乙政策'));
  check('正文只出现一次', countOf(content, MARKER) === 1, countOf(content, MARKER));
  check('卡片仍在正文之前', content.indexOf('POLICY_TABLE') < content.indexOf(MARKER));
}

console.log('\n【17】应用层：撤稿时**已上屏的卡片保留**（契约要求），且不会被补发第二份');
{
  // ⚠️ 断流（EOF 无 done）这条路径**会走 flushContent** —— 那时 `answerStream` 已被
  // `discardActiveStream` 重置，`streaming` 变回 false。若「卡片已上屏」的判据里带上
  // `streaming`，卡片就会被当成本轮的新内容**再发一份**（界面上两份卡片）。
  const seen = await runTurnWithApp([
    ['source', { id: 's1', title: '甲政策', type: 'policy', source: { url: 'https://example.com/p1' } }],
    ['item', { source_id: 's1', title: '甲政策', card: { name: { text: '甲政策' } } }],
    ['answer_start', { stream_id: 's1', target: 'summary', sequence: 0 }],
    ['answer_delta', { stream_id: 's1', target: 'summary', sequence: 1, text: '半截草稿' }],
    // 没有 done 就到 EOF
  ]);
  const content = seen.content;
  check('卡片保留（开流前已上屏）且只有一份', countCards(content) === 1, countCards(content));
  check('草稿已被撤掉', !content.includes('半截草稿'), content.slice(-60));
}

console.log('\n【18】应用层：后端 error（不走 flushContent）撤稿，卡片同样保留');
{
  const seen = await runTurnWithApp([
    ['source', { id: 's1', title: '甲政策', type: 'policy', source: { url: 'https://example.com/p1' } }],
    ['item', { source_id: 's1', title: '甲政策', card: { name: { text: '甲政策' } } }],
    ['answer_start', { stream_id: 's1', target: 'summary', sequence: 0 }],
    ['answer_delta', { stream_id: 's1', target: 'summary', sequence: 1, text: '半截草稿' }],
    ['error', { code: 'processing_failed' }],
  ]);
  const content = seen.content;
  check('卡片保留且只有一份', countCards(content) === 1, countCards(content));
  check('草稿已被撤掉', !content.includes('半截草稿'), content.slice(-60));
}

console.log(`\n===== 总计：通过 ${pass} 项，失败 ${fail} 项 =====`);
process.exit(fail ? 1 : 0);