niceeval 0.12.1 → 0.12.2-canary.31

package/src/report/model/metrics.ts

@@ -1,256 +0,0 @@
-// 内置读数（AttemptMetric 字面量）。
-//
-// null ≠ 0:null = 此 attempt 测不了这个指标(不进聚合);0 = 测了,结果是零(照常进)。
-// 哪个 verdict 落哪边必须显式表态,内置指标按 docs/feature/reports/library.md「内置指标」的表格。
-// 三个通过率指标把「Agent 答错」与「基建没跑起来」拆开,不互相伪装:
-//
-//   指标(name)                                    skipped  errored          failed  passed        better
-//   taskPassRate(task-pass-rate)                   null     null             0       1             higher
-//   executionReliability(execution-reliability)    null     0                1       1             higher
-//   passRate(pass-rate)                            null     0                0       1             higher
-//   examScore(exam-score)                          null     0                0       soft 均分      higher
-//   totalScore(total-score)                        null     null             Σpoints Σpoints       higher(通过制 eval 恒 null,不参与聚合)
-//   durationMs(duration)                           null     实测;timeout→null 同左   实测     实测          lower
-//   tokens(tokens)                                 null     实测;无 usage→null 同左   同左          lower
-//   costUSD(cost)                                  null     同上             同左     同左          lower
-//   assistantTurns(assistant-turns)                null     实测;o11y 缺失→null 同左  同左          lower
-//   repeatedFailedCommands(repeated-failed-commands) null   实测;o11y 缺失→null 同左  同左          lower
-//
-// bounds(自然边界,驱动图轴呼吸边距的钳制,见 docs/feature/reports/components/charts/README.md
-// 「值域」):三个通过率指标与 examScore 是 { min: 0, max: 1 };其余七个(totalScore、
-// durationMs、tokens、costUSD、assistantTurns、repeatedFailedCommands)是 { min: 0 }。
-//
-// 两档指标(docs/feature/reports/library/measures.md「内置指标」):以上除 assistantTurns 与
-// repeatedFailedCommands 外全部只读 attempt.result 的瘦身字段——任何 producer、任何
-// publish artifacts 选择都算得出,内置 SampleOverview 只用这一档。
-// 后两个读 attempt.o11y()(懒加载 artifact),发布时若 o11y 没随行就诚实渲染缺数据「—」,
-// 不算 0——报告作者自己摆时心里要有这根弦,内置报告不用它们。
-
-import type { EvalResult } from "../../types.ts";
-import type { AttemptMetric } from "./types.ts";
-
-/** 内部：校验 AttemptMetric 字面量；不对外导出。 */
-function attemptMetric<const Name extends string>(def: AttemptMetric<Name>): AttemptMetric<Name> {
-  if (typeof def.name !== "string" || def.name.length === 0) {
-    throw new Error(`attemptMetric: name must be a non-empty string.`);
-  }
-  if (typeof def.value !== "function") {
-    throw new Error(`attemptMetric "${def.name}" must provide a value(attempt) function.`);
-  }
-  return def;
-}
-
-/** 单 attempt 成本:网关实测(usage.costUSD)优先于价格表估算(estimatedCostUSD);都缺 → null,不编 0。 */
-export function attemptCostUSD(result: EvalResult): number | null {
-  return result.usage?.costUSD ?? result.estimatedCostUSD ?? null;
-}
-
-/**
- * 条件答题质量:passed = 1,failed = 0,errored 记 null 不进分母。
- * 这是「已形成可信判定」条件下的诊断指标,不能简称默认通过率
- * (docs/feature/reports/library.md「内置指标」)。
- */
-export const taskPassRate = attemptMetric({
-  name: "task-pass-rate",
-  label: { en: "Task pass rate", "zh-CN": "可判定任务通过率" },
-  description: "Conditional task quality among attempts that formed a trustworthy verdict: passed = 1, failed = 0; errored is null.",
-  better: "higher",
-  unit: "%",
-  bounds: { min: 0, max: 1 },
-  value(a) {
-    switch (a.result.verdict) {
-      case "passed":
-        return 1;
-      case "failed":
-        return 0;
-      default:
-        // errored = 没形成可信判定 → null 不进这个条件指标;skipped 同为 null。
-        return null;
-    }
-  },
-});
-
-/** 执行可靠性:跑到可判定(passed / failed)= 1,errored = 0;skipped → null。 */
-export const executionReliability = attemptMetric({
-  name: "execution-reliability",
-  label: { en: "Execution reliability", "zh-CN": "执行可靠性" },
-  description: "Execution reliability: reached a trustworthy verdict (passed / failed) = 1, errored = 0.",
-  better: "higher",
-  unit: "%",
-  bounds: { min: 0, max: 1 },
-  value(a) {
-    switch (a.result.verdict) {
-      case "passed":
-      case "failed":
-        return 1;
-      case "errored":
-        return 0;
-      default:
-        return null; // skipped
-    }
-  },
-});
-
-/**
- * 端到端合成:passed = 1,failed / errored = 0;哪边拖累用
- * taskPassRate / executionReliability 拆开看。
- */
-export const passRate = attemptMetric({
-  name: "passRate",
-  label: { en: "Pass rate", "zh-CN": "通过率" },
-  description: "End-to-end composite: passed = 1, failed / errored = 0. Split blame with taskPassRate and executionReliability.",
-  better: "higher",
-  unit: "%",
-  bounds: { min: 0, max: 1 },
-  value: (a) =>
-    a.result.verdict === "skipped" ? null : a.result.verdict === "passed" ? 1 : 0,
-});
-
-export const examScore = attemptMetric({
-  name: "exam-score",
-  label: { en: "Exam score", "zh-CN": "考试得分" },
-  description: "Per-eval score: gates decide pass, soft assertions grade quality.",
-  better: "higher",
-  unit: "%",
-  bounds: { min: 0, max: 1 },
-  value(a) {
-    const { verdict, assertions } = a.result;
-    if (verdict === "skipped") return null;
-    // 先按 verdict 分派,再看断言:errored 的断言是空数组,「gate 全过才得分」的
-    // 字面实现会让条件空真成立、崩溃反而得满分 —— 交白卷是 0 分,不是缺数据,更不是满分。
-    // failed 同理得 0:--strict 下被翻成 failed 的哪怕 soft 分不低也是 0(报告不重新判卷)。
-    if (verdict !== "passed") return 0;
-    // unavailable 没有分数:不计入均分分母(评不了 ≠ 0 分;非 optional 的 unavailable
-    // 早已把 verdict 拖成 errored,走不到这个分支)。带 points 的也排除:计分制的得分点
-    // 已经在分数面被读过一次,再进质量分就是同一条证据被读两遍(docs/feature/experiments/
-    // score-points.md「折叠树」——质量分按「soft 且无 points」取子集)。
-    const soft = assertions.filter(
-      (x) => x.severity === "soft" && x.outcome !== "unavailable" && x.points === undefined,
-    );
-    if (soft.length === 0) return 1;
-    return soft.reduce((sum, x) => sum + (x.outcome === "unavailable" ? 0 : x.score), 0) / soft.length;
-  },
-});
-
-/**
- * 计分制(`defineScoreEval`)eval 的挣分:`assertions[].points` 之和加 `scoreEntries[].points`
- * 之和——纯累加,不声明满分(docs/feature/experiments/score-points.md「计分制:叠加给分,
- * 没有上限声明」)。errored 记 null(基础设施得 null,不折成 0);skipped 同为 null。通过制
- * (`evaluationKind !== "points"`,含省略即 "pass")eval 没有分数面,同样返回 null——这样跨题型的
- * Sample 里对 totalScore 求 acrossEvals 和时,通过制 eval 天然不贡献、也不拉低分母(它们不落
- * 进这个指标的样本)。`runs > 1` 时同一 eval 的多个 attempt 取均值(perEval mean,与文档「eval
- * 得分取各 attempt 的均值」一致);跨 eval 用 sum(acrossEvals sum,对应「总分 = Σ 各 eval 挣分」)。
- */
-export const totalScore = attemptMetric({
-  name: "total-score",
-  label: { en: "Total score", "zh-CN": "总分" },
-  description: "Points eval's earned points: sum of assertions[].points + scoreEntries[].points. Not applicable (null) to pass evals.",
-  better: "higher",
-  bounds: { min: 0 },
-  value(a) {
-    if (a.result.evaluationKind !== "points") return null;
-    if (a.result.verdict === "errored" || a.result.verdict === "skipped") return null;
-    let total = 0;
-    for (const assertion of a.result.assertions) {
-      if (assertion.outcome !== "unavailable" && typeof assertion.points === "number") total += assertion.points;
-    }
-    for (const entry of a.result.scoreEntries ?? []) total += entry.points;
-    return total;
-  },
-  perEval: "mean",
-  acrossEvals: "sum",
-});
-
-export const durationMs = attemptMetric({
-  name: "duration",
-  label: { en: "Duration", "zh-CN": "平均耗时" },
-  description: "Wall-clock duration of the attempt. Timeout-truncated attempts (error.code = \"timeout\") return null: the timeout line is a right-censoring point, not an observed completion time.",
-  better: "lower",
-  unit: "ms",
-  bounds: { min: 0 },
-  value(a) {
-    if (a.result.verdict === "skipped") return null;
-    // 超时删失:线值不是「跑了这么久」,是「被砍在这里」——计入聚合会把截断当实测,
-    // 排除又制造幸存者偏差(慢条件因为被截断反而显得快)。唯一诚实做法是 null,
-    // 让 MetricValue 的 samples < total 把删失显式呈现出来(docs/feature/reports/library/measures.md「内置指标」)。
-    if (a.result.verdict === "errored" && a.result.error?.code === "timeout") return null;
-    return a.result.durationMs;
-  },
-});
-
-export const tokens = attemptMetric({
-  name: "tokens",
-  label: { en: "Tokens", "zh-CN": "Tokens" },
-  description: "Input + output tokens (cache reads/writes excluded).",
-  better: "lower",
-  unit: "tokens",
-  bounds: { min: 0 },
-  value(a) {
-    if (a.result.verdict === "skipped") return null;
-    const usage = a.result.usage;
-    // input/output 缺失(协议没提供)→ null,不拿 0 冒充「实测就是 0」
-    // (docs/feature/record/architecture.md#usage)。
-    if (!usage || usage.inputTokens === undefined || usage.outputTokens === undefined) return null;
-    // 只加 input + output:缓存读写量大但便宜,计进去会把缓存热的 agent 画成 token 大户;
-    // 花钱多少本来就有 costUSD 负责。
-    return usage.inputTokens + usage.outputTokens;
-  },
-});
-
-export const costUSD = attemptMetric({
-  name: "cost",
-  label: { en: "Cost", "zh-CN": "成本" },
-  description: "USD cost per attempt (gateway-measured beats estimated).",
-  better: "lower",
-  unit: "$",
-  bounds: { min: 0 },
-  value: (a) => (a.result.verdict === "skipped" ? null : attemptCostUSD(a.result)),
-});
-
-/**
- * 读 artifact(o11y,懒加载)的内置指标之一——其余只读瘦身字段。
- * 发布时若该 attempt 没带 o11y(如 publish 的 artifacts 选项漏了它),
- * value 如实返回 null,渲染成「—」,不冒充 0。名字带限定词:o11y 事件流中的 assistant
- * turn 数与 `t.send` 的 `turn<N>` / `session<K>/turn<N>` 轮次是两个计数。
- */
-export const assistantTurns = attemptMetric({
-  name: "assistant-turns",
-  label: { en: "Assistant turns", "zh-CN": "Assistant 轮次" },
-  description: "Assistant turns in the o11y event stream per attempt. Reads o11y — “—” if not published alongside this attempt.",
-  better: "lower",
-  unit: "turns",
-  bounds: { min: 0 },
-  async value(a) {
-    if (a.result.verdict === "skipped") return null;
-    const o11y = await a.o11y();
-    return o11y?.totalTurns ?? null;
-  },
-});
-
-/**
- * 同一 attempt 内同一条 shell 命令的重复失败数:每条命令失败 n 次(n > 1)记 n − 1,求和。
- * 成功执行与只失败一次的命令不计。回答 agent 是否在反复撞同一个已知失败的命令。
- * 读 o11y.json;skipped 与缺 o11y 返回 null(docs/feature/reports/library/measures.md「内置指标」)。
- */
-export const repeatedFailedCommands = attemptMetric({
-  name: "repeated-failed-commands",
-  label: { en: "Repeated failed commands", "zh-CN": "重复失败命令" },
-  description: "Per attempt: for each shell command failing n > 1 times, count n − 1, summed. Reads o11y — “—” if not published alongside this attempt.",
-  better: "lower",
-  unit: "cmds",
-  bounds: { min: 0 },
-  async value(a) {
-    if (a.result.verdict === "skipped") return null;
-    const o11y = await a.o11y();
-    if (!o11y) return null;
-    const failures = new Map<string, number>();
-    for (const entry of o11y.shellCommands) {
-      const failed = entry.success === false || (entry.success === undefined && entry.exitCode !== undefined && entry.exitCode !== 0);
-      if (!failed) continue;
-      failures.set(entry.command, (failures.get(entry.command) ?? 0) + 1);
-    }
-    let repeated = 0;
-    for (const n of failures.values()) if (n > 1) repeated += n - 1;
-    return repeated;
-  },
-});

