chaffjs 0.19.0 → 0.21.0

package/src/fix-plan/plan.ts

@@ -5,6 +5,9 @@ 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";
+import { DEFAULT_DEPTH, depthIncludes, type RewriteDepth } from "../rewrite-depth.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 };
@@ -16,6 +19,8 @@ export type PhraseHint = { readonly phrase: string; readonly rewrite: string };
 export type RulePlan = {
   readonly rule: string;
   readonly name: string;
+  /** How deep the rule's direction reaches (rewrite.depth); light when the rule does not say. */
+  readonly depth: RewriteDepth;
   /** The rule's rewrite direction, or its how_to_fix when it has no rewrite block. */
   readonly direction: string;
   readonly keep: readonly string[];
@@ -29,6 +34,12 @@ export type RulePlan = {
 /** A rule that measures the whole document, with what it said. */
 type DocumentSignal = { readonly rule: string; readonly message: string };
 
+/** A rule that fired but reaches deeper than the chosen depth: named, not planned, so its silence is not read as fixed. */
+export type DeeperRule = { readonly rule: string; readonly name: string; readonly depth: RewriteDepth; readonly spots: number };
+
+/** The depth chosen for the plan, and where: --depth on the command line, or fix_plan.depth in chaff.yaml. */
+export type ChosenDepth = { readonly depth: RewriteDepth; readonly from: "flag" | "config" };
+
 export type FixPlan = {
   readonly path: string;
   /** Where the plan suggests saving the rewrite, so the check commands can be pasted as they are. */
@@ -37,9 +48,17 @@ export type FixPlan = {
   readonly genre: string;
   readonly experimental: boolean;
   readonly mode: ModeChoice;
+  /** None when chaff recommends the depth itself. */
+  readonly chosenDepth: ChosenDepth | undefined;
   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 rules that fired but reach deeper than the chosen depth. Empty without a chosen depth. */
+  readonly deeper: readonly DeeperRule[];
   /** The rewrite and signal rules that did not run, and why: silence from them is not "checked and fine". */
   readonly notRun: readonly Skipped[];
   readonly checks: readonly string[];
@@ -56,11 +75,17 @@ 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;
+  readonly chosenDepth?: ChosenDepth | undefined;
 };
 
 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. */
@@ -103,6 +128,7 @@ const rulePlanOf = (rule: RuleDefinition, findings: readonly Finding[], input: P
   return {
     rule: rule.id,
     name: localized(rule.name, input.language),
+    depth: depthOfRule(rule),
     direction: rewrite?.direction ?? localized(rule.how_to_fix, input.language),
     keep: rewrite?.keep ?? [],
     avoid: rewrite?.avoid ?? [],
@@ -112,6 +138,18 @@ const rulePlanOf = (rule: RuleDefinition, findings: readonly Finding[], input: P
   };
 };
 
+const depthOfRule = (rule: RuleDefinition): RewriteDepth => rule.guide?.rewriteDepth ?? DEFAULT_DEPTH;
+
+/** Every rule that fired, planned; then the ones a chosen depth leaves out, set apart. */
+const byDepth = (plans: readonly RulePlan[], chosen: ChosenDepth | undefined): Pick<FixPlan, "rules" | "deeper"> => {
+  if (chosen === undefined) return { rules: plans, deeper: [] };
+  const within = (plan: RulePlan): boolean => depthIncludes(chosen.depth, plan.depth);
+  return {
+    rules: plans.filter(within),
+    deeper: plans.filter((plan) => !within(plan)).map((plan) => ({ rule: plan.rule, name: plan.name, depth: plan.depth, spots: plan.spots.length })),
+  };
+};
+
 /** The rules in the order their first finding appears; the composite has no spot of its own and is a signal only. */
 const rulePlansOf = (input: PlanInput): RulePlan[] => {
   const order = [...new Set(input.findings.map((finding) => finding.rule))].filter((id) => id !== COMPOSITE_RULE);
@@ -148,12 +186,12 @@ const notRunOf = (input: PlanInput, signalRules: ReadonlySet<string>): Skipped[]
   return input.skipped.filter((skipped) => watched.has(skipped.rule));
 };
 
-/** The commands to run on the rewrite. A full rewrite cuts repeats and rebuilds headings, which compare is told. */
+/** The commands to run on the rewrite. A rewrite past light cuts repeats and rebuilds headings, which compare is told. */
 const checksOf = (input: PlanInput, choice: ModeChoice): string[] => {
   const original = shellPath(input.path);
   const rewritten = shellPath(rewrittenPathOf(input.path));
   const lintFlags = [...(input.experimental ? ["--experimental"] : []), ...(input.genreFlag === undefined ? [] : ["--genre", input.genreFlag])];
-  const compareFlags = choice.mode === "full" ? ["--distinct", "--allow-dropped heading", "--allow-added heading"] : [];
+  const compareFlags = choice.depth !== undefined && choice.depth !== "light" ? ["--distinct", "--allow-dropped heading", "--allow-added heading"] : [];
   return [
     ["npx chaffjs", rewritten, ...lintFlags].join(" "),
     ["npx chaffjs compare", original, rewritten, ...compareFlags].join(" "),
@@ -161,10 +199,22 @@ 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 planned = byDepth(rulePlansOf(input), input.chosenDepth);
+  // A rule the depth sets apart is not something this rewrite fixes, so it does not decide the way either.
+  const setApart = new Set(planned.deeper.map((rule) => rule.rule));
+  const firedRules = new Set(input.findings.map((finding) => finding.rule).filter((rule) => !setApart.has(rule)));
+  const chosen = input.chosenDepth?.depth;
+  const mode = recommendMode({ genre: input.genre, firedRules, signalRules, structure, chosen, setApart: setApart.size });
   return {
     path: input.path,
     rewrittenPath: rewrittenPathOf(input.path),
@@ -172,9 +222,12 @@ export const buildFixPlan = (input: PlanInput): FixPlan => {
     genre: input.genre,
     experimental: input.experimental,
     mode,
+    chosenDepth: input.chosenDepth,
     signals: signalsOf(input, signalRules),
     outline: { unit: input.outline.unit, shape: input.outline.shape },
-    rules: rulePlansOf(input),
+    structure,
+    targets: structureTargetsOf(input.structure, documentLength(input.outline)),
+    ...planned,
     notRun: notRunOf(input, signalRules),
     checks: checksOf(input, mode),
   };

package/src/fix-plan/render.ts

@@ -4,6 +4,8 @@ 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";
+import { DEFAULT_DEPTH, depthMeaning } from "../rewrite-depth.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}"`);
@@ -33,6 +35,7 @@ const rulePlanLines = (rule: RulePlan, text: FixPlanText, language: string): str
   "",
   `### \`${rule.rule}\` ${rule.name}`,
   "",
+  ...(rule.depth === DEFAULT_DEPTH ? [] : [`**${text.ruleDepth}**: ${rule.depth}`, ""]),
   `**${text.direction}**: ${rule.direction}`,
   ...labelled(text.keep, bullets(rule.keep)),
   ...labelled(text.avoid, bullets(rule.avoid)),
@@ -47,21 +50,58 @@ const rulePlanLines = (rule: RulePlan, text: FixPlanText, language: string): str
   ),
 ];
 
+const depthLines = (plan: FixPlan, text: FixPlanText): string[] => {
+  const { depth } = plan.mode;
+  if (depth === undefined) return [];
+  const setBy = plan.chosenDepth === undefined ? "" : text.depthSetBy[plan.chosenDepth.from];
+  return [text.depthLine(depth, depthMeaning(depth, uiLanguageOf(plan.language)), setBy), ""];
+};
+
 const modeLines = (plan: FixPlan, text: FixPlanText): string[] => [
   "",
   `## ${text.modeHeading}: ${text.modeName[plan.mode.mode]}`,
   "",
   text.modeReason[plan.mode.reason],
   "",
+  ...depthLines(plan, text),
   ...bullets(text.modeWays),
 ];
 
+/** The rules a chosen depth leaves out, named with their depth, so their findings are not taken for fixed. */
+const deeperLines = (plan: FixPlan, text: FixPlanText): string[] => {
+  if (plan.deeper.length === 0 || plan.chosenDepth === undefined) return [];
+  return [
+    "",
+    `## ${text.deeperHeading}`,
+    "",
+    text.deeperNote(plan.chosenDepth.depth),
+    "",
+    ...bullets(plan.deeper.map((rule) => `\`${rule.rule}\` ${rule.name}: ${text.deeperLine(rule.depth, rule.spots)}`)),
+  ];
+};
+
 const signalLines = (plan: FixPlan, text: FixPlanText): string[] => {
   const outline = text.outlineLine(shapeMeasures(plan.outline.shape, plan.outline.unit, OUTLINE_TEXT[uiLanguageOf(plan.language)]));
   const said = plan.signals.length === 0 ? [text.noSignals, ""] : [];
   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,8 +146,10 @@ 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)),
+    ...deeperLines(plan, text),
     ...notRunLines(plan, text),
     ...checkLines(plan, text),
   ].join("\n");

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

@@ -13,6 +13,14 @@ export type FixPlanText = {
   readonly modeName: Readonly<Record<FixMode, string>>;
   readonly modeReason: Readonly<Record<ModeReason, string>>;
   readonly modeWays: readonly string[];
+  /** The depth the plan goes to, with what it means, and where it was chosen when it was. */
+  readonly depthLine: (depth: string, meaning: string, setBy: string) => string;
+  readonly depthSetBy: Readonly<Record<"flag" | "config", string>>;
+  /** A rule's own depth, shown when it reaches past light. */
+  readonly ruleDepth: string;
+  readonly deeperHeading: string;
+  readonly deeperNote: (chosen: string) => string;
+  readonly deeperLine: (depth: string, spots: number) => string;
   readonly signalsHeading: string;
   readonly noSignals: string;
   readonly outlineLine: (measures: string) => string;
@@ -35,7 +43,7 @@ export type FixPlanText = {
 
 export const FIX_PLAN_TEXT: Texts<FixPlanText> = {
   ja: {
-    usage: "使い方: chaff fix-plan <file> [--experimental] [--genre <ジャンル>] [--json]",
+    usage: "使い方: chaff fix-plan <file> [--depth light|structure|register] [--experimental] [--genre <ジャンル>] [--json]",
     notFound: (path) => `${path} がありません。`,
     title: (path) => `直す計画: ${path}`,
     about: (language, genre) => `言語 ${language}、ジャンル ${genre}`,
@@ -49,19 +57,37 @@ export const FIX_PLAN_TEXT: Texts<FixPlanText> = {
       "書き直しは 2 回まで。指摘を消すためだけに書き直しを繰り返さない。",
     ],
     modeHeading: "勧める直し方",
-    modeName: { none: "直すところなし", light: "軽く直す（Light）", bold: "大胆に直す（Bold）", full: "全面書き直し（Full）" },
+    modeName: {
+      none: "直すところなし",
+      light: "軽く直す（Light）",
+      bold: "大胆に直す（Bold）",
+      full: "全面書き直し（Full）",
+      register: "文体を変える（Register）",
+    },
     modeReason: {
+      chosen: "書き直しの深さが決めてあるので、その深さで直します。",
+      "depth-limit": "chaff だけなら構成から書き直すことを勧めますが、決めてある深さが light なので、構成は残します。",
       "nothing-found": "chaff は何も見つけませんでした。",
+      "all-deeper": "指摘はどれも、決めた深さより深く直すルールのものです。この深さで直すところはありません（下の「決めた深さより深いルール」）。",
       composite: "ai-generated-composite が出ています。文の言い回しを直しても、生成文の骨組みが残ります。",
+      structure: "構成の項目のいくつもが、人の記事の 9 割を超えています（下の「構成の目標」）。文を直しても、見出しの立て方と節の形が残ります。",
       genre: "ブログやエッセイは、構成から書き直すほうが書き手の望みに合います。",
       signals: "文書全体を測るルールが 2 つ以上出ています。見出しの構成は残し、節ごとに文を書き直します。",
       spots: "指摘は箇所ごとです。指摘された所だけを直します。",
     },
     modeWays: [
-      "軽く直す: 指摘された箇所だけ。",
-      "大胆に直す: 見出しの構成は残し、節ごとに文を書き直す。",
-      "全面書き直し: 事実と主張を控えてから、構成から書き直す。頼まれた内容が「全面的に」「一から」なら、これを選ぶ。",
+      "軽く直す（深さ light）: 指摘された箇所だけ。",
+      "大胆に直す（深さ light）: 見出しの構成は残し、節ごとに文を書き直す。",
+      "全面書き直し（深さ structure）: 事実と主張を控えてから、構成から書き直す。頼まれた内容が「全面的に」「一から」なら、これを選ぶ。",
+      "文体を変える（深さ register）: 全面書き直しに加えて、文体も変える（です・ます → である など）。chaff からは勧めません。--depth register で選びます。",
     ],
+    depthLine: (depth, meaning, setBy) => `書き直しの深さ: ${depth}（${meaning}）${setBy}。`,
+    depthSetBy: { flag: "。--depth で決めました", config: "。chaff.yaml の fix_plan.depth で決めました" },
+    ruleDepth: "深さ",
+    deeperHeading: "決めた深さより深いルール",
+    deeperNote: (chosen) =>
+      `次のルールも指摘を出しましたが、直す方向が深さ ${chosen} より深いので、この計画では直しません。直すときは、そのルールの深さを --depth に渡して計画を出し直してください。`,
+    deeperLine: (depth, spots) => `深さ ${depth}、${String(spots)} 箇所`,
     signalsHeading: "文書全体の目印",
     noSignals: "文書全体を測るルールは、何も言っていません。",
     outlineLine: (measures) => `構成: ${measures}`,
@@ -83,7 +109,7 @@ export const FIX_PLAN_TEXT: Texts<FixPlanText> = {
       "1 つめは書き直した文書の指摘、2 つめは事実が落ちていないか・足されていないか、3 つめは構成の変化です。数は chaff の出力から取り、形容詞で言わないでください。",
   },
   en: {
-    usage: "usage: chaff fix-plan <file> [--experimental] [--genre <genre>] [--json]",
+    usage: "usage: chaff fix-plan <file> [--depth light|structure|register] [--experimental] [--genre <genre>] [--json]",
     notFound: (path) => `${path} does not exist.`,
     title: (path) => `Fix plan: ${path}`,
     about: (language, genre) => `language ${language}, genre ${genre}`,
@@ -97,19 +123,33 @@ export const FIX_PLAN_TEXT: Texts<FixPlanText> = {
       "At most two passes. Do not rewrite again just to silence a finding.",
     ],
     modeHeading: "Recommended way",
-    modeName: { none: "Nothing to fix", light: "Light", bold: "Bold", full: "Full rewrite" },
+    modeName: { none: "Nothing to fix", light: "Light", bold: "Bold", full: "Full rewrite", register: "Register change" },
     modeReason: {
+      chosen: "A rewrite depth is set, so the plan goes to that depth.",
+      "depth-limit": "On its findings alone chaff would rewrite from the structure up, but the depth set is light, so the structure stays.",
       "nothing-found": "chaff found nothing.",
+      "all-deeper":
+        'Every finding comes from a rule that rewrites deeper than the depth set. There is nothing to fix at this depth (see "Rules deeper than the depth set" below).',
       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.",
     },
     modeWays: [
-      "Light: only the flagged spots.",
-      "Bold: keep the outline, rewrite the prose of each section.",
-      'Full: take an inventory of the facts and claims, then rewrite from the structure up. If the request says "from scratch", choose this.',
+      "Light (depth light): only the flagged spots.",
+      "Bold (depth light): keep the outline, rewrite the prose of each section.",
+      'Full (depth structure): take an inventory of the facts and claims, then rewrite from the structure up. If the request says "from scratch", choose this.',
+      "Register (depth register): a full rewrite that also converts the style (polite to plain endings, and so on). chaff never recommends it; choose it with --depth register.",
     ],
+    depthLine: (depth, meaning, setBy) => `Rewrite depth: ${depth} (${meaning})${setBy}.`,
+    depthSetBy: { flag: ", set by --depth", config: ", set by fix_plan.depth in chaff.yaml" },
+    ruleDepth: "Depth",
+    deeperHeading: "Rules deeper than the depth set",
+    deeperNote: (chosen) =>
+      `These rules fired too, but their direction goes deeper than ${chosen}, so this plan does not fix them. To fix them, give the rule's depth to --depth and print the plan again.`,
+    deeperLine: (depth, spots) => `depth ${depth}, ${String(spots)} ${spots === 1 ? "spot" : "spots"}`,
     signalsHeading: "Document-level signals",
     noSignals: "None of the rules that measure the whole document said anything.",
     outlineLine: (measures) => `Outline: ${measures}`,

package/src/genre-load.ts

@@ -2,17 +2,20 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse } from "yaml";
-import { parseGenres, presetLevelsOf, presetProfileOf, type GenreData, type PresetLevels } from "./genre-parse.ts";
+import { parseGenres, presetLevelsOf, presetProfileOf, withRuleOffs, type GenreData, type PresetLevels } from "./genre-parse.ts";
+import { loadRuleOffs } from "./rule-offs.ts";
 
-const GENRES_FILE = join(dirname(fileURLToPath(import.meta.url)), "..", "genres.yaml");
+const PACKAGE = join(dirname(fileURLToPath(import.meta.url)), "..");
+const GENRES_FILE = join(PACKAGE, "genres.yaml");
+const RULES_DIR = join(PACKAGE, "rules");
 
 const loaded: { value: GenreData | undefined } = { value: undefined };
 
-/** The bundled genres.yaml. Read once. */
+/** The bundled genres.yaml, with the offs the rule files set (off_for). Read once. */
 export const loadGenres = (): GenreData => {
   if (loaded.value !== undefined) return loaded.value;
   try {
-    loaded.value = parseGenres(parse(readFileSync(GENRES_FILE, "utf8")));
+    loaded.value = withRuleOffs(parseGenres(parse(readFileSync(GENRES_FILE, "utf8"))), loadRuleOffs(RULES_DIR));
   } catch (error) {
     throw new Error(`cannot read ${GENRES_FILE}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }

package/src/genre-parse.ts

@@ -1,5 +1,6 @@
 import { isLevel } from "./levels.ts";
 import type { Level, Localized } from "./plugin.ts";
+import type { RuleOff } from "./rule-offs.ts";
 
 /** A preset's rules: the level each named rule runs at, under whatever chaff.yaml's rules say. */
 export type PresetLevels = Readonly<Record<string, Level>>;
@@ -139,6 +140,24 @@ export const parseGenres = (raw: unknown): GenreData => {
   return { groups, genres };
 };
 
+const withOffsFor = <T extends { readonly id: string; readonly rules: PresetLevels }>(entry: T, offs: readonly RuleOff[]): T => {
+  const mine = offs.filter((off) => off.target === entry.id);
+  const both = mine.find((off) => entry.rules[off.rule] !== undefined);
+  if (both !== undefined) throw new Error(`${both.rule}: its off_for and genres.yaml both set its level for ${entry.id}`);
+  return mine.length === 0 ? entry : { ...entry, rules: { ...entry.rules, ...Object.fromEntries(mine.map((off) => [off.rule, "off" as const])) } };
+};
+
+/**
+ * genres.yaml's data with each rule file's off_for merged in. An off for a group joins the group's rules and an off for
+ * a genre the genre's own, so a genre's own level still wins over its group's. An off naming no group or genre stops here.
+ */
+export const withRuleOffs = (data: GenreData, offs: readonly RuleOff[]): GenreData => {
+  const known = new Set([...data.groups, ...data.genres].map((entry) => entry.id));
+  const unknown = offs.find((off) => !known.has(off.target));
+  if (unknown !== undefined) throw new Error(`${unknown.rule}: off_for names ${unknown.target}, which is no group or genre`);
+  return { groups: data.groups.map((group) => withOffsFor(group, offs)), genres: data.genres.map((genre) => withOffsFor(genre, offs)) };
+};
+
 /** The levels a genre's preset sets: its group's, then its own on top. Empty for a genre chaff does not know. */
 export const presetLevelsOf = (data: GenreData, genre: string): PresetLevels => {
   const own = data.genres.find((entry) => entry.id === genre);

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: "; ",
+  },
+};