patina-cli 3.11.0

package/profiles/social.md

@@ -0,0 +1,56 @@
+---
+profile: social
+name: SNS/소셜미디어 프로필
+version: 1.0.0
+scope: 트위터/X, 인스타그램, 스레드, 블루스카이, 카카오스토리, 페이스북
+voice-overrides:
+  first-person: amplify        # 1인칭 적극 사용
+  opinions: amplify             # 의견 강하게
+  rhythm-variation: amplify     # 리듬 변화 극대화
+  humor: amplify                # 유머 적극 허용
+  messiness: amplify            # 불완전 구조, 파편 문장 적극 허용
+  concrete-emotions: amplify    # 구체적 감정 표현 강화
+pattern-overrides:
+  ko:
+    17: suppress                # 이모지 — SNS에서는 표준
+    22: reduce                  # 채움 표현 — 일부 캐주얼 필러 허용
+    14: suppress                # 볼드체 — SNS에서는 비해당 (플랫폼 지원 불일치)
+    21: reduce                  # 아첨 — 약간의 친근한 표현은 허용
+  en:
+    17: suppress                # Emojis — standard in social media
+    22: reduce                  # Filler — some casual filler is natural
+    14: suppress                # Boldface — not relevant for most social platforms
+    21: reduce                  # Sycophantic — some friendly tone allowed
+  zh:
+    17: suppress                # 表情符号 — SNS 표준
+    22: reduce                  # 填充表达 — 캐주얼 필러 허용
+    14: suppress                # 加粗 — 비해당
+  ja:
+    17: suppress                # 絵文字 — SNS 표준
+    22: reduce                  # フィラー — 캐주얼 필러 허용
+    14: suppress                # 太字 — 비해당
+---
+
+# SNS/소셜미디어 프로필
+
+소셜미디어 특유의 캐주얼한 어조를 유지하면서 AI 패턴을 제거한다. 이모지, 구어체, 파편 문장을 허용하되, 여전히 AI 티가 나는 구조적 패턴은 교정한다.
+
+## 범위
+
+트위터/X, 인스타그램, 스레드, 블루스카이, 카카오스토리, 페이스북 포스트. 기업 공식 계정은 `default` 프로필이 더 적합.
+
+## 어조 지침
+
+- **짧게 쓴다.** SNS의 핵심은 간결함. 한두 문장이면 충분할 때가 많다.
+- **구어체가 기본이다.** "~거든", "~잖아", "ㅋㅋ", "ㅠㅠ" 등 자연스러운 SNS 언어 허용.
+- **이모지는 자유롭게.** 교정 대상이 아니다.
+- **의견을 과감하게.** "이거 진짜 별로다", "개꿀팁" — 태도가 뚜렷해야 사람다움.
+- **파편 문장 OK.** "진짜로.", "이게 맞나.", "아 글쎄." — SNS에서는 자연스럽다.
+
+## 적극 교정 대상
+
+- **AI 고빈도 어휘 (#7):** "다양한", "혁신적인" 등은 SNS에서 특히 어색. 구어로 교체.
+- **과도한 중요성 부여 (#1):** SNS에서 "획기적인 성과"는 풍자가 아닌 이상 부적절.
+- **구조적 반복 (#25):** 모든 트윗이 같은 구조면 봇처럼 보인다.
+- **과제와 전망 공식 (#6):** "도전과 기회가 공존" 같은 표현은 SNS에서 극도로 부자연스럽다.
+- **챗봇 표현 (#19):** "도움이 되셨으면 좋겠습니다"는 SNS에서도 여전히 교정 대상.

package/profiles/technical.md

@@ -0,0 +1,53 @@
+---
+profile: technical
+name: 기술 문서/API 문서 프로필
+version: 1.0.0
+scope: 기술 문서, API 문서, README, 가이드, 튜토리얼, 사양서
+voice-overrides:
+  first-person: suppress        # 1인칭 억제
+  opinions: suppress            # 의견 억제, 사실 기반 서술
+  rhythm-variation: normal      # 리듬 변화 유지
+  humor: suppress               # 유머 억제
+  messiness: suppress           # 불완전 구조 억제
+  concrete-emotions: suppress   # 감정 표현 억제
+pattern-overrides:
+  ko:
+    14: suppress                # 볼드체 — 기술 문서에서 키워드/파라미터 볼드 표준
+    15: suppress                # 인라인 헤더 — API 문서의 표준 형식
+    27: reduce                  # 수동태 — 사양서에서 허용
+  en:
+    14: suppress                # Boldface — standard in technical docs for keywords
+    15: suppress                # Inline-header lists — standard API doc format
+    18: suppress                # Curly quotes — actively fix in code/config contexts
+    26: reduce                  # Passive — acceptable in specifications
+  zh:
+    14: suppress                # 加粗 — 기술 문서 표준
+    15: suppress                # 内联标题列表 — API 문서 표준
+    27: reduce                  # 被字句 — 사양서에서 허용
+  ja:
+    14: suppress                # 太字 — 기술 문서 표준
+    15: suppress                # インラインヘッダー — API 문서 표준
+    16: suppress                # 敬語 — 기술 문서에서는 비해당 (である調 기본)
+---
+
+# 기술 문서/API 문서 프로필
+
+기술 문서의 형식적 관행을 존중하면서 AI 패턴을 제거한다. 볼드 키워드, 파라미터 테이블, 인라인 헤더 리스트 등 기술 문서의 표준 요소는 건드리지 않는다.
+
+## 범위
+
+API 문서, README, 가이드, 튜토리얼, 기술 사양서. 기술 블로그 글은 `blog` 프로필이 더 적합.
+
+## 어조 지침
+
+- **명확하고 직접적으로 쓴다.** 기술 문서의 목표는 정확한 정보 전달.
+- **1인칭은 쓰지 않는다.** "Set the variable" (O), "I set the variable" (X).
+- **의견이나 유머는 넣지 않는다.** 사실과 절차만.
+- **일관된 용어를 유지한다.** 같은 개념을 같은 단어로 부른다 (유의어 순환 금지).
+
+## 적극 교정 대상
+
+- **AI 고빈도 어휘 (#7):** "활용하여", "체계적으로" 등 → "사용하여", "순서대로" 등으로 교체.
+- **채움 표현 (#22):** "주목할 만한 점은 ~라는 것이다" → 직접 서술.
+- **과도한 중요성 부여 (#1):** 기술 문서에서 "획기적인 기능"은 부적절. 기능 설명으로 대체.
+- **유의어 순환 (#11):** 기술 문서에서 같은 것을 다른 이름으로 부르면 혼란. 적극 교정.

package/scripts/benchmark-report.mjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+// Generate a publishable benchmark report from the deterministic quality suite.
+//
+// Default behavior reruns tests/quality/benchmark.mjs first so docs/benchmarks/*
+// reflects the current fixture set. Use --no-run to render from an existing
+// tests/quality/results.json file.
+
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+const RESULTS_PATH = resolve(REPO_ROOT, 'tests/quality/results.json');
+const REPORT_DIR = resolve(REPO_ROOT, 'docs/benchmarks');
+const JSON_PATH = resolve(REPORT_DIR, 'latest.json');
+const MARKDOWN_PATH = resolve(REPORT_DIR, 'latest.md');
+
+const runBenchmarkFirst = !process.argv.includes('--no-run');
+const benchmarkCommand = ['node', 'tests/quality/benchmark.mjs', '--quiet'];
+
+function runBenchmark() {
+  const result = spawnSync(process.execPath, ['tests/quality/benchmark.mjs', '--quiet'], {
+    cwd: REPO_ROOT,
+    stdio: 'inherit',
+  });
+  if (result.error) throw result.error;
+  return result.status ?? 1;
+}
+
+function readResults() {
+  try {
+    const results = JSON.parse(readFileSync(RESULTS_PATH, 'utf8'));
+    validateResultsSchema(results);
+    return results;
+  } catch (error) {
+    throw new Error(
+      `Cannot read ${relative(REPO_ROOT, RESULTS_PATH)}. Run npm run benchmark first. ${error.message}`
+    );
+  }
+}
+
+function validateResultsSchema(results) {
+  const missing = [];
+  if (results?.schemaVersion !== 2) missing.push('schemaVersion=2');
+  if (typeof results?.fixtureSchemaVersion !== 'number') missing.push('fixtureSchemaVersion');
+  if (typeof results?.nodeVersion !== 'string') missing.push('nodeVersion');
+  if (typeof results?.overall?.ci_low !== 'number') missing.push('overall.ci_low');
+  if (typeof results?.overall?.ci_high !== 'number') missing.push('overall.ci_high');
+  if (typeof results?.overall?.n !== 'number') missing.push('overall.n');
+  for (const [lang, summary] of Object.entries(results?.perLanguage || {})) {
+    for (const detector of ['burstiness', 'mattr', 'lexicon']) {
+      if (!summary.byDetector?.[detector]) missing.push(`perLanguage.${lang}.byDetector.${detector}`);
+    }
+  }
+  if (missing.length) {
+    throw new Error(`Benchmark results schema is stale or invalid; missing ${missing.join(', ')}. Re-run tests/quality/benchmark.mjs.`);
+  }
+}
+
+function pct(value) {
+  return `${((value ?? 0) * 100).toFixed(1)}%`;
+}
+
+function num(value, digits = 3) {
+  return Number(value ?? 0).toFixed(digits).replace(/\.0+$/, '').replace(/(\.\d*?)0+$/, '$1');
+}
+
+function bool(value) {
+  return value ? 'hot' : 'cold';
+}
+
+function resultMark(value) {
+  return value ? '✓' : '✗';
+}
+
+function cell(value) {
+  return String(value ?? '—').replace(/\|/g, '\\|').replace(/\s+/g, ' ').trim() || '—';
+}
+
+function statusFromResults(results) {
+  return (results.fixtures || []).some((f) => !f.correct) ? 1 : 0;
+}
+
+function languageRows(perLanguage = {}) {
+  return Object.entries(perLanguage)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([lang, s]) =>
+      `| ${lang} | ${s.total} | ${pct(s.accuracy)} | ${pct(s.ci_low)}–${pct(s.ci_high)} | ${pct(s.precision)} | ${pct(s.recall)} | ${num(s.f1, 2)} | ${s.tp} | ${s.fp} | ${s.fn} | ${s.tn} |`
+    );
+}
+
+function detectorRows(perLanguage = {}) {
+  const rows = [];
+  for (const [lang, s] of Object.entries(perLanguage).sort(([a], [b]) => a.localeCompare(b))) {
+    for (const [detector, d] of Object.entries(s.byDetector || {}).sort(([a], [b]) => a.localeCompare(b))) {
+      rows.push(
+        `| ${lang} | ${detector} | ${d.total} | ${pct(d.accuracy)} | ${pct(d.ci_low)}–${pct(d.ci_high)} | ${pct(d.precision)} | ${pct(d.recall)} | ${num(d.f1, 2)} | ${d.tp} | ${d.fp} | ${d.fn} | ${d.tn} |`
+      );
+    }
+  }
+  return rows;
+}
+
+function classRows(fixtures = []) {
+  const counts = new Map();
+  for (const f of fixtures) {
+    const key = `${f.lang}\0${f.class}`;
+    counts.set(key, (counts.get(key) || 0) + 1);
+  }
+  return [...counts.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, count]) => {
+      const [lang, klass] = key.split('\0');
+      return `| ${cell(lang)} | ${cell(klass)} | ${count} |`;
+    });
+}
+
+function sampleSizeSummary(fixtures = []) {
+  return fixtures.reduce((acc, f) => {
+    const lang = f.lang || 'unknown';
+    const klass = f.class || 'unknown';
+    acc[lang] ||= {};
+    acc[lang][klass] = (acc[lang][klass] || 0) + 1;
+    return acc;
+  }, {});
+}
+
+function fixtureRows(fixtures = []) {
+  return fixtures.map((f) => {
+    const hits = cell((f.lexicon_hits || []).slice(0, 4).join(', '));
+    return `| ${cell(f.fixture_id)} | ${cell(f.lang)} | ${cell(f.class)} | ${bool(f.expected_hot)} | ${bool(f.predicted_hot)} | ${resultMark(f.correct)} | ${num(f.cv)} ${cell(f.cv_band)} | ${num(f.mattr)} ${cell(f.mattr_band)} | ${num(f.lexicon_density)} | ${hits} |`;
+  });
+}
+
+function misclassificationSection(fixtures = []) {
+  const wrong = fixtures.filter((f) => !f.correct);
+  if (wrong.length === 0) return 'All fixtures classified correctly.';
+  return [
+    '| fixture | lang | class | expected | predicted | cv | mattr | lexicon density |',
+    '|---|---|---|---|---|---:|---:|---:|',
+    ...wrong.map(
+      (f) =>
+        `| ${f.fixture_id} | ${f.lang} | ${f.class} | ${bool(f.expected_hot)} | ${bool(f.predicted_hot)} | ${num(f.cv)} ${f.cv_band || ''} | ${num(f.mattr)} ${f.mattr_band || ''} | ${num(f.lexicon_density)} |`
+    ),
+  ].join('\n');
+}
+
+function renderMarkdown(results, benchmarkStatus) {
+  const generatedAt = results.generatedAt || new Date().toISOString();
+  const languages = Object.keys(results.perLanguage || {}).sort();
+  const languageCount = languages.length;
+  const languageList = languages.join(', ');
+  const status = benchmarkStatus === 0 ? 'passing' : 'failing';
+  const overall = results.overall || {
+    accuracy: results.overallAccuracy,
+    ci_low: null,
+    ci_high: null,
+    n: results.fixtureCount,
+    confidence_method: 'unavailable',
+  };
+
+  return `# Benchmark Report
+
+This is the latest checked-in report for patina's deterministic suspect-zone benchmark.
+
+> Scope: this benchmark measures whether patina's stylometry layer flags fixture paragraphs as AI-like editing hotspots. It does **not** prove whether a real document was written by a human or by AI.
+
+## Current result
+
+- Status: **${status}**
+- Generated at: ${generatedAt}
+- Node: ${results.nodeVersion}
+- Fixture schema: v${results.fixtureSchemaVersion}
+- Fixtures: ${results.fixtureCount}
+- Languages: ${languageCount} (${languageList})
+- Overall accuracy: **${pct(overall.accuracy)}** [${pct(overall.ci_low)}–${pct(overall.ci_high)}] (n=${overall.n}, ${overall.confidence_method})
+- Source fixtures: \`tests/fixtures/suspect-zones/**\`
+- Regression ranges: \`tests/fixtures/suspect-zones/expected-ranges.json\` (refresh with \`npm run benchmark:ranges\`)
+- Reproduce: \`npm run benchmark:report\`
+- Raw JSON: [latest.json](latest.json)
+- Detector comparison harness: [detector-comparison.md](detector-comparison.md)
+- 2025+ re-baseline plan: [docs/research/2025-rebaseline-plan.md](../research/2025-rebaseline-plan.md)
+
+## Language breakdown
+
+| lang | fixtures | accuracy | 95% CI | precision | recall | f1 | TP | FP | FN | TN |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+${languageRows(results.perLanguage).join('\n')}
+
+## Detector breakdown
+
+| lang | detector | fixtures | accuracy | 95% CI | precision | recall | f1 | TP | FP | FN | TN |
+|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+${detectorRows(results.perLanguage).join('\n')}
+
+## Sample sizes
+
+| lang | class | fixtures |
+|---|---|---:|
+${classRows(results.fixtures).join('\n')}
+
+## Misclassifications
+
+${misclassificationSection(results.fixtures)}
+
+## Fixture log
+
+| fixture | lang | class | expected | predicted | ok | CV band | MATTR band | lexicon/1k | sample lexicon hits |
+|---|---|---|---|---|---:|---:|---:|---:|---|
+${fixtureRows(results.fixtures).join('\n')}
+
+## How to read this
+
+- **Hot** means at least one deterministic signal crossed the benchmark threshold: low burstiness CV, low MATTR, or AI-lexicon density.
+- **Cold** means the fixture did not cross those thresholds.
+- The report is meant for regression tracking and contributor discussion, not for authorship accusation.
+- This deterministic corpus is intentionally small (${results.fixtureCount} fixtures across ${languageList}); do not treat 100% fixture accuracy as generalization to new models, genres, or edited AI text.
+- Confidence intervals use Wilson score intervals for the checked-in fixture set; external threshold sweeps and 2025+ model rebaselines are separate research follow-ups tracked in [2025+ Re-baseline Plan](../research/2025-rebaseline-plan.md).
+- Broader methodology notes live in [AI/Human Metrics Research](../research/ai-human-metrics.md) and [Quality Checks](../../tests/quality/README.md).
+`;
+}
+
+function main() {
+  let benchmarkStatus = 0;
+  if (runBenchmarkFirst) benchmarkStatus = runBenchmark();
+
+  const results = readResults();
+  if (!runBenchmarkFirst) benchmarkStatus = statusFromResults(results);
+
+  const report = {
+    reportVersion: 2,
+    benchmarkCommand: benchmarkCommand.join(' '),
+    benchmarkStatus,
+    note: 'Deterministic suspect-zone benchmark; not an authorship detector.',
+    regressionRanges: 'tests/fixtures/suspect-zones/expected-ranges.json',
+    ...results,
+    sampleSizes: sampleSizeSummary(results.fixtures),
+  };
+
+  mkdirSync(REPORT_DIR, { recursive: true });
+  writeFileSync(JSON_PATH, `${JSON.stringify(report, null, 2)}\n`);
+  writeFileSync(MARKDOWN_PATH, renderMarkdown(results, benchmarkStatus));
+
+  console.log(`Wrote ${relative(REPO_ROOT, MARKDOWN_PATH)}`);
+  console.log(`Wrote ${relative(REPO_ROOT, JSON_PATH)}`);
+
+  if (benchmarkStatus !== 0) process.exitCode = benchmarkStatus;
+}
+
+main();

package/scripts/check-release-metadata.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+
+const pkg = readJson('package.json');
+const version = pkg.version;
+const checks = [];
+
+expect(pkg.private === false, 'package.json private must be false');
+expect(pkg.bin?.patina === 'bin/patina.js', 'package.json bin.patina must point to bin/patina.js');
+expect(pkg.bin?.['patina-score'] === 'scripts/precommit-score.mjs', 'package.json bin.patina-score must point to scripts/precommit-score.mjs');
+expect(existsSync('bin/patina.js'), 'bin/patina.js must exist');
+expect(readVersionField('SKILL.md') === version, 'SKILL.md version must match package.json');
+expect(readVersionField('SKILL-MAX.md') === version, 'SKILL-MAX.md version must match package.json');
+expect(readVersionField('patina-max/SKILL.md') === version, 'patina-max/SKILL.md version must match package.json');
+expect(readVersionField('.patina.default.yaml') === version, '.patina.default.yaml version must match package.json');
+expect(readFileSync('README.md', 'utf8').includes(`version: "${version}"`), 'README.md config example version must match package.json');
+expect(new RegExp(`^## ${escapeRegex(version)} — \\d{4}-\\d{2}-\\d{2}`, 'm').test(readFileSync('CHANGELOG.md', 'utf8')), 'CHANGELOG.md must contain a release heading for package.json version');
+
+const aliasPkg = readJson('packages/patina-humanizer/package.json');
+expect(aliasPkg.name === 'patina-humanizer', 'alias package name must be patina-humanizer');
+expect(aliasPkg.version === version, 'patina-humanizer version must match package.json');
+expect(aliasPkg.dependencies?.['patina-cli'] === version, 'patina-humanizer must depend on exact patina-cli version');
+expect(aliasPkg.bin?.['patina-humanizer'] === 'bin/patina-humanizer.js', 'patina-humanizer bin must point to bin/patina-humanizer.js');
+expect(existsSync('packages/patina-humanizer/bin/patina-humanizer.js'), 'patina-humanizer bin file must exist');
+
+if (checks.length) {
+  console.error(checks.map((msg) => `- ${msg}`).join('\n'));
+  process.exit(1);
+}
+console.log(`Release metadata OK for ${version}`);
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function readVersionField(path) {
+  const text = readFileSync(path, 'utf8');
+  const match = text.match(/^version:\s*["']?([^"'\n]+)["']?/m);
+  return match?.[1]?.trim();
+}
+
+function expect(condition, message) {
+  if (!condition) checks.push(message);
+}
+
+function escapeRegex(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/scripts/detector-comparison.mjs

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+// Offline detector-comparison harness for the suspect-zone benchmark.
+//
+// Default mode compares Patina's deterministic in-tree analyzer against the
+// checked-in fixture labels. Pass --input <manual-results.json> to merge scores
+// copied manually from third-party tools. The script never scrapes websites,
+// never sends text to external services, and never reads secrets.
+
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+const RESULTS_PATH = resolve(REPO_ROOT, 'tests/quality/results.json');
+const REPORT_DIR = resolve(REPO_ROOT, 'docs/benchmarks');
+const JSON_PATH = resolve(REPORT_DIR, 'detector-comparison.json');
+const MARKDOWN_PATH = resolve(REPORT_DIR, 'detector-comparison.md');
+
+const args = parseArgs(process.argv.slice(2));
+
+function parseArgs(argv) {
+  const out = { runBenchmark: true, input: null };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--no-run') out.runBenchmark = false;
+    else if (arg === '--input') out.input = argv[++i];
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+  return out;
+}
+
+function runBenchmark() {
+  const result = spawnSync(process.execPath, ['tests/quality/benchmark.mjs', '--quiet'], {
+    cwd: REPO_ROOT,
+    stdio: 'inherit',
+  });
+  if (result.error) throw result.error;
+  if ((result.status ?? 1) !== 0) process.exit(result.status ?? 1);
+}
+
+function readBenchmarkResults() {
+  const results = JSON.parse(readFileSync(RESULTS_PATH, 'utf8'));
+  if (results?.schemaVersion !== 2 || !Array.isArray(results?.fixtures)) {
+    throw new Error(`${relative(REPO_ROOT, RESULTS_PATH)} is not a benchmark schema v2 result`);
+  }
+  return results;
+}
+
+function normalizeLabel(row) {
+  if (typeof row.predicted_hot === 'boolean') return row.predicted_hot;
+  if (typeof row.label === 'string') {
+    const label = row.label.toLowerCase();
+    if (['hot', 'ai', 'ai-like', 'suspect', 'generated'].includes(label)) return true;
+    if (['cold', 'human', 'natural', 'not-ai', 'clean'].includes(label)) return false;
+  }
+  throw new Error(`Manual result for ${row.fixture_id}/${row.detector} needs predicted_hot boolean or label hot|cold`);
+}
+
+function readManualInput(path) {
+  if (!path) return null;
+  const abs = resolve(REPO_ROOT, path);
+  if (!existsSync(abs)) throw new Error(`Manual detector input not found: ${path}`);
+  const manual = JSON.parse(readFileSync(abs, 'utf8'));
+  if (manual?.schemaVersion !== 1) throw new Error(`${path}: expected schemaVersion=1`);
+  if (!Array.isArray(manual.detectors)) throw new Error(`${path}: detectors must be an array`);
+  if (!Array.isArray(manual.results)) throw new Error(`${path}: results must be an array`);
+  return { path: abs, ...manual };
+}
+
+function emptyMetrics() {
+  return { tp: 0, fp: 0, fn: 0, tn: 0, total: 0 };
+}
+
+function updateMetrics(m, predicted, expected) {
+  m.total++;
+  if (predicted && expected) m.tp++;
+  else if (predicted && !expected) m.fp++;
+  else if (!predicted && expected) m.fn++;
+  else m.tn++;
+}
+
+function summarize(m, fixtureCount) {
+  const precision = m.tp + m.fp ? m.tp / (m.tp + m.fp) : 0;
+  const recall = m.tp + m.fn ? m.tp / (m.tp + m.fn) : 0;
+  const accuracy = m.total ? (m.tp + m.tn) / m.total : 0;
+  const f1 = precision + recall ? (2 * precision * recall) / (precision + recall) : 0;
+  return {
+    ...m,
+    fixtureCount,
+    coverage: fixtureCount ? round(m.total / fixtureCount) : 0,
+    accuracy: round(accuracy),
+    precision: round(precision),
+    recall: round(recall),
+    f1: round(f1),
+  };
+}
+
+function round(n, digits = 3) {
+  return Math.round(n * 10 ** digits) / 10 ** digits;
+}
+
+function pct(n) {
+  return `${((n ?? 0) * 100).toFixed(1)}%`;
+}
+
+function cell(value) {
+  return String(value ?? '—').replace(/\|/g, '\\|').replace(/\s+/g, ' ').trim() || '—';
+}
+
+function bool(value) {
+  return value ? 'hot' : 'cold';
+}
+
+function builtInDetector(results) {
+  return {
+    detectors: [
+      {
+        id: 'patina-deterministic',
+        name: 'Patina deterministic suspect-zone analyzer',
+        kind: 'in-tree',
+        mode: 'offline',
+        threshold: 'burstiness low OR MATTR low OR lexicon density > threshold',
+      },
+    ],
+    rows: results.fixtures.map((fixture) => ({
+      fixture_id: fixture.fixture_id,
+      detector: 'patina-deterministic',
+      predicted_hot: fixture.predicted_hot,
+      score: fixture.predicted_hot ? 1 : 0,
+      source: 'tests/quality/benchmark.mjs',
+    })),
+  };
+}
+
+function mergeRows(results, manual) {
+  const fixtureById = Object.fromEntries(results.fixtures.map((f) => [f.fixture_id, f]));
+  const builtIn = builtInDetector(results);
+  const detectors = [...builtIn.detectors];
+  const rows = [...builtIn.rows];
+  if (manual) {
+    const detectorIds = new Set(detectors.map((d) => d.id));
+    for (const detector of manual.detectors) {
+      if (!detector?.id) throw new Error('Manual detector missing id');
+      if (!detectorIds.has(detector.id)) {
+        detectors.push({ ...detector, kind: detector.kind || 'manual-third-party', mode: 'manual-offline' });
+        detectorIds.add(detector.id);
+      }
+    }
+    for (const row of manual.results) {
+      if (!fixtureById[row.fixture_id]) throw new Error(`Unknown fixture_id in manual input: ${row.fixture_id}`);
+      rows.push({
+        ...row,
+        predicted_hot: normalizeLabel(row),
+        source: manual.runId || relative(REPO_ROOT, manual.path),
+      });
+    }
+  }
+  return { detectors, rows };
+}
+
+function computeSummaries(results, detectors, rows) {
+  const fixtureById = Object.fromEntries(results.fixtures.map((f) => [f.fixture_id, f]));
+  const byDetector = {};
+  for (const detector of detectors) byDetector[detector.id] = emptyMetrics();
+  const expandedRows = [];
+  for (const row of rows) {
+    const fixture = fixtureById[row.fixture_id];
+    if (!fixture) continue;
+    const expected = fixture.expected_hot;
+    const predicted = Boolean(row.predicted_hot);
+    byDetector[row.detector] ||= emptyMetrics();
+    updateMetrics(byDetector[row.detector], predicted, expected);
+    expandedRows.push({
+      fixture_id: row.fixture_id,
+      lang: fixture.lang,
+      class: fixture.class,
+      detector: row.detector,
+      expected_hot: expected,
+      predicted_hot: predicted,
+      correct: predicted === expected,
+      score: typeof row.score === 'number' ? row.score : null,
+      source: row.source || null,
+      notes: row.notes || null,
+    });
+  }
+  return {
+    summaries: Object.fromEntries(
+      Object.entries(byDetector).map(([id, metrics]) => [id, summarize(metrics, results.fixtureCount)])
+    ),
+    rows: expandedRows,
+  };
+}
+
+function detectorRows(detectors, summaries) {
+  return detectors.map((d) => {
+    const s = summaries[d.id] || summarize(emptyMetrics(), 0);
+    return `| ${cell(d.id)} | ${cell(d.name)} | ${cell(d.kind)} | ${s.total}/${s.fixtureCount} | ${pct(s.coverage)} | ${pct(s.accuracy)} | ${pct(s.precision)} | ${pct(s.recall)} | ${s.tp} | ${s.fp} | ${s.fn} | ${s.tn} |`;
+  });
+}
+
+function fixtureRows(rows) {
+  return rows.map((r) => `| ${cell(r.fixture_id)} | ${cell(r.lang)} | ${cell(r.class)} | ${cell(r.detector)} | ${bool(r.expected_hot)} | ${bool(r.predicted_hot)} | ${r.correct ? '✓' : '✗'} | ${cell(r.score)} | ${cell(r.source)} |`);
+}
+
+function renderMarkdown(report) {
+  return `# Detector Comparison Harness
+
+This report is generated offline from the checked-in suspect-zone fixtures. It is a comparison harness, not a vendor ranking claim.
+
+## Current run
+
+- Generated at: ${report.generatedAt}
+- Fixture source: \`tests/fixtures/suspect-zones/**\`
+- Fixture count: ${report.fixtureCount}
+- Manual third-party input: ${report.manualInput ? `\`${report.manualInput}\`` : 'none'}
+- Reproduce built-in comparison: \`npm run benchmark:compare\`
+- Merge manual scores: \`node scripts/detector-comparison.mjs --input tests/quality/detectors.manual.example.json\`
+
+## Summary
+
+| detector | name | kind | covered | coverage | accuracy | precision | recall | TP | FP | FN | TN |
+|---|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+${detectorRows(report.detectors, report.summaries).join('\n')}
+
+## Fixture-level rows
+
+| fixture | lang | class | detector | expected | predicted | ok | score | source |
+|---|---|---|---|---|---|---:|---:|---|
+${fixtureRows(report.rows).join('\n')}
+
+## Manual third-party protocol
+
+1. Use only redistributable fixture text from \`tests/fixtures/suspect-zones/**\`.
+2. Paste text into a third-party detector manually, respecting that service's terms.
+3. Record only fixture id, detector id, date/version, score, and hot/cold label. Do not check private text into the repo.
+4. Run this script with \`--input <json>\`. The script does not scrape sites or call external APIs.
+5. Treat results as time-stamped evidence, not a universal claim about authorship detection.
+`;
+}
+
+function main() {
+  if (args.runBenchmark) runBenchmark();
+  const results = readBenchmarkResults();
+  const manual = readManualInput(args.input);
+  const { detectors, rows } = mergeRows(results, manual);
+  const computed = computeSummaries(results, detectors, rows);
+  const report = {
+    reportVersion: 1,
+    generatedAt: new Date().toISOString(),
+    fixtureCount: results.fixtureCount,
+    benchmarkGeneratedAt: results.generatedAt,
+    note: 'Offline comparison harness. Built-in Patina row uses deterministic suspect-zone analyzer; third-party rows are manual opt-in only.',
+    manualInput: manual ? relative(REPO_ROOT, manual.path) : null,
+    detectors,
+    summaries: computed.summaries,
+    rows: computed.rows,
+  };
+  mkdirSync(REPORT_DIR, { recursive: true });
+  writeFileSync(JSON_PATH, `${JSON.stringify(report, null, 2)}\n`);
+  writeFileSync(MARKDOWN_PATH, renderMarkdown(report));
+  console.log(`Wrote ${relative(REPO_ROOT, MARKDOWN_PATH)}`);
+  console.log(`Wrote ${relative(REPO_ROOT, JSON_PATH)}`);
+}
+
+main();