chaffjs 0.19.0 → 0.20.0

package/src/facts/table-facts.ts

@@ -0,0 +1,71 @@
+import type { Span } from "../plugin.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { TABLE_RULE } from "../structure/runs.ts";
+import { CELL_SEPARATOR } from "../structure/bare-numbers.ts";
+import type { FactValue } from "./fact-values.ts";
+import type { Fact } from "./labelled-facts.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 表の升の値。名前は行の見出し（最初の列）で、列が三つ以上なら列の見出しも付ける（「大人 料金」）。
+ * 升に値だけを書いたときだけ読む。「3,000円（税込）」のように条件を書いた升は読まない。
+ * 行の見出しが値を含むか字を含まない表（日付の列から始まる日程表）は、行に名前が無いので読まない。
+ */
+type Cell = Span & { readonly text: string };
+
+const LETTER = /\p{L}/u;
+const TWO_COLUMNS = 2;
+
+const cellsOf = (line: Line): Cell[] => {
+  const bounds = [-1, ...[...line.text.matchAll(CELL_SEPARATOR)].map((match) => match.index), line.text.length];
+  const cells = bounds.slice(1).map((end, index) => {
+    const from = (bounds[index] ?? 0) + 1;
+    return { start: line.start + from, end: line.start + end, text: line.text.slice(from, end) };
+  });
+  const trimmed = line.text.trim();
+  return cells.slice(trimmed.startsWith("|") ? 1 : 0, trimmed.endsWith("|") ? cells.length - 1 : cells.length);
+};
+
+const plain = withoutEdgeMarks;
+
+/** 区切り行（|---|）の前の行が見出し、後ろに続く | の行が本体。 */
+const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
+  lines.flatMap((line, index) => {
+    const header = lines[index - 1];
+    if (!TABLE_RULE.test(line.text) || header === undefined || !header.text.includes("|")) return [];
+    const after = lines.slice(index + 1);
+    const end = after.findIndex((row) => !row.text.includes("|"));
+    return [{ header, rows: end === -1 ? after : after.slice(0, end) }];
+  });
+
+const inside = (cell: Span, value: FactValue): boolean => value.start >= cell.start && value.end <= cell.end;
+
+/** 升の値。升の字（強調を除く）がちょうど一つの値のときだけ。 */
+const cellValue = (cell: Cell, values: readonly FactValue[], source: string): FactValue | undefined => {
+  const within = values.filter((value) => inside(cell, value));
+  const only = within.length === 1 ? within[0] : undefined;
+  return only !== undefined && source.slice(only.start, only.end) === plain(cell.text) ? only : undefined;
+};
+
+const keyOf = (label: string): string => label.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+
+const rowFacts = (row: Line, headings: readonly string[], values: readonly FactValue[], source: string): Fact[] => {
+  const [first, ...rest] = cellsOf(row);
+  if (first === undefined) return [];
+  const rowLabel = plain(first.text);
+  if (!LETTER.test(rowLabel) || values.some((value) => inside(first, value))) return [];
+  return rest.flatMap((cell, index) => {
+    const value = cellValue(cell, values, source);
+    const column = headings[index + 1] ?? "";
+    if (value === undefined || (headings.length > TWO_COLUMNS && column === "")) return [];
+    const label = headings.length > TWO_COLUMNS ? `${rowLabel} ${column}` : rowLabel;
+    return [{ label, key: keyOf(label), value }];
+  });
+};
+
+/** 文書の表すべての升の値。 */
+export const tableFacts = (source: string, values: readonly FactValue[]): Fact[] =>
+  tablesOf(linesOf(source)).flatMap((table) => {
+    const headings = cellsOf(table.header).map((cell) => plain(cell.text));
+    return table.rows.flatMap((row) => rowFacts(row, headings, values, source));
+  });

package/src/facts/trim-marks.ts

@@ -0,0 +1,18 @@
+/** 名前や値の端の、強調の印と空白。全角の空白も入れる。 */
+export const EDGE_MARKS: ReadonlySet<string> = new Set(["*", "_", " ", "\t", "　"]);
+
+/** 後ろの端から、chars の字を落とす。正規表現の [..]*$ は長い行で後戻りが重くなるので、端から数える。 */
+export const trimEndOf = (text: string, chars: ReadonlySet<string>): string => {
+  let end = text.length;
+  while (end > 0 && chars.has(text.charAt(end - 1))) end -= 1;
+  return text.slice(0, end);
+};
+
+const trimStartOf = (text: string, chars: ReadonlySet<string>): string => {
+  let start = 0;
+  while (start < text.length && chars.has(text.charAt(start))) start += 1;
+  return text.slice(start);
+};
+
+/** 両端から、強調の印と空白を落とす。 */
+export const withoutEdgeMarks = (text: string): string => trimStartOf(trimEndOf(text, EDGE_MARKS), EDGE_MARKS);

