@dommaker/harness 1.7.0 → 1.8.0

package/src/cli/commands/__tests__/init.test.ts

@@ -50,12 +50,6 @@ jest.mock('chalk', () => ({
   bold: jest.fn((str: string) => str),
 }));
 
-// Mock validate module
-jest.mock('../validate', () => ({
-  createExampleCheckpoint: jest.fn(),
-  createExampleResolutions: jest.fn(),
-}));
-
 const mockFs = fs as jest.Mocked<typeof fs>;
 
 // Use explicit projectPath to avoid CI path mismatch
@@ -193,6 +187,59 @@ describe('init command', () => {
         expect(io2.outText()).toContain(line);
       }
     });
+
+    it('应该创建 pre-push hook（第 9 站点，#144）并带可执行位', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockFs.chmod.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/.git`);
+      existingFiles.add(`${PROJECT}/.git/hooks`);
+
+      await init({ preset: 'standard', projectPath: PROJECT }, io);
+
+      expect(io.outText()).toContain('已创建 .git/hooks/pre-push');
+      expect(mockFs.chmod).toHaveBeenCalledWith(
+        `${PROJECT}/.git/hooks/pre-push`,
+        0o755,
+      );
+    });
+
+    it('pre-push 落盘正文 = 整仓全量兜底：check 不带 --staged + validate，scoped 包名（#144/#36）', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/.git`);
+      existingFiles.add(`${PROJECT}/.git/hooks`);
+
+      await init({ preset: 'standard', projectPath: PROJECT }, io);
+      const call = mockFs.writeFile.mock.calls.find((c: any[]) => String(c[0]).includes('pre-push'));
+      expect(call).toBeDefined();
+      const body = String(call![1]);
+
+      expect(body).toContain('npx @dommaker/harness check');
+      expect(body).not.toContain('check --staged');
+      expect(body).toContain('npx @dommaker/harness validate');
+      expect(body).not.toMatch(/npx harness /);
+      // 任一失败即非零退出挡住 push
+      expect(body.match(/\n {2}exit 1\n/g)?.length).toBe(2);
+    });
+
+    it('pre-push 已存在时告知并打印同源片段（#144 + #103）', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/.git`);
+      existingFiles.add(`${PROJECT}/.git/hooks`);
+      existingFiles.add(`${PROJECT}/.git/hooks/pre-push`);
+
+      await init({ preset: 'standard', projectPath: PROJECT }, io);
+      expect(io.outText()).toContain('pre-push 已存在');
+
+      const written = mockFs.writeFile.mock.calls.find((c: any[]) => String(c[0]).includes('pre-push'));
+      expect(written).toBeUndefined();
+
+      const io2 = captureIO();
+      await init({ preset: 'standard', printSnippets: true }, io2);
+      expect(io2.outText()).toContain('echo "🔍 Running harness pre-push checks (whole repo)..."');
+    });
   });
 
   describe('GitHub Actions', () => {
@@ -221,6 +268,35 @@ describe('init command', () => {
     });
   });
 
+  describe('跳过旗帜 → plan 里没有这些站点（scaffold 不持有覆盖/跳过策略）', () => {
+    it('--no-git-hooks 与 --no-github-actions 不落任何 hook / workflow', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/.git`);
+      existingFiles.add(`${PROJECT}/.git/hooks`);
+
+      await init({ preset: 'standard', gitHooks: false, githubActions: false, projectPath: PROJECT }, io);
+      const writes = mockFs.writeFile.mock.calls.map((c: unknown[]) => String(c[0]));
+      expect(writes.some((w: string) => w.includes('pre-commit'))).toBe(false);
+      expect(writes.some((w: string) => w.includes('pre-push'))).toBe(false);
+      expect(writes.some((w: string) => w.includes('.github/workflows'))).toBe(false);
+      expect(io.outText()).not.toContain('未检测到 Git 仓库');
+    });
+
+    it('未带跳过旗帜时两站点照常进 plan', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/.git`);
+      existingFiles.add(`${PROJECT}/.git/hooks`);
+
+      await init({ preset: 'standard', projectPath: PROJECT }, io);
+      const writes = mockFs.writeFile.mock.calls.map((c: unknown[]) => String(c[0]));
+      expect(writes.some((w: string) => w.includes('pre-commit'))).toBe(true);
+      expect(writes.some((w: string) => w.includes('pre-push'))).toBe(true);
+      expect(writes.some((w: string) => w.includes('harness-check.yml'))).toBe(true);
+    });
+  });
+
   describe('CAPABILITIES.md', () => {
     it('init 不应创建 CAPABILITIES.md（由 sync-docs 管理）', async () => {
       mockFs.mkdir.mockResolvedValue(undefined);

package/src/cli/commands/__tests__/knowledge-audit-threshold.test.ts

@@ -0,0 +1,146 @@
+/**
+ * knowledge audit --threshold 的装配面测试（harness#152）
+ *
+ * 证的是「数值旗帜从 commander 到判定」这一程，不是投影：
+ * ① 声明与运行时一致——`--threshold <n>` 恒给字符串，`knowledge.ts` 不得再靠 `as any` 躲编译期；
+ * ② 脏输入 fail-loud——非零判定 + stderr 提示，不出报告、不写盘（原先 NaN 静默关掉短内容规则）；
+ * ③ 缺省与显式 '50' 逐字同果、显式 '0' 不被当「未传」兜掉。
+ * 用真 KnowledgeAudit：要证的是阈值落进判定，而非参数传到（那是 mock 入参断言的假绿）。
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+// Mock chalk（断言看文本，不看 ANSI）
+jest.mock('chalk', () => ({
+  blue: jest.fn((s: string) => s),
+  bold: jest.fn((s: string) => s),
+  green: jest.fn((s: string) => s),
+  yellow: jest.fn((s: string) => s),
+  red: jest.fn((s: string) => s),
+  gray: jest.fn((s: string) => s),
+  cyan: jest.fn((s: string) => s),
+}));
+
+import { captureIO, lastJsonOutput, type CapturingIO } from '../../command-contract';
+import { FileKnowledgeStore } from '../../../knowledge/store';
+import type { KnowledgeEntry } from '../../../knowledge/types';
+import { knowledgeAudit } from '../knowledge';
+
+const SRC_FILE = path.join(__dirname, '..', 'knowledge.ts');
+const DAY = 24 * 60 * 60 * 1000;
+const daysAgo = (n: number): string => new Date(Date.now() - n * DAY).toISOString();
+
+/** 三条探针条目：30 / 25 字符在缺省阈值 50 下都算短，80 字符怎么都不算 */
+const EDGE_30 = 'GUI-101';
+const SHORT_25 = 'GUI-102';
+const LONG_80 = 'GUI-103';
+
+function makeEntry(id: string, content: string): KnowledgeEntry {
+  return {
+    id,
+    type: 'guideline',
+    title: `阈值探针 ${id}`,
+    content,
+    maturity: 'draft',
+    layer: 'project',
+    created: daysAgo(3),
+    lastReferenced: daysAgo(1),
+    contributors: [],
+    projects: [],
+    tags: [],
+    applicablePhases: [],
+    sourceReferences: [],
+    referencedBy: [],
+    executionResults: [],
+    consumptionMode: 'reference',
+    origin: 'agent',
+  };
+}
+
+function fixture(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-k152-'));
+  const store = new FileKnowledgeStore({ baseDir: dir });
+  store.save(makeEntry(EDGE_30, 'x'.repeat(30)));
+  store.save(makeEntry(SHORT_25, 'y'.repeat(25)));
+  store.save(makeEntry(LONG_80, 'z'.repeat(80)));
+  return dir;
+}
+
+let io: CapturingIO;
+let dir: string;
+
+beforeEach(() => {
+  io = captureIO();
+  dir = fixture();
+});
+
+/** 走 --json 面取短内容命中的条目 id（判定结果的正本面） */
+async function shortContentIds(threshold?: string): Promise<string[]> {
+  const probe = captureIO();
+  const result = await knowledgeAudit({ dir, json: true, threshold }, probe);
+  expect(result.kind).toBe('ok');
+  const report = lastJsonOutput<{ issues: { rule: string; entryId: string }[] }>(probe);
+  return report.issues.filter(i => i.rule === 'short-content').map(i => i.entryId).sort();
+}
+
+describe('knowledge audit --threshold：阈值真的进判定', () => {
+  it('未传 = 缺省 50，与显式 "50" 逐字同果', async () => {
+    expect(await shortContentIds(undefined)).toEqual([EDGE_30, SHORT_25].sort());
+    expect(await shortContentIds('50')).toEqual([EDGE_30, SHORT_25].sort());
+  });
+
+  it('"30" 生效：恰好 30 字符的条目退出短内容判定，detail 打的是阈值 30', async () => {
+    const result = await knowledgeAudit({ dir, json: true, threshold: '30' }, io);
+    expect(result.kind).toBe('ok');
+    const report = lastJsonOutput<{ issues: { rule: string; entryId: string; detail: string }[] }>(io);
+    const hits = report.issues.filter(i => i.rule === 'short-content');
+    expect(hits.map(i => i.entryId)).toEqual([SHORT_25]);
+    expect(hits[0].detail).toContain('阈值 30');
+  });
+
+  it('显式 "0" 不被当「未传」兜掉：按 0 判定，一条不报（兜掉则回 50、报两条）', async () => {
+    expect(await shortContentIds('0')).toEqual([]);
+  });
+
+  it('阈值随入参移动：40 两条都算短，29 只剩 25 字符那条', async () => {
+    expect(await shortContentIds('40')).toEqual([EDGE_30, SHORT_25].sort());
+    expect(await shortContentIds('29')).toEqual([SHORT_25]);
+  });
+});
+
+describe('knowledge audit --threshold：脏输入 fail-loud（不再 NaN 穿透）', () => {
+  const DIRTY = ['abc', '30abc', '1e2', '0.7', '-5', '', ' ', 'NaN', 'Infinity', '0x10'];
+
+  it.each(DIRTY.map(v => [v]))('--threshold %o → usage-error + stderr 提示，stdout 零字节', async (raw) => {
+    const result = await knowledgeAudit({ dir, json: true, threshold: raw }, io);
+    expect(result).toEqual({ kind: 'usage-error', reason: expect.stringContaining('--threshold') });
+    expect(io.outText()).toBe('');
+    expect(io.errText()).toContain('阈值');
+    if (raw.trim() !== '') expect(io.errText()).toContain(raw);
+  });
+
+  it('人读面同样不产出报告，且不落「阈值 NaN」这种自证异常的行', async () => {
+    const result = await knowledgeAudit({ dir, threshold: 'abc' }, io);
+    expect(result.kind).toBe('usage-error');
+    expect(io.outText()).toBe('');
+    expect(io.outText()).not.toContain('阈值 NaN');
+  });
+
+  it('脏值不写盘：审计后的索引重建随之不发生（人读路径的既有副作用）', async () => {
+    const before = fs.readdirSync(dir).sort();
+    await knowledgeAudit({ dir, threshold: 'abc' }, io);
+    expect(fs.readdirSync(dir).sort()).toEqual(before);
+  });
+});
+
+describe('knowledge audit --threshold：声明与运行时一致', () => {
+  it('knowledge.ts 零 as any（断言不得替编译器记住旗帜的实际形状）', () => {
+    const offenders = fs.readFileSync(SRC_FILE, 'utf-8')
+      .split('\n')
+      .map((line, i) => ({ line: i + 1, text: line }))
+      .filter(({ text }) => text.includes('as any'));
+    expect(offenders).toEqual([]);
+  });
+});

package/src/cli/commands/__tests__/knowledge-flywheel-consistency.test.ts

@@ -77,7 +77,7 @@ describe('飞轮指标三处同源', () => {
     const projectRoot = setupKnowledgeBase();
     const baseDir = path.join(projectRoot, '.harness', 'knowledge');
 
-    const report = new KnowledgeAudit({ baseDir }).run();
+    const report = new KnowledgeAudit(new FileKnowledgeStore({ baseDir })).run();
     const auditDetails = report.dimensions.flywheel.details;
     await knowledgeStats({ projectPath: projectRoot, json: true }, io);
     const statsFlywheel = lastJsonOutput<any>(io).flywheel;

package/src/cli/commands/__tests__/knowledge-tone-mapping.test.ts

@@ -0,0 +1,244 @@
+/**
+ * tone 映射冻结闸（harness#151）
+ *
+ * #133 的人读侧冻成「identity chalk 之下的逐行文本基线」（`knowledge-view.test.ts:20-21`，
+ * 注释写明「人读断言看的是文本，不看 ANSI」）。代价是渲染类映射里唯一没被钉住的维度就是
+ * **颜色本身**：`grep -rn "toneForMaturity\|TONE_STYLES" src/cli/commands/__tests__` 零命中，
+ * 于是把 `toneForMaturity('verified')` 改回 `'warn'`（#133 有意偏离③ 的回退）、或把
+ * `TONE_STYLES.accent` 换成 `chalk.yellow`，全仓零红。本文件把那两张表逐格钉住，且不经 identity mock：
+ *
+ * 1. **输入值 → tone**：`toneForMaturity` / `toneForSeverity` / `toneForScore` 每个键一格。
+ * 2. **tone → chalk 样式键**：`TONE_STYLES` 每个档位一格。chalk 替身按样式键给文本加标签，
+ *    断言走 `renderDisplayModel` / `announce` 的真实渲染链（`{cells:[{tone}]}` → 上色），
+ *    不是只读表——表读得到、链断了也算漏。
+ * 3. **表键集合穷尽**：本文件的登记表与源码里的 `DisplayTone` 联合、`TONE_STYLES` 字面量
+ *    逐字对撞。新增档位不登记即红（编译期 `Record<…, …>` 与运行期集合对撞双钉）。
+ *
+ * 生产侧零改动：`TONE_STYLES` 保持模块内私有——本闸要钉的是它的行为（经渲染链）与它的
+ * 声明形状（源码对撞），不是它的可访问性。导出它会动 `knowledge-view.ts` 的公开面。
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// chalk 替身：每个样式键把文本包成 "<key>文本</key>"，「这一格走了哪个样式」由此成为可断言的文本。
+// 与 knowledge-view.test.ts 的 identity mock 相反——那份为的是读文案，这份为的是读颜色。
+jest.mock('chalk', () => {
+  const tag = (key: string) => (text: string): string => `<${key}>${String(text)}</${key}>`;
+  return {
+    blue: tag('blue'),
+    bold: tag('bold'),
+    green: tag('green'),
+    yellow: tag('yellow'),
+    red: tag('red'),
+    gray: tag('gray'),
+    cyan: tag('cyan'),
+  };
+});
+
+import { captureIO } from '../../command-contract';
+import {
+  announce, renderDisplayModel,
+  toneForMaturity, toneForScore, toneForSeverity,
+  type DisplayCell, type DisplayModel, type DisplayTone, type SeverityName,
+} from '../knowledge-view';
+import type { MaturityLevel } from '../../../knowledge/types';
+
+const VIEW_SOURCE = fs.readFileSync(path.join(__dirname, '..', 'knowledge-view.ts'), 'utf-8');
+
+const wrap = (style: string, text: string): string => `<${style}>${text}</${style}>`;
+
+/** 把若干格塞进单 section 单 row，走真实渲染链 */
+function renderCells(...cells: DisplayCell[]): string[] {
+  const model: DisplayModel = { sections: [{ rows: [{ cells }] }] };
+  const io = captureIO();
+  renderDisplayModel(io, model);
+  return io.outLines();
+}
+
+function renderSectionTitle(title: string): string[] {
+  const io = captureIO();
+  renderDisplayModel(io, { sections: [{ title, rows: [] }] });
+  return io.outLines();
+}
+
+// ========================================
+// 登记表 1：tone → chalk 样式键（源码 TONE_STYLES 的测试侧镜像）
+// ========================================
+
+/**
+ * 缺键即编译期红（`Record<DisplayTone, …>` 要求全键），另有与源码字面量的运行期对撞闸。
+ * 这张表是人读面颜色语义的唯一登记处：改色要在源码改一笔、这里改一笔，diff 即评审材料。
+ */
+const TONE_TO_STYLE: Record<DisplayTone, string> = {
+  heading: 'blue',
+  accent: 'cyan',
+  emph: 'bold',
+  muted: 'gray',
+  ok: 'green',
+  warn: 'yellow',
+  error: 'red',
+};
+
+const TONE_KEYS = Object.keys(TONE_TO_STYLE) as DisplayTone[];
+
+/** 源码里 `export type DisplayTone = 'a' | 'b' | …` 的成员清单 */
+function declaredTones(): string[] {
+  const decl = /export type DisplayTone =([^;]+);/.exec(VIEW_SOURCE);
+  if (!decl) {
+    throw new Error('源码里找不到 DisplayTone 声明——本闸的穷尽判据随之失效，去看一眼 knowledge-view.ts');
+  }
+  return [...decl[1].matchAll(/'([^']+)'/g)].map(m => m[1]);
+}
+
+/** 源码里 `TONE_STYLES` 字面量的 `{ tone: chalk.<style> }` 条目 */
+function declaredToneStyles(): Array<{ tone: string; style: string }> {
+  const start = VIEW_SOURCE.indexOf('const TONE_STYLES');
+  if (start < 0) {
+    throw new Error('源码里找不到 TONE_STYLES——上色单表被搬走或改名，本闸需要跟着搬家');
+  }
+  const end = VIEW_SOURCE.indexOf('\n};', start);
+  const entries = [...VIEW_SOURCE.slice(start, end).matchAll(/^\s*(\w+):\s*chalk\.(\w+),$/gm)]
+    .map(m => ({ tone: m[1], style: m[2] }));
+  if (entries.length === 0) throw new Error('TONE_STYLES 里解析不出任何条目——正则与源码形状脱节');
+  return entries;
+}
+
+// ========================================
+// 登记表 2：输入值 → tone（三张映射表的测试侧镜像）
+// ========================================
+
+/** 成熟度→角色：Record 全键，`MaturityLevel` 新增成员不登记即编译期红 */
+const MATURITY_TO_TONE: Record<MaturityLevel, DisplayTone> = {
+  draft: 'warn',
+  verified: 'accent', // #133 有意偏离③：stats 人读面由此格决定是青不是黄
+  proven: 'ok',
+  archived: 'muted',
+  active: 'warn',
+  deprecated: 'warn',
+};
+
+/** severity→角色：审计条目的 critical/high/medium/low 与 health 问题的 error/warn/info 共用一张表 */
+const SEVERITY_TO_TONE: Record<SeverityName, DisplayTone> = {
+  critical: 'error',
+  high: 'warn',
+  medium: 'muted',
+  low: 'muted',
+  error: 'error',
+  warn: 'warn',
+  info: 'muted',
+};
+
+/** 0-100 分的档位边界：≥80 / ≥60 / 其余 */
+const SCORE_TO_TONE: Array<{ score: number; tone: DisplayTone }> = [
+  { score: 100, tone: 'ok' },
+  { score: 80, tone: 'ok' },
+  { score: 79, tone: 'warn' },
+  { score: 60, tone: 'warn' },
+  { score: 59, tone: 'error' },
+  { score: 0, tone: 'error' },
+];
+
+describe('输入值 → tone：三张映射逐格冻结', () => {
+  for (const [level, tone] of Object.entries(MATURITY_TO_TONE)) {
+    it(`toneForMaturity('${level}') = '${tone}'`, () => {
+      expect(toneForMaturity(level as MaturityLevel)).toBe(tone);
+    });
+  }
+
+  for (const [severity, tone] of Object.entries(SEVERITY_TO_TONE)) {
+    it(`toneForSeverity('${severity}') = '${tone}'`, () => {
+      expect(toneForSeverity(severity as SeverityName)).toBe(tone);
+    });
+  }
+
+  for (const { score, tone } of SCORE_TO_TONE) {
+    it(`toneForScore(${score}) = '${tone}'`, () => {
+      expect(toneForScore(score)).toBe(tone);
+    });
+  }
+
+  it('三张映射的输出恒在样式表键集内（不会映射出一个没人上色的 tone）', () => {
+    const produced: DisplayTone[] = [
+      ...Object.keys(MATURITY_TO_TONE).map(l => toneForMaturity(l as MaturityLevel)),
+      ...Object.keys(SEVERITY_TO_TONE).map(s => toneForSeverity(s as SeverityName)),
+      ...SCORE_TO_TONE.map(({ score }) => toneForScore(score)),
+    ];
+    for (const tone of produced) {
+      expect(TONE_TO_STYLE[tone]).toEqual(expect.any(String));
+    }
+  });
+});
+
+describe('tone → chalk 样式键：TONE_STYLES 逐格冻结（经真实渲染链）', () => {
+  for (const tone of TONE_KEYS) {
+    it(`${tone} 渲染走 chalk.${TONE_TO_STYLE[tone]}`, () => {
+      expect(renderCells({ label: 'X', tone })).toEqual([wrap(TONE_TO_STYLE[tone], 'X')]);
+    });
+  }
+
+  it('未声明 tone 的格不上色：渲染链不套任何样式', () => {
+    expect(renderCells({ label: 'plain' })).toEqual(['plain']);
+  });
+
+  it('section 标题恒走 emph（tone 由渲染器决定，不经格）', () => {
+    expect(renderSectionTitle('  按成熟度:')).toEqual([wrap('bold', '  按成熟度:')]);
+  });
+
+  it('announce 缺省走 heading、显式 tone 照表，--json 下静默', () => {
+    const headingIo = captureIO();
+    announce(headingIo, false, '📊 取数中');
+    expect(headingIo.outLines()).toEqual([wrap('blue', '📊 取数中')]);
+
+    const warnIo = captureIO();
+    announce(warnIo, false, '⚠ 降级', 'warn');
+    expect(warnIo.outLines()).toEqual([wrap('yellow', '⚠ 降级')]);
+
+    const jsonIo = captureIO();
+    announce(jsonIo, true, '📊 取数中');
+    expect(jsonIo.outText()).toBe('');
+  });
+
+  it('表键集合穷尽：登记表 = 源码 DisplayTone 联合 = TONE_STYLES 字面量键', () => {
+    expect(TONE_KEYS.slice().sort()).toEqual(declaredTones().sort());
+    expect(declaredToneStyles().map(e => e.tone).sort()).toEqual(TONE_KEYS.slice().sort());
+  });
+
+  it('逐格对撞：源码 TONE_STYLES 的样式键 = 登记表（源码改一格即红）', () => {
+    for (const { tone, style } of declaredToneStyles()) {
+      expect(TONE_TO_STYLE[tone as DisplayTone]).toBe(style);
+    }
+  });
+});
+
+/**
+ * 整条链（#133 偏离③ 的回退就是沿这条链发生的）：输入值 → toneForXxx → 格的 tone → 渲染上色。
+ * 只钉前两张表也能抓到回退，这条钉的是「命令侧真拿它去渲染」这个用法本身。
+ */
+describe('两表串成一条链：输入值经映射后渲染出的样式 = 样式键表的落点', () => {
+  for (const [level, tone] of Object.entries(MATURITY_TO_TONE)) {
+    it(`成熟度 ${level} 的人读格渲染成 chalk.${TONE_TO_STYLE[tone]}`, () => {
+      const text = `  [${level}]`;
+      expect(renderCells({ label: text, tone: toneForMaturity(level as MaturityLevel) }))
+        .toEqual([wrap(TONE_TO_STYLE[tone], text)]);
+    });
+  }
+
+  for (const { score, tone } of SCORE_TO_TONE) {
+    it(`健康分 ${score} 的人读格渲染成 chalk.${TONE_TO_STYLE[tone]}`, () => {
+      const text = `  健康分: ${score}/100`;
+      expect(renderCells({ label: text, tone: toneForScore(score) }))
+        .toEqual([wrap(TONE_TO_STYLE[tone], text)]);
+    });
+  }
+
+  it('一格多 tone：同排相邻格各自上色，互不吞并', () => {
+    expect(renderCells(
+      { label: '  [verified]', tone: toneForMaturity('verified') },
+      { label: ' | ', tone: 'muted' },
+      { label: '条目 K-002', tone: 'emph' },
+    )).toEqual([
+      `${wrap('cyan', '  [verified]')}${wrap('gray', ' | ')}${wrap('bold', '条目 K-002')}`,
+    ]);
+  });
+});