package/src/report/model/panel.test.ts

@@ -1,272 +0,0 @@
-// cases: docs/engineering/testing/unit/reports.md
-// 分区「面板几何（panel.ts）」：区域框契约的纯函数实现,直接对 renderPanel 的返回行数组
-// 断言,不经真实终端或 HTML(与 chart-math/grid-layout 同一类,见 grid-layout.test.ts)。
-
-import { describe, expect, it } from "vitest";
-import { panelContentWidth, renderPanel, renderRule } from "./panel.ts";
-import { stringWidth } from "./text-layout.ts";
-
-describe("renderPanel — 顶层完整框", () => {
-  it("boxed 模式画完整四边框,标题嵌上边框左侧、meta 嵌右侧,正文左右各留边框+padding", () => {
-    const lines = renderPanel({
-      title: "PLAN",
-      rows: [{ kind: "line", text: "45 attempts · 9 evals × 5 configs" }],
-      width: 82,
-      mode: "boxed",
-    });
-    expect(lines[0]!.startsWith("╭─ PLAN ")).toBe(true);
-    expect(lines[0]!.endsWith("╮")).toBe(true);
-    expect(lines.at(-1)!.startsWith("╰")).toBe(true);
-    expect(lines.at(-1)!.endsWith("╯")).toBe(true);
-    expect(lines[1]!.startsWith("│ 45 attempts · 9 evals × 5 configs")).toBe(true);
-    expect(lines[1]!.endsWith(" │")).toBe(true);
-    // 每一行(含边框)显示宽度恒等于声明宽度
-    for (const line of lines) expect(stringWidth(line)).toBe(82);
-  });
-
-  it("meta 嵌上边框右侧、footerCommand 嵌下边框右侧", () => {
-    const lines = renderPanel({
-      title: "niceeval exp compare",
-      meta: "2m 14s",
-      footerCommand: "$0.84",
-      rows: [{ kind: "line", text: "45 total · 6 reused · 19 running · 12 queued · 8 completed" }],
-      width: 82,
-      mode: "boxed",
-    });
-    expect(lines[0]).toBe(
-      "╭─ niceeval exp compare ──────────────────────────────────────────────── 2m 14s ─╮",
-    );
-    expect(lines.at(-1)).toBe(
-      "╰──────────────────────────────────────────────────────────────────────── $0.84 ─╯",
-    );
-  });
-});
-
-describe("renderPanel — 嵌套 Section 降横隔", () => {
-  it("divider 行渲染成贯穿框宽的 ├─ 标题 ─┤,不再画嵌套的四边框", () => {
-    const lines = renderPanel({
-      title: "运行总览",
-      meta: "6/6 完成",
-      rows: [
-        { kind: "line", text: "…顶层正文…" },
-        { kind: "divider", title: "Cost" },
-        { kind: "line", text: "…嵌套 Section 的正文…" },
-      ],
-      width: 82,
-      mode: "boxed",
-    });
-    const dividerLine = lines.find((l) => l.startsWith("├"));
-    expect(dividerLine).toBeDefined();
-    expect(dividerLine).toMatch(/^├─ Cost ─+┤$/);
-    expect(stringWidth(dividerLine!)).toBe(82);
-    // 只有一层框:整份输出只有一对 ╭…╮ / ╰…╯,没有第二个嵌套的完整边框
-    expect(lines.filter((l) => l.startsWith("╭")).length).toBe(1);
-    expect(lines.filter((l) => l.startsWith("╰")).length).toBe(1);
-  });
-
-  it("divider 的 meta 右对齐在同一条隔条上", () => {
-    const lines = renderPanel({
-      title: "outer",
-      rows: [{ kind: "divider", title: "ACTIVE", meta: "3 running" }],
-      width: 82,
-      mode: "boxed",
-    });
-    const dividerLine = lines.find((l) => l.startsWith("├"))!;
-    expect(dividerLine).toMatch(/^├─ ACTIVE ─+ 3 running ─┤$/);
-  });
-
-});
-
-describe("renderPanel — 宽度上限与截断优先级", () => {
-  it("宽度上限 100:更宽的可用宽度也不会把框撑过 100 显示列", () => {
-    const lines = renderPanel({
-      title: "PLAN",
-      rows: [{ kind: "line", text: "x" }],
-      width: 200,
-      mode: "boxed",
-    });
-    for (const line of lines) expect(stringWidth(line)).toBeLessThanOrEqual(100);
-    expect(stringWidth(lines[0]!)).toBe(100);
-  });
-
-  it("调用方声明 capWidth: false 时框宽豁免 100 上限、跟随传入宽度(动态面板形态)", () => {
-    const lines = renderPanel({
-      title: "niceeval exp compare",
-      rows: [{ kind: "line", text: "x" }],
-      width: 200,
-      mode: "boxed",
-      capWidth: false,
-    });
-    for (const line of lines) expect(stringWidth(line)).toBe(200);
-  });
-
-  it("省略 capWidth 时默认行为不变,仍然封顶 100(豁免是显式 opt-in,不是新默认值)", () => {
-    const lines = renderPanel({
-      title: "PLAN",
-      rows: [{ kind: "line", text: "x" }],
-      width: 200,
-      mode: "boxed",
-    });
-    expect(stringWidth(lines[0]!)).toBe(100);
-  });
-
-  it("先缩横线到最短一段,标题/meta 仍完整时不截断内容", () => {
-    const lines = renderPanel({
-      title: "PLAN",
-      meta: "1m 02s",
-      rows: [],
-      width: 60,
-      mode: "boxed",
-    });
-    expect(lines[0]).toContain("PLAN");
-    expect(lines[0]).toContain("1m 02s");
-    expect(stringWidth(lines[0]!)).toBe(60);
-  });
-
-  it("横线缩到头仍放不下时,标题中段截断补 …,meta 保持完整", () => {
-    const longTitle = "niceeval exp compare --very-long-flag-name-that-does-not-fit-in-a-narrow-box";
-    const lines = renderPanel({
-      title: longTitle,
-      meta: "2m 14s",
-      rows: [],
-      width: 60,
-      mode: "boxed",
-    });
-    const border = lines[0]!;
-    expect(stringWidth(border)).toBe(60);
-    expect(border).toContain("…"); // 标题被截断
-    expect(border).toContain("2m 14s"); // meta 仍然完整保留
-    // 保留标题的头部与尾部(「保留 niceeval exp 和末尾参数」同一条规则)
-    expect(border).toContain("niceeval");
-  });
-
-  it("即使标题截到最短也放不下 meta 时,最后才放弃 meta——标题优先于 meta", () => {
-    const longTitle = "a".repeat(80);
-    const lines = renderPanel({
-      title: longTitle,
-      meta: "this metadata text is also fairly long",
-      rows: [],
-      width: 60,
-      mode: "boxed",
-    });
-    const border = lines[0]!;
-    expect(stringWidth(border)).toBe(60);
-    expect(border).toContain(longTitle.slice(0, 3)); // 标题头部仍可辨认
-  });
-});
-
-describe("renderPanel — 非 TTY / 窄终端降级为无框文本", () => {
-  it("mode: \"plain\" 时不产生任何框字符,title 单独成行、meta 同行右侧、正文两格缩进", () => {
-    const lines = renderPanel({
-      title: "运行总览",
-      meta: "6/6 完成",
-      rows: [{ kind: "line", text: "body line" }],
-      width: 82,
-      mode: "plain",
-    });
-    expect(lines.join("\n")).not.toMatch(/[╭╮╰╯├┤]/);
-    expect(lines[0]).toContain("运行总览");
-    expect(lines[0]).toContain("6/6 完成");
-    expect(lines[1]).toBe("  body line");
-  });
-
-  it("宽度窄于 60 列时,即便 mode: \"boxed\" 也整体降级为无框文本", () => {
-    const lines = renderPanel({
-      title: "PLAN",
-      rows: [{ kind: "line", text: "x" }],
-      width: 59,
-      mode: "boxed",
-    });
-    expect(lines.join("\n")).not.toMatch(/[╭╮╰╯├┤]/);
-  });
-
-  it("plain 模式下 divider 行按与顶层相同的规则渲染标题(+meta),不画横隔字符", () => {
-    const lines = renderPanel({
-      rows: [{ kind: "divider", title: "RESULTS" }],
-      width: 82,
-      mode: "plain",
-    });
-    expect(lines.join("\n")).not.toMatch(/[├┤]/);
-    expect(lines[0]).toContain("RESULTS");
-  });
-
-  it("内容与分节顺序在降级前后一字不变(框只是呈现层)", () => {
-    const rows = [
-      { kind: "line" as const, text: "first" },
-      { kind: "divider" as const, title: "MID" },
-      { kind: "line" as const, text: "second" },
-    ];
-    const boxed = renderPanel({ title: "T", rows, width: 82, mode: "boxed" });
-    const plain = renderPanel({ title: "T", rows, width: 82, mode: "plain" });
-    const strip = (s: string) => s.replace(/[│╭╮╰╯├┤─\s]/g, "");
-    expect(boxed.map(strip).filter(Boolean)).toEqual(plain.map(strip).filter(Boolean));
-  });
-});
-
-describe("renderPanel — CJK / ambiguous 宽度量测", () => {
-  it("CJK 内容按 2 列量测,正文行仍严格对齐到声明宽度", () => {
-    const lines = renderPanel({
-      title: "运行总览",
-      rows: [{ kind: "line", text: "中文内容测试" }], // 6 个汉字 = 12 列
-      width: 82,
-      mode: "boxed",
-    });
-    for (const line of lines) expect(stringWidth(line)).toBe(82);
-  });
-
-  it("East-Asian-Ambiguous 字符(· ● … × ✓ ✗)恒记 1 列,与 text-layout 的量测表一致", () => {
-    const ambiguous = "· ● … × ✓ ✗";
-    expect(stringWidth(ambiguous)).toBe(ambiguous.length);
-    const lines = renderPanel({
-      rows: [{ kind: "line", text: ambiguous }],
-      width: 60,
-      mode: "boxed",
-    });
-    for (const line of lines) expect(stringWidth(line)).toBe(60);
-  });
-
-  it("panelContentWidth 与实际内容行宽度一致:boxed 少 4 列、plain 少 2 列", () => {
-    expect(panelContentWidth(82, "boxed")).toBe(78);
-    expect(panelContentWidth(82, "plain")).toBe(80);
-    // 宽度低于 60 时 boxed 请求同样按 plain 的算法折算(与 renderPanel 的降级判断一致)
-    expect(panelContentWidth(50, "boxed")).toBe(48);
-  });
-
-  it("panelContentWidth 的 capWidth: false 豁免同一个 100 上限,内容宽仍是 width - 4", () => {
-    expect(panelContentWidth(200, "boxed", false)).toBe(196);
-    // 省略第三个参数时默认仍封顶 100,内容宽固定 96,不随 width 继续增长
-    expect(panelContentWidth(200, "boxed")).toBe(96);
-  });
-});
-
-describe("renderRule — 隔条", () => {
-  it("boxed 模式是一条不封口的横线,左侧嵌名称,总显示宽度等于框宽", () => {
-    const rule = renderRule({ title: "概览 1/3", width: 82, mode: "boxed" });
-    expect(rule.startsWith("── 概览 1/3 ─")).toBe(true);
-    expect(rule.endsWith("─")).toBe(true);
-    // 不封口:四角字符一个都不出现,读者不会把它读成一块有边界的面板
-    expect(/[╭╮╰╯│├┤]/.test(rule)).toBe(false);
-    expect(stringWidth(rule)).toBe(82);
-  });
-
-  it("与面板同规则夹紧到 100 显示列,capWidth: false 时跟随传入宽度", () => {
-    expect(stringWidth(renderRule({ title: "概览 1/3", width: 200, mode: "boxed" }))).toBe(100);
-    expect(
-      stringWidth(renderRule({ title: "概览 1/3", width: 200, mode: "boxed", capWidth: false })),
-    ).toBe(200);
-  });
-
-  it("嵌字截断复用边框那份优先级:先截标题中段补 …,最后才放弃 meta", () => {
-    const long = "非常长的视角名".repeat(6);
-    const rule = renderRule({ title: `${long} 1/3`, meta: "88 attempts", width: 60, mode: "boxed" });
-    expect(stringWidth(rule)).toBe(60);
-    expect(rule).toContain("…");
-    expect(rule).toContain("88 attempts");
-  });
-
-  it("plain 或窄于 60 列时降为裸标题行,不出现横线字符", () => {
-    expect(renderRule({ title: "概览 1/3", width: 82, mode: "plain" })).toBe("概览 1/3");
-    expect(renderRule({ title: "概览 1/3", width: 40, mode: "boxed" })).toBe("概览 1/3");
-    expect(renderRule({ width: 82, mode: "plain" })).toBe("");
-  });
-});