package/src/facts/unit-conflicts.ts

@@ -0,0 +1,45 @@
+import type { ScopedFact } from "./fact-scope.ts";
+import { sameMeasure, type Measured } from "./measures.ts";
+
+/**
+ * 同じ名前の量を、違う単位で書いて、換算すると合わない（「距離：5 km」と「距離：3000 m」）。比べるのは同じ範囲の、同じ種類の量で、
+ * 単位が違うものだけ。同じ単位どうしの食い違いは fact-conflict が見る。丸めた書き方（1 mile と 1.6 km）は、差が TOLERANCE 以内なら合う。
+ */
+export type UnitConflict = { readonly fact: ScopedFact; readonly measured: Measured; readonly other: Measured };
+
+const TOLERANCE = 0.02;
+
+const groupKey = (fact: ScopedFact): string => `${fact.scope}\u0000${fact.key}`;
+
+type Read = { readonly fact: ScopedFact; readonly measured: Measured };
+
+/**
+ * 一つの種類（長さなら長さ）の量のうち、前にある単位の違う量のどれとも換算して合わないもの。どれか一つと合えば、食い違いは同じ単位
+ * どうし（3 km と 5 km）の側にあり、fact-conflict が見る。
+ */
+const conflictsInDimension = (reads: readonly Read[]): UnitConflict[] =>
+  reads.flatMap(({ fact, measured }, index) => {
+    const others = reads.slice(0, index).filter((earlier) => earlier.measured.unit !== measured.unit);
+    const [first] = others;
+    if (first === undefined || others.some((earlier) => sameMeasure(earlier.measured, measured, TOLERANCE))) return [];
+    return [{ fact, measured, other: first.measured }];
+  });
+
+const conflictsIn = (reads: readonly Read[]): UnitConflict[] => {
+  if (reads.some(({ fact }) => fact.record)) return [];
+  const dimensions = [...new Set(reads.map(({ measured }) => measured.dimension))];
+  return dimensions.flatMap((dimension) => conflictsInDimension(reads.filter(({ measured }) => measured.dimension === dimension)));
+};
+
+/** 範囲と名前ごとに、最初の量と単位の違う量を換算して比べる。 */
+export const unitConflicts = (facts: readonly ScopedFact[], measuredOf: (fact: ScopedFact) => Measured | undefined): UnitConflict[] => {
+  const groups = new Map<string, Read[]>();
+  facts.forEach((fact) => {
+    const measured = measuredOf(fact);
+    if (measured === undefined) return;
+    const group = groups.get(groupKey(fact));
+    if (group === undefined) groups.set(groupKey(fact), [{ fact, measured }]);
+    else group.push({ fact, measured });
+  });
+  return [...groups.values()].flatMap(conflictsIn);
+};

package/src/figure-references.ts

@@ -23,7 +23,7 @@ export type LabelWords = {
 
 export type DanglingFigure = { readonly offset: number; readonly label: string };
 
-type Mention = { readonly start: number; readonly end: number; readonly written: string; readonly key: string; readonly kind: string };
+export type Mention = { readonly start: number; readonly end: number; readonly written: string; readonly key: string; readonly kind: string };
 
 /** 語の前の字が漢字・カタカナ・英数字なら、長い語の一部（地図3、一覧表2、法別表第二、SubFigure）。 */
 const INSIDE_WORD = "(?<![\\p{Script=Han}\\p{Script=Katakana}\\p{N}A-Za-z])";
@@ -171,3 +171,22 @@ export const danglingFigures = (
   const elsewhere = named.length === 0 || citations === undefined ? () => false : citedElsewhere(named, citations.sentences);
   return dangling.filter((mention) => !elsewhere(mention)).map((mention) => ({ offset: mention.start, label: mention.written }));
 };
+
+/**
+ * The document's captions (a number at the start of a line) and its references in the text (every other mention that
+ * points at this document, outside a link), each in document order. Only the kinds the document labels somewhere.
+ */
+export const figureMentions = (
+  source: string,
+  prose: string,
+  words: LabelWords,
+  links: readonly Span[] = [],
+): { readonly captions: readonly Mention[]; readonly references: readonly Mention[] } => {
+  if (words.labels.length === 0) return { captions: [], references: [] };
+  const captions = labelledIn(source, words.labels);
+  const kinds = new Set(captions.map((mention) => mention.kind));
+  const references = mentionsIn(prose, words.labels)
+    .filter((mention) => kinds.has(mention.kind) && !isLabelled(source, mention))
+    .filter((mention) => pointsHere(prose, mention, words) && !links.some((link) => link.start <= mention.start && mention.end <= link.end));
+  return { captions, references };
+};

package/src/files.ts

@@ -1,12 +1,13 @@
 import { globSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join, relative, sep } from "node:path";
+import { join, matchesGlob, relative, sep } from "node:path";
 import { plainSource } from "./plain-source.ts";
 
 /** 検査する文書を読む。言語・ジャンル・stet も文書モデルと同じ本文（BOM と CRLF / CR をそろえたもの）で読むため、ここでそろえる。 */
 export const readDocumentFile = async (path: string): Promise<string> => plainSource(await readFile(path, "utf8"));
 
-const MARKDOWN = [".md", ".markdown", ".mdx"];
+/** What a directory walk finds without include: Markdown. */
+export const MARKDOWN = [".md", ".markdown", ".mdx"];
 
 /** 走査から外す。ここを通すと node_modules の README を延々と検査することになる。 */
 const SKIP: ReadonlySet<string> = new Set(["node_modules", "dist", "build", "coverage", ".git", ".chaff-cache"]);
@@ -15,12 +16,17 @@ const isMarkdown = (path: string): boolean => MARKDOWN.some((ext) => path.toLowe
 
 const isSkipped = (path: string): boolean => path.split(sep).some((part) => SKIP.has(part));
 
-const expand = (target: string): string[] => {
-  const stat = statSync(target, { throwIfNoEntry: false });
-  if (stat === undefined) return globSync(target).filter(isMarkdown);
-  if (stat.isFile()) return [target];
-  return globSync(join(target, "**", "*.{md,markdown,mdx}"));
-};
+/** include: file-name globs (*.yaml) a walk takes besides Markdown. A glob with a slash is matched below each folder walked. */
+const isIncluded = (path: string, include: readonly string[]): boolean => include.some((pattern) => matchesGlob(path, join("**", pattern)));
+
+const expand =
+  (include: readonly string[]) =>
+  (target: string): string[] => {
+    const stat = statSync(target, { throwIfNoEntry: false });
+    if (stat === undefined) return globSync(target).filter((path) => isMarkdown(path) || isIncluded(path, include));
+    if (stat.isFile()) return [target];
+    return [join(target, "**", "*.{md,markdown,mdx}"), ...include.map((pattern) => join(target, "**", pattern))].flatMap((pattern) => globSync(pattern));
+  };
 
 /**
  * 与えられたファイル・ディレクトリ・glob を、検査する Markdown の一覧にする。
@@ -33,7 +39,7 @@ const expand = (target: string): string[] => {
  */
 const byPath = (left: string, right: string): number => left.localeCompare(right, "en");
 
-export const collectTargets = (targets: readonly string[]): string[] => {
-  const found = targets.flatMap(expand).filter((path) => !isSkipped(path));
+export const collectTargets = (targets: readonly string[], include: readonly string[] = []): string[] => {
+  const found = targets.flatMap(expand(include)).filter((path) => !isSkipped(path));
   return [...new Set(found)].toSorted((left, right) => byPath(relative(".", left), relative(".", right)));
 };

package/src/fix-plan/mode.ts

@@ -5,7 +5,7 @@
 export type FixMode = "none" | "light" | "bold" | "full";
 
 /** Why the mode was chosen, so the plan can say it. */
-export type ModeReason = "nothing-found" | "composite" | "genre" | "signals" | "spots";
+export type ModeReason = "nothing-found" | "composite" | "structure" | "genre" | "signals" | "spots";
 
 export type ModeChoice = { readonly mode: FixMode; readonly reason: ModeReason };
 
@@ -15,6 +15,8 @@ export type ModeInput = {
   readonly firedRules: ReadonlySet<string>;
   /** The rules that measure the whole document: ai-generated-composite's inputs and bold-density. */
   readonly signalRules: ReadonlySet<string>;
+  /** The structure score (measures past 90% of human articles) and the count at which the outline itself is the problem. */
+  readonly structure?: { readonly score: number; readonly limit: number };
 };
 
 export const COMPOSITE_RULE = "ai-generated-composite";
@@ -25,9 +27,13 @@ const MIN_SIGNALS_FOR_BOLD = 2;
 /** A blog post or an essay is rewritten from its structure up: what the writer wants changed there is the structure. */
 const isFreeFormGenre = (genre: string): boolean => genre.startsWith("blog/") || genre === "literature/essay";
 
+/** An outline far from human articles is rewritten from the outline, in any genre and whether or not a rule fired. */
+const hasStructureToFix = (input: ModeInput): boolean => input.structure !== undefined && input.structure.score >= input.structure.limit;
+
 export const recommendMode = (input: ModeInput): ModeChoice => {
-  if (input.firedRules.size === 0) return { mode: "none", reason: "nothing-found" };
   if (input.firedRules.has(COMPOSITE_RULE)) return { mode: "full", reason: "composite" };
+  if (hasStructureToFix(input)) return { mode: "full", reason: "structure" };
+  if (input.firedRules.size === 0) return { mode: "none", reason: "nothing-found" };
   if (isFreeFormGenre(input.genre)) return { mode: "full", reason: "genre" };
   const signals = [...input.firedRules].filter((rule) => input.signalRules.has(rule)).length;
   return signals >= MIN_SIGNALS_FOR_BOLD ? { mode: "bold", reason: "signals" } : { mode: "light", reason: "spots" };

package/src/fix-plan/plan.ts

@@ -5,6 +5,8 @@ import type { Outline, Shape } from "../outline/shape.ts";
 import { localized, messageOf } from "../render/text.ts";
 import { splitWords } from "../detectors/word-list.ts";
 import { COMPOSITE_RULE, recommendMode, type ModeChoice } from "./mode.ts";
+import type { StructureScore } from "../structure-shape/score.ts";
+import { structureTargetsOf, type StructureTarget } from "./structure-targets.ts";
 
 /** One flagged spot, where it is and what chaff said about it. */
 export type PlanSpot = { readonly line: number; readonly column: number; readonly quote: string; readonly message: string };
@@ -39,6 +41,10 @@ export type FixPlan = {
   readonly mode: ModeChoice;
   readonly signals: readonly DocumentSignal[];
   readonly outline: { readonly unit: LengthUnit; readonly shape: Shape };
+  /** The structure score, the count at which the plan rewrites from the outline, and how many measures were compared. */
+  readonly structure: { readonly score: number; readonly limit: number; readonly compared: number };
+  /** The structure measures past 90% of human articles, each with the human numbers to bring it back to. */
+  readonly targets: readonly StructureTarget[];
   readonly rules: readonly RulePlan[];
   /** The rewrite and signal rules that did not run, and why: silence from them is not "checked and fine". */
   readonly notRun: readonly Skipped[];
@@ -56,11 +62,16 @@ export type PlanInput = {
   readonly rules: readonly RuleDefinition[];
   readonly skipped: readonly Skipped[];
   readonly outline: Outline;
+  /** The document's structure measures against human articles (chaff outline's structure block). */
+  readonly structure: StructureScore;
   /** The ai-tell lexicon of the document's language, whose entries may carry their own hint. */
   readonly phrases: Lexicon;
 };
 
 const BOLD_DENSITY_RULE = "bold-density";
+const STRUCTURE_RULE = "ai-structure";
+/** ai-structure's count at its normal level, when its rule file does not say. */
+const DEFAULT_STRUCTURE_LIMIT = 3;
 const AI_TELL_RULE = "ai-tell";
 
 /** ai-generated-composite's inputs and bold-density: the rules the guide reads as document-level signals. */
@@ -161,10 +172,18 @@ const checksOf = (input: PlanInput, choice: ModeChoice): string[] => {
   ];
 };
 
-/** The plan for one document: deterministic, from chaff's findings and the rule files alone. */
+/** The count ai-structure fires at by default: the same line decides when the plan rewrites from the outline. */
+const structureLimitOf = (rules: readonly RuleDefinition[]): number =>
+  rules.find((rule) => rule.id === STRUCTURE_RULE)?.levels.normal ?? DEFAULT_STRUCTURE_LIMIT;
+
+const documentLength = (outline: Outline): number => outline.entries.reduce((sum, entry) => sum + entry.length, 0);
+
+/** The plan for one document: deterministic, from chaff's findings, the rule files and the human baseline alone. */
 export const buildFixPlan = (input: PlanInput): FixPlan => {
   const signalRules = signalRulesOf(input.rules);
-  const mode = recommendMode({ genre: input.genre, firedRules: new Set(input.findings.map((finding) => finding.rule)), signalRules });
+  const structure = { score: input.structure.score, limit: structureLimitOf(input.rules), compared: input.structure.compared };
+  const firedRules = new Set(input.findings.map((finding) => finding.rule));
+  const mode = recommendMode({ genre: input.genre, firedRules, signalRules, structure });
   return {
     path: input.path,
     rewrittenPath: rewrittenPathOf(input.path),
@@ -174,6 +193,8 @@ export const buildFixPlan = (input: PlanInput): FixPlan => {
     mode,
     signals: signalsOf(input, signalRules),
     outline: { unit: input.outline.unit, shape: input.outline.shape },
+    structure,
+    targets: structureTargetsOf(input.structure, documentLength(input.outline)),
     rules: rulePlansOf(input),
     notRun: notRunOf(input, signalRules),
     checks: checksOf(input, mode),

package/src/fix-plan/render.ts

@@ -4,6 +4,7 @@ import { OUTLINE_TEXT } from "../outline/text.ts";
 import { uiLanguageOf } from "../ui.ts";
 import type { FixPlan, PhraseHint, PlanSpot, RulePlan } from "./plan.ts";
 import { FIX_PLAN_TEXT, type FixPlanText } from "./text.ts";
+import { STRUCTURE_TARGET_TEXT } from "./structure-target-text.ts";
 
 /** A phrase quoted the way the document's language quotes: 「…」 in Japanese, "…" otherwise. */
 const quoted = (text: string, language: string): string => (language === "ja" ? `「${text}」` : `"${text}"`);
@@ -62,6 +63,22 @@ const signalLines = (plan: FixPlan, text: FixPlanText): string[] => {
   return ["", `## ${text.signalsHeading}`, "", ...said, ...bullets([...plan.signals.map((signal) => `\`${signal.rule}\`: ${signal.message}`), outline])];
 };
 
+/** The structure score and, for each measure past the human limit, the target from the baseline; then when to stop. */
+const structureLines = (plan: FixPlan): string[] => {
+  const text = STRUCTURE_TARGET_TEXT[uiLanguageOf(plan.language)];
+  const targets = plan.targets.map((target) => text.target[target.id](target));
+  const stop = targets.length === 0 ? [] : ["", text.stop(plan.structure.limit)];
+  return [
+    "",
+    `## ${text.heading}`,
+    "",
+    text.score(plan.structure.score, plan.structure.limit, plan.structure.compared),
+    "",
+    ...(targets.length === 0 ? [text.noTargets] : bullets(targets)),
+    ...stop,
+  ];
+};
+
 const notRunLines = (plan: FixPlan, text: FixPlanText): string[] => {
   const note = plan.experimental ? [] : [text.notExperimental];
   const listed = plan.notRun;
@@ -106,6 +123,7 @@ export const renderFixPlanMarkdown = (plan: FixPlan): string => {
     ...text.constraints.map((constraint, index) => `${String(index + 1)}. ${constraint}`),
     ...modeLines(plan, text),
     ...signalLines(plan, text),
+    ...structureLines(plan),
     ...(plan.rules.length === 0 ? [] : ["", `## ${text.rulesHeading}`]),
     ...plan.rules.flatMap((rule) => rulePlanLines(rule, text, plan.language)),
     ...notRunLines(plan, text),

package/src/fix-plan/structure-target-text.ts

@@ -0,0 +1,90 @@
+import type { Texts } from "../ui.ts";
+import type { FeatureId } from "../structure-shape/features.ts";
+import type { StructureTarget } from "./structure-targets.ts";
+
+export type StructureTargetText = {
+  readonly heading: string;
+  /** The score, what it counts, and the count at which the plan rewrites from the outline. */
+  readonly score: (score: number, limit: number, compared: number) => string;
+  readonly noTargets: string;
+  /** One target per measure past the human limit, from the baseline's numbers. */
+  readonly target: Readonly<Record<FeatureId, (target: StructureTarget) => string>>;
+  /** When the rewrite of the outline is done. */
+  readonly stop: (limit: number) => string;
+};
+
+const v = (value: number): string => String(value);
+
+const withDetail = (detail: string | undefined, wrap: (detail: string) => string): string => (detail === undefined ? "" : wrap(detail));
+
+const formJa = (form: string): string => `（多いのは「${form}」）`;
+const quotedJa = (heading: string): string => `「${heading}」`;
+const pairsJa = (pairs: string): string => `（${pairs}）`;
+const formEn = (form: string): string => ` (most: "${form}")`;
+const quotedEn = (heading: string): string => ` "${heading}"`;
+const pairsEn = (pairs: string): string => ` (${pairs})`;
+
+export const STRUCTURE_TARGET_TEXT: Texts<StructureTargetText> = {
+  ja: {
+    heading: "構成の目標",
+    score: (score, limit, compared) =>
+      `構成の AI らしさ: ${v(score)}（人の記事の 9 割を超えた項目の数。比べた ${v(compared)} 項目のうち）。${v(limit)} 以上なら構成から書き直します。`,
+    noTargets: "構成の項目は、どれも人の記事の範囲にあります。",
+    target: {
+      "heading-density": (target) => {
+        const budget = target.headings;
+        const counts =
+          budget === undefined ? "" : `いま ${v(budget.now)} 個。この長さの人の記事なら多くて ${v(budget.most)} 個、ふつうは ${v(budget.usual)} 個です。`;
+        return `見出しを減らす: ${counts}一段落ごとに見出しを立てず、中身のまとまりごとに立てます。`;
+      },
+      "short-sections": (target) => `1〜2 段落しかない節を、前後の節と合わせる: いま ${v(target.value)}%（人の記事の 9 割は ${v(target.limit)}% まで）。`,
+      "section-uniformity": (target) =>
+        `節の長さを揃えない: ばらつきがいま ${v(target.value)}%（人の記事の 9 割は ${v(target.limit)}% 以上、ふつうは ${v(target.median)}%）。書くことの少ない節は短く、多い節は長くします。`,
+      "heading-forms": (target) =>
+        `見出しの形を変える: いま ${v(target.value)}% が決まった形${withDetail(target.detail, formJa)}です（人の記事の 9 割は ${v(target.limit)}% まで）。「〜とは」「〜のメリット」をやめ、その節で言うことを見出しにします。`,
+      "three-subsections": (target) =>
+        `3 つの小見出しに分けた見出しを、中身の数に合わせる: いま ${v(target.value)} か所（人の記事の 9 割は ${v(target.limit)} か所まで）。`,
+      bookends: () => "「はじめに」と「まとめ」の見出しを外す: 要点か具体的な場面から書き始め、最後の節は本文の続きにします。",
+      "closing-restatement": (target) =>
+        `本文を言い直す${withDetail(target.detail, quotedJa)}を消す: 言い直しがいま ${v(target.value)}%（人の記事の 9 割は ${v(target.limit)}% まで）。言いたいことは前の節の最後に入れます。`,
+      "three-item-lists": (target) => `3 項目に揃えた箇条書きを、中身の数に合わせる: いま ${v(target.value)}%（人の記事の 9 割は ${v(target.limit)}% まで）。`,
+      "bold-labels": (target) => `太字の札で始まる項目 ${v(target.value)} 個を文に戻す（人の記事の 9 割は ${v(target.limit)} 個まで）。`,
+      "emoji-headings": (target) => `見出しの絵文字 ${v(target.value)} 個を外す（人の記事の 9 割は ${v(target.limit)} 個まで）。`,
+      "pro-con": (target) => `メリットとデメリットを対にした節${withDetail(target.detail, pairsJa)}を、代わりに払うものも書いた一つの話にまとめる。`,
+    },
+    stop: (limit) =>
+      `\`chaff outline <元の文書> <書き直した文書>\` で、上の項目に ✗ が付かなくなり、構成の AI らしさが ${v(limit)} 未満になったら構成の書き直しを止めます。`,
+  },
+  en: {
+    heading: "Structure targets",
+    score: (score, limit, compared) =>
+      `Structure score: ${v(score)} (measures past 90% of human articles, of ${v(compared)} compared). At ${v(limit)} or more, rewrite from the outline.`,
+    noTargets: "Every structure measure is within the range of human articles.",
+    target: {
+      "heading-density": (target) => {
+        const budget = target.headings;
+        const counts =
+          budget === undefined ? "" : `${v(budget.now)} now; a human article this long has ${v(budget.most)} at most, ${v(budget.usual)} usually. `;
+        return `Fewer headings: ${counts}Give a heading to a unit of content, not to every paragraph.`;
+      },
+      "short-sections": (target) =>
+        `Merge sections of one or two paragraphs into their neighbours: ${v(target.value)}% now (90% of human articles: ${v(target.limit)}% or less).`,
+      "section-uniformity": (target) =>
+        `Let section lengths vary: variation ${v(target.value)}% now (90% of human articles: ${v(target.limit)}% or more, median ${v(target.median)}%). Thin sections stay thin, full ones run long.`,
+      "heading-forms": (target) =>
+        `Vary the heading forms: ${v(target.value)}% are in a stock form now${withDetail(target.detail, formEn)} (90% of human articles: ${v(target.limit)}% or less). Say in the heading what the section says, not "What is X" or "Benefits of X".`,
+      "three-subsections": (target) =>
+        `Split a section as many ways as its content has: ${v(target.value)} headings split into three now (90% of human articles: ${v(target.limit)} or fewer).`,
+      bookends: () => 'Drop the "Introduction" and "Conclusion" headings: open with the point or a concrete scene, and let the last section continue the body.',
+      "closing-restatement": (target) =>
+        `Cut the closing${withDetail(target.detail, quotedEn)} that restates the body: ${v(target.value)}% restated now (90% of human articles: ${v(target.limit)}% or less). Put the point at the end of the section before.`,
+      "three-item-lists": (target) =>
+        `Give each list as many items as its content has: ${v(target.value)}% of lists have three now (90% of human articles: ${v(target.limit)}% or less).`,
+      "bold-labels": (target) => `Turn the ${v(target.value)} bold-label list items back into sentences (90% of human articles: ${v(target.limit)} or fewer).`,
+      "emoji-headings": (target) => `Take the emoji out of ${v(target.value)} headings (90% of human articles: ${v(target.limit)} or fewer).`,
+      "pro-con": (target) => `Fold the paired pros and cons sections${withDetail(target.detail, pairsEn)} into one account that also says what it costs.`,
+    },
+    stop: (limit) =>
+      `Stop rewriting the outline when \`chaff outline <original> <rewrite>\` marks none of these with ✗ and the structure score is under ${v(limit)}.`,
+  },
+};

package/src/fix-plan/structure-targets.ts

@@ -0,0 +1,46 @@
+import type { FeatureId } from "../structure-shape/features.ts";
+import type { Placement, StructureScore } from "../structure-shape/score.ts";
+
+/** How many section headings the document has, and how many a human article of its length has at most and usually. */
+export type HeadingBudget = { readonly now: number; readonly most: number; readonly usual: number };
+
+/** One structure measure to bring back into the human range: where it is, where the human limit is, and the median. */
+export type StructureTarget = {
+  readonly id: FeatureId;
+  readonly value: number;
+  readonly limit: number;
+  readonly median: number;
+  readonly detail?: string;
+  /** For heading density only: the measure turned into a count of headings for this document's length. */
+  readonly headings?: HeadingBudget;
+};
+
+const PER = 1000;
+
+const budgetOf = (placement: Placement, value: number, length: number): HeadingBudget => ({
+  now: placement.feature.count ?? Math.round((value * length) / PER),
+  most: Math.floor(((placement.limit ?? 0) * length) / PER),
+  usual: Math.round(((placement.median ?? 0) * length) / PER),
+});
+
+const targetOf = (placement: Placement, length: number): StructureTarget[] => {
+  const { value, detail, id } = placement.feature;
+  if (!placement.beyond || value === undefined || placement.limit === undefined || placement.median === undefined) return [];
+  return [
+    {
+      id,
+      value,
+      limit: placement.limit,
+      median: placement.median,
+      ...(detail === undefined ? {} : { detail }),
+      ...(id === "heading-density" ? { headings: budgetOf(placement, value, length) } : {}),
+    },
+  ];
+};
+
+/**
+ * The measures past the human limit, each as a target from the baseline's numbers. `length` is the document's length in
+ * its unit (characters or words), which turns the heading density into a count of headings.
+ */
+export const structureTargetsOf = (score: StructureScore, length: number): StructureTarget[] =>
+  score.placements.flatMap((placement) => targetOf(placement, length));

package/src/fix-plan/text.ts

@@ -53,6 +53,7 @@ export const FIX_PLAN_TEXT: Texts<FixPlanText> = {
     modeReason: {
       "nothing-found": "chaff は何も見つけませんでした。",
       composite: "ai-generated-composite が出ています。文の言い回しを直しても、生成文の骨組みが残ります。",
+      structure: "構成の項目のいくつもが、人の記事の 9 割を超えています（下の「構成の目標」）。文を直しても、見出しの立て方と節の形が残ります。",
       genre: "ブログやエッセイは、構成から書き直すほうが書き手の望みに合います。",
       signals: "文書全体を測るルールが 2 つ以上出ています。見出しの構成は残し、節ごとに文を書き直します。",
       spots: "指摘は箇所ごとです。指摘された所だけを直します。",
@@ -101,6 +102,8 @@ export const FIX_PLAN_TEXT: Texts<FixPlanText> = {
     modeReason: {
       "nothing-found": "chaff found nothing.",
       composite: "ai-generated-composite fires. Fixing the wording would leave the skeleton of generated text.",
+      structure:
+        'Several structure measures lie past 90% of human articles (see "Structure targets" below). Fixing the sentences would leave the headings and the shape of the sections.',
       genre: "For a blog post or an essay, what the writer wants changed is usually the structure.",
       signals: "Two or more rules that measure the whole document fire. Keep the outline and rewrite the prose section by section.",
       spots: "The findings are single spots. Rewrite only those.",

package/src/grade/baseline-text.ts

@@ -0,0 +1,80 @@
+import type { Texts } from "../ui.ts";
+
+export type BaselineText = {
+  readonly unreadable: (path: string, lines: string) => string;
+  readonly notComparable: (path: string, differ: string) => string;
+  readonly mismatchAllowed: (path: string, differ: string) => string;
+  readonly differ: Readonly<Record<"rules" | "settings" | "mixed", string>>;
+  readonly heading: (path: string, paired: number) => string;
+  readonly unpaired: (onlyBefore: string, onlyAfter: string, readOtherwise: string) => string;
+  readonly ratesHeading: (unit: string) => string;
+  readonly unit: Readonly<Record<"char" | "word", string>>;
+  readonly more: (ids: string) => string;
+  readonly fewer: (ids: string) => string;
+  readonly inRubric: string;
+  readonly newlyFailed: (ids: string) => string;
+  readonly newlyPassed: (ids: string) => string;
+  readonly newFactsHeading: string;
+  readonly droppedAdded: (dropped: string, added: string) => string;
+  readonly newCitations: (addresses: string) => string;
+  readonly penalty: (before: number, after: number) => string;
+  readonly regressionsHeading: (count: number) => string;
+  readonly noRegression: string;
+  readonly none: string;
+  /** Between the parts of one output's line. */
+  readonly separator: string;
+};
+
+export const BASELINE_TEXT: Texts<BaselineText> = {
+  ja: {
+    unreadable: (path, lines) => `${path}: chaff grade --out の 1 回分の結果として読めない行があります（${lines} 行目。形が違うか、id が重なっている）`,
+    notComparable: (path, differ) =>
+      `${path} とは比べません: ${differ}が違います。ルールか設定が変わった差を、prompt や model の差として読まないため（--allow-stamp-mismatch で比べる）`,
+    mismatchAllowed: (path, differ) =>
+      `注意: ${path} とは${differ}が違います。--allow-stamp-mismatch で比べています。差には prompt や model の差でないものが混ざります`,
+    differ: { rules: "ルール", settings: "設定", mixed: "結果ごとの再現の印" },
+    heading: (path, paired) => `${path} と比べた: ${String(paired)} 件の出力が組になった`,
+    unpaired: (onlyBefore, onlyAfter, readOtherwise) => `比べられない: 前の回だけ ${onlyBefore}、今回だけ ${onlyAfter}、言語かジャンルが違う ${readOtherwise}`,
+    ratesHeading: (unit) => `ルールごとの率（1,000 ${unit}あたり、前 → 後）`,
+    unit: { char: "字", word: "語" },
+    more: (ids) => `増えた: ${ids}`,
+    fewer: (ids) => `減った: ${ids}`,
+    inRubric: "（grade: のルール）",
+    newlyFailed: (ids) => `新しく落ちた: ${ids}`,
+    newlyPassed: (ids) => `新しく通った: ${ids}`,
+    newFactsHeading: "新しく落ちた・足された事実と、新しく外れた引用",
+    droppedAdded: (dropped, added) => `落ちた ${dropped}、足された ${added}`,
+    newCitations: (addresses) => `外れた引用 ${addresses}`,
+    penalty: (before, after) => `減点の和: ${String(before)} → ${String(after)}`,
+    regressionsHeading: (count) => `回帰 ${String(count)} 件`,
+    noRegression: "回帰はありません",
+    none: "なし",
+    separator: "、",
+  },
+  en: {
+    unreadable: (path, lines) => `${path}: not the results of one chaff grade --out run (line ${lines}: another shape, or an id already used)`,
+    notComparable: (path, differ) =>
+      `Not compared with ${path}: the ${differ} differ. A change of rules or settings would read as a change of prompt or model (--allow-stamp-mismatch compares anyway)`,
+    mismatchAllowed: (path, differ) =>
+      `Note: the ${differ} differ from ${path}; compared because of --allow-stamp-mismatch. Not every change below comes from the prompt or model`,
+    differ: { rules: "rules", settings: "settings", mixed: "stamps of its results" },
+    heading: (path, paired) => `Compared with ${path}: ${String(paired)} paired ${paired === 1 ? "output" : "outputs"}`,
+    unpaired: (onlyBefore, onlyAfter, readOtherwise) =>
+      `Not compared: only before ${onlyBefore}; only now ${onlyAfter}; another language or genre ${readOtherwise}`,
+    ratesHeading: (unit) => `Rule rates (per 1,000 ${unit}, before → after)`,
+    unit: { char: "characters", word: "words" },
+    more: (ids) => `more in ${ids}`,
+    fewer: (ids) => `fewer in ${ids}`,
+    inRubric: "(a grade: rule)",
+    newlyFailed: (ids) => `Newly failed: ${ids}`,
+    newlyPassed: (ids) => `Newly passed: ${ids}`,
+    newFactsHeading: "New dropped or added facts, and new failed quotations",
+    droppedAdded: (dropped, added) => `dropped ${dropped}; added ${added}`,
+    newCitations: (addresses) => `failed quotations ${addresses}`,
+    penalty: (before, after) => `Penalty points: ${String(before)} → ${String(after)}`,
+    regressionsHeading: (count) => `${String(count)} ${count === 1 ? "regression" : "regressions"}`,
+    noRegression: "No regression",
+    none: "none",
+    separator: "; ",
+  },
+};