@pmelab/gtd 44.0.0 → 45.1.0

package/src/workflows/review/review.ts

@@ -1,24 +1,11 @@
-import { read, refuse, removeScript, run, start, type WorkflowBase } from "../../flows/index.js"
-import { buildTail, reUnwind } from "../shared/review.js"
+import { read, refuse, start, type WorkflowBase } from "../../flows/index.js"
+import { buildTail, fixFeedback, reUnwind } from "../shared/review.js"
 import { gate } from "../shared/health.js"
 import { shipped } from "../shared/options.js"
-import { coder, REQUIREMENTS } from "../shared/steps.js"
+import { REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 
-/** Build the concerns a review round collected into `.gtd/REQUIREMENTS.md`, then remove it. */
-const fixFeedback = async (): Promise<void> => {
-  await t.agentWithSkills("feedback.fixing", t.reviewFeedbackFixPrompt(), {
-    label: "Fixing your review feedback",
-    file: REQUIREMENTS,
-    model: coder(),
-    system: t.finisherSystem(),
-    // An earlier nit fix may already have built the concern.
-    allowEmpty: true,
-  })
-  await run("feedback.closing", removeScript([REQUIREMENTS]), { label: "Closing the feedback" })
-}
-
 /**
  * The feature's review of everything since `reviewBase` — a green gate, the
  * triaged quality lap, then the human review — with no design phase: a

package/src/workflows/shared/learn.test.ts

@@ -0,0 +1,154 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const state = vi.hoisted(() => ({
+  files: {} as Record<string, string | undefined>,
+  vars: { standardMinP: "0.8" } as Record<string, string>,
+  answers: {} as Record<string, { answer: string; p: number } | undefined>,
+  judged: [] as string[][],
+  written: {} as Record<string, string>,
+}))
+
+vi.mock("../../flows/index.js", async (original) => ({
+  ...(await original<typeof import("../../flows/index.js")>()),
+  read: (path: string) => state.files[path],
+  vars: state.vars,
+  judge: async (_: string, spec: { questions: { id: string }[] }) => {
+    state.judged.push(spec.questions.map((q) => q.id))
+    return { answers: state.answers, truncated: [] }
+  },
+  run: async (_: string, script: string) => {
+    const path = /> '([^']+)'/.exec(script)?.[1] ?? ""
+    const content = /printf '%s' '((?:[^']|'\\'')*)'/.exec(script)?.[1] ?? ""
+    state.written[path] = content.replaceAll("'\\''", "'")
+  },
+}))
+
+import type { ReviewDecision } from "../../steering/index.js"
+import { learnStandards } from "./learn.js"
+
+const STANDARDS = ".gtd/STANDARDS.md"
+
+const file = (...lines: string[]): string =>
+  [
+    "# Standards",
+    "",
+    "Kept from your review answers for every agent turn. One standard per bullet.",
+    "",
+    ...lines,
+    "",
+  ].join("\n")
+
+const answer = (anchor: string, text: string): ReviewDecision => ({
+  anchor,
+  body: "",
+  choice: "answer",
+  text,
+})
+
+const yes = { answer: "yes", p: 0.9 }
+const no = { answer: "no", p: 0.9 }
+const kept = () => state.written[STANDARDS]
+
+beforeEach(() => {
+  state.files = { ".gtd/REVIEW.md": "# Review\n" }
+  state.vars.standardMinP = "0.8"
+  state.answers = {}
+  state.judged = []
+  state.written = {}
+})
+
+describe("learnStandards", () => {
+  it("asks a later candidate about each earlier one, and holds a contradiction for the human", async () => {
+    state.answers = { "standard-1": yes, "standard-2": yes, "standard-2.contradicts-new-1": yes }
+    await learnStandards([answer("A", "Use classes."), answer("B", "Never use classes.")])
+    expect(state.judged[0]).toContain("standard-2.contradicts-new-1")
+    expect(kept()).toBe(
+      file(
+        "- Use classes. (re: A)",
+        "",
+        "## Undecided",
+        "",
+        "- Never use classes. (re: B)",
+        "  - contradicts: Use classes. (re: A)",
+      ),
+    )
+  })
+
+  it("raises a contradiction ruled out below the threshold", async () => {
+    state.files[STANDARDS] = file("- Old.")
+    state.answers = { "standard-1": yes, "standard-1.contradicts-1": { answer: "no", p: 0.5 } }
+    await learnStandards([answer("A", "New.")])
+    expect(kept()).toBe(
+      file("- Old.", "", "## Undecided", "", "- New. (re: A)", "  - contradicts: Old."),
+    )
+  })
+
+  it("keeps one the judge confidently calls compatible", async () => {
+    state.files[STANDARDS] = file("- Old.")
+    state.answers = { "standard-1": yes, "standard-1.contradicts-1": no }
+    await learnStandards([answer("A", "New.")])
+    expect(kept()).toBe(file("- Old.", "- New. (re: A)"))
+  })
+
+  it("asks no judge when standardMinP is blank", async () => {
+    state.vars.standardMinP = ""
+    await learnStandards([answer("A", "New.")])
+    expect(state.judged).toEqual([])
+    expect(state.written).toEqual({})
+  })
+
+  it("drops a replaced standard from another open conflict", async () => {
+    state.files[STANDARDS] = file(
+      "- O.",
+      "",
+      "## Undecided",
+      "",
+      "- A.",
+      "  - contradicts: O.",
+      "- B.",
+      "  - contradicts: O.",
+    )
+    // The conflict note's title hashes its new standard, "A.".
+    await learnStandards([
+      { anchor: "Standard conflict 01248e26", body: "", choice: "fix", text: "" },
+    ])
+    expect(kept()).toBe(file("- A.", "", "## Undecided", "", "- B."))
+  })
+})
+
+describe("learnStandards, from a won't-fix", () => {
+  it("states the finding, not gtd's banner", async () => {
+    state.answers = { "standard-1": yes }
+    await learnStandards([
+      {
+        anchor: "Slow loop",
+        // As the review parser hands it over: paragraphs joined by a space.
+        body: "_The fixer left this unresolved._ The loop is quadratic.",
+        choice: "wontfix",
+        text: "",
+      },
+    ])
+    expect(kept()).toBe(file("- Won't fix: Slow loop — The loop is quadratic."))
+  })
+
+  it("replaces an old standard hand-edited in case only", async () => {
+    state.files[STANDARDS] = file(
+      "- use classes.",
+      "",
+      "## Undecided",
+      "",
+      "- A.",
+      "  - contradicts: Use classes.",
+    )
+    await learnStandards([
+      { anchor: "Standard conflict 01248e26", body: "", choice: "fix", text: "" },
+    ])
+    expect(kept()).toBe(file("- A."))
+  })
+
+  it("does not learn again what a formatter rewrote", async () => {
+    state.files[STANDARDS] = file("- Prefer _named_ exports. (re: A)")
+    await learnStandards([answer("A", "Prefer *named* exports.")])
+    expect(state.judged).toEqual([])
+  })
+})

package/src/workflows/shared/learn.ts

@@ -0,0 +1,206 @@
+import {
+  answered,
+  changesSince,
+  judge,
+  numeric,
+  read,
+  run,
+  vars,
+  writeScript,
+  type JudgeQuestion,
+} from "../../flows/index.js"
+import type { ReviewDecision } from "../../steering/index.js"
+import {
+  conflictBody,
+  conflictFor,
+  conflictTitle,
+  isConflictTitle,
+  oneLine,
+  parseStandards,
+  standardKey,
+  renderStandards,
+  STANDARDS,
+  type Conflict,
+  type Standards,
+} from "./standards.js"
+import { REVIEW } from "./steps.js"
+
+interface Candidate {
+  readonly decision: ReviewDecision
+  readonly text: string
+}
+
+const SUMMARY_MAX = 200
+
+// The banners composedReview opens a note with say nothing about the finding; the
+// parsed body has its paragraphs joined, so they are matched by their own text.
+const BANNER =
+  /^_(?:The fixer left this unresolved\.|A fix turn removed this while renaming another finding — check whether it was fixed\.|No detail given\.)_\s*/
+
+const summary = (body: string): string => {
+  const text = oneLine(body).replace(BANNER, "")
+  return text.length > SUMMARY_MAX ? `${text.slice(0, SUMMARY_MAX - 1)}…` : text
+}
+
+/** The standard a won't-fix or an own answer would make; a fix states none. */
+const candidateOf = (d: ReviewDecision): Candidate[] => {
+  const anchor = oneLine(d.anchor)
+  if (d.choice === "wontfix") {
+    const why = summary(d.body)
+    return [{ decision: d, text: `Won't fix: ${anchor}${why === "" ? "" : ` — ${why}`}` }]
+  }
+  if (d.choice === "answer") return [{ decision: d, text: `${oneLine(d.text)} (re: ${anchor})` }]
+  return []
+}
+
+// By key, as everywhere else: a hand-edit to case or emphasis still names the same standard.
+const without = (list: readonly string[], drop: readonly string[]): string[] => {
+  const keys = new Set(drop.map(standardKey))
+  return list.filter((s) => !keys.has(standardKey(s)))
+}
+
+const adding = (list: readonly string[], text: string): string[] =>
+  list.some((s) => standardKey(s) === standardKey(text)) ? [...list] : [...list, text]
+
+/**
+ * Keep the new one, keep the old one, or replace both with the human's own
+ * wording. Another open conflict stops naming a replaced standard: the human
+ * never judged it against the replacement, so keeping it must not drop that.
+ */
+const resolve = (standards: Standards, d: ReviewDecision): Standards => {
+  const c = conflictFor(standards, d.anchor)
+  if (c === undefined) return standards
+  const others = standards.undecided.filter((u) => u !== c)
+  if (d.choice === "wontfix") return { decided: standards.decided, undecided: others }
+  const kept = d.choice === "fix" ? c.text : oneLine(d.text)
+  const undecided = others.map((u) => ({ text: u.text, olds: without(u.olds, c.olds) }))
+  return { decided: adding(without(standards.decided, c.olds), kept), undecided }
+}
+
+const contradicts = (i: number, id: string, other: string): JudgeQuestion => ({
+  id: `standard-${i}.contradicts-${id}`,
+  primitive: "noul",
+  instructions: `Does the "Standard:" line of evidence "standard-${i}" contradict ${other}?`,
+  criteria:
+    "yes: following one breaks the other. no: both can be followed — they are compatible or unrelated.",
+})
+
+// Each candidate against every kept standard and every candidate before it.
+const questionsFor = (i: number, anchor: string, decided: readonly string[]): JudgeQuestion[] => [
+  {
+    id: `standard-${i}`,
+    primitive: "noul",
+    instructions: `Is the human's answer to review note "${anchor}" (evidence "standard-${i}") a reusable standard for this codebase — a rule later changes and reviews should follow — rather than a call about this one note? Its "Standard:" line is the wording gtd would keep.`,
+    criteria:
+      "yes: it states a rule or preference that applies beyond this note. no: it is specific to this note, a one-off call, or unclear.",
+  },
+  ...decided.map((_, k) =>
+    contradicts(i, `${k + 1}`, `kept standard ${k + 1} (evidence "kept-${k + 1}")`),
+  ),
+  ...Array.from({ length: i - 1 }, (_, j) =>
+    contradicts(i, `new-${j + 1}`, `the "Standard:" line of evidence "standard-${j + 1}"`),
+  ),
+]
+
+const evidenceOf = (c: Candidate): string =>
+  [
+    `Note: ${c.decision.anchor}`,
+    `Reviewer's text: ${c.decision.body}`,
+    `Human's answer: ${c.decision.choice === "wontfix" ? "won't fix" : c.decision.text}`,
+    `Standard: ${c.text}`,
+  ].join("\n")
+
+/**
+ * One judge rest over every candidate. Only a confident `yes` on uncut
+ * evidence makes a standard; a contradiction the judge does not confidently
+ * rule out goes to the human instead of overwriting what they decided before.
+ * A cut kept standard leaves the round unlearned: raise `judgeBudgetBytes`.
+ */
+const judged = async (
+  candidates: readonly Candidate[],
+  decided: readonly string[],
+  minP: number,
+): Promise<{ added: string[]; raised: Conflict[] }> => {
+  const { answers, truncated } = await judge("review.standards.judge", {
+    questions: candidates.flatMap((c, i) => questionsFor(i + 1, c.decision.anchor, decided)),
+    evidence: Object.fromEntries([
+      ...candidates.map((c, i) => [`standard-${i + 1}`, evidenceOf(c)]),
+      ...decided.map((s, k) => [`kept-${k + 1}`, s]),
+    ]),
+    message:
+      "Judging whether your answers are standards to keep: run `gtd judge run`, or land without a verdict, which keeps none.",
+    label: "Learning your standards",
+  })
+  const ruledOut = (i: number, id: string): boolean =>
+    answered(answers[`standard-${i}.contradicts-${id}`], "no", minP)
+  const added: { i: number; text: string }[] = []
+  const raised: Conflict[] = []
+  candidates.forEach((c, n) => {
+    const i = n + 1
+    if (truncated.includes(`standard-${i}`)) return
+    if (decided.some((_, k) => truncated.includes(`kept-${k + 1}`))) return
+    if (!answered(answers[`standard-${i}`], "yes", minP)) return
+    const olds = [
+      ...decided.filter((_, k) => !ruledOut(i, `${k + 1}`)),
+      ...added.filter((a) => !ruledOut(i, `new-${a.i}`)).map((a) => a.text),
+    ]
+    if (olds.length === 0) added.push({ i, text: c.text })
+    else raised.push({ text: c.text, olds })
+  })
+  return { added: added.map((a) => a.text), raised }
+}
+
+/**
+ * Settles every answer to a standard conflict, then learns standards from
+ * the won't-fix ticks and own answers: kept in `.gtd/STANDARDS.md`, a
+ * contradicting one as a new conflict note in `.gtd/REVIEW.md`.
+ */
+export const learnStandards = async (decisions: readonly ReviewDecision[]): Promise<void> => {
+  const before = parseStandards(read(STANDARDS) ?? "")
+  const rest = decisions.filter((d) => !isConflictTitle(d.anchor))
+  const settled = decisions.filter((d) => isConflictTitle(d.anchor)).reduce(resolve, before)
+  const known = new Set(
+    [...settled.decided, ...settled.undecided.map((c) => c.text)].map(standardKey),
+  )
+  const candidates = rest.flatMap(candidateOf).filter((c) => {
+    const key = standardKey(c.text)
+    if (known.has(key)) return false
+    known.add(key)
+    return true
+  })
+  // Blank keeps none, so there is nothing to ask.
+  const minP = numeric(vars.standardMinP, Infinity)
+  const { added, raised } =
+    candidates.length === 0 || !Number.isFinite(minP)
+      ? { added: [], raised: [] }
+      : await judged(candidates, settled.decided, minP)
+  const after: Standards = {
+    decided: [...settled.decided, ...added],
+    undecided: [...settled.undecided, ...raised],
+  }
+  if (renderStandards(after) !== renderStandards(before)) {
+    await run("review.standards.recording", writeScript(STANDARDS, renderStandards(after)), {
+      label: "Recording your standards",
+    })
+  }
+  if (raised.length > 0) {
+    const chunks = raised.map((c) => `## ${conflictTitle(c)}\n\n${conflictBody(c)}`)
+    await run(
+      "review.standards.raising",
+      writeScript(REVIEW, `${(read(REVIEW) ?? "").trimEnd()}\n\n${chunks.join("\n\n")}\n`),
+      { label: "Asking about a contradicting standard", file: REVIEW },
+    )
+  }
+}
+
+export const settlesStandard = (d: ReviewDecision): boolean => isConflictTitle(d.anchor)
+
+export const standardsPending = (): boolean =>
+  parseStandards(read(STANDARDS) ?? "").undecided.length > 0
+
+export const standardsAddedSince = (base: string): readonly string[] => {
+  const change = changesSince(base).get(STANDARDS)
+  if (change === undefined) return []
+  const was = new Set(parseStandards(change.before ?? "").decided)
+  return parseStandards(change.after ?? "").decided.filter((s) => !was.has(s))
+}

package/src/workflows/shared/lenses.ts

@@ -29,7 +29,11 @@ type FindingKind = "mechanical" | "noise" | "design"
 /** What the triaged quality lap did with its findings, for the review to list. */
 export interface LensReport {
   /** Design findings, then the mechanical ones the fix cap left. */
-  readonly notes: readonly (Finding & { readonly unresolved?: true; readonly unclear?: true })[]
+  readonly notes: readonly (Finding & {
+    readonly unresolved?: true
+    readonly unclear?: true
+    readonly answers?: readonly [string, string]
+  })[]
   readonly fixed: readonly (Finding & { readonly commit: string })[]
   readonly noise: readonly (Finding & { readonly p: number })[]
 }

package/src/workflows/shared/options.ts

@@ -9,7 +9,7 @@ import {
   scope,
   vars,
 } from "../../flows/index.js"
-import { defaultFlagRegistry, defaults, envDefaults } from "./vars.js"
+import { defaultFlagRegistry, defaults, envDefaults, testsDefaults } from "./vars.js"
 
 const setting = Schema.optionalWith(Schema.String, { exact: true })
 
@@ -20,6 +20,7 @@ export const ShippedOptions = Schema.Struct({
   reviewNoteActionable: setting,
   reviewSeverityMinP: setting,
   qualityTriageMinP: setting,
+  standardMinP: setting,
   refactorFlagPattern: setting,
   seamAllow: setting,
   sliceMaxCriteria: setting,
@@ -106,3 +107,23 @@ export const flagShipped = (
       }
     },
   )
+
+export const TestsOptions = Schema.Struct({
+  ...ShippedOptions.fields,
+  testFiles: setting,
+  skipPattern: setting,
+})
+
+export type TestsOptions = Schema.Schema.Encoded<typeof TestsOptions>
+
+export const testsShipped = (flow: Flow): WorkflowFactory<TestsOptions> =>
+  defineWorkflow(
+    Schema.standardSchemaV1(TestsOptions, { onExcessProperty: "error", errors: "all" }),
+    ({ contextLimit, ...options }) => ({
+      flow: limited(flow, contextLimit),
+      defaults: over({ ...defaults, ...testsDefaults }, options),
+      envDefaults: over(envDefaults, options),
+      doors: { tests: {} },
+      base: undefined,
+    }),
+  )

package/src/workflows/shared/review.ts

@@ -4,6 +4,8 @@ import {
   head,
   judge,
   numeric,
+  read,
+  removeScript,
   requireRevert,
   restoreScript,
   run,
@@ -21,6 +23,7 @@ import { NO_FINDINGS, type LensReport } from "./lenses.js"
 import {
   answerReviewQuestions,
   awaitReview,
+  coder,
   collecting,
   fixCheck,
   fixNits,
@@ -30,6 +33,8 @@ import {
   REVIEW,
   reviewMissing,
 } from "./steps.js"
+import { learnStandards, settlesStandard, standardsAddedSince, standardsPending } from "./learn.js"
+import { parseStandards, STANDARDS } from "./standards.js"
 import { closeReview, isOptionalObject, tail, type TailOptions } from "./tail.js"
 import * as t from "./text.js"
 
@@ -191,6 +196,10 @@ const composing = (
             weakened: kit.removedAssertions(changesSince(base)),
             nitFix,
             answered,
+            standards: {
+              added: standardsAddedSince(base),
+              undecided: parseStandards(read(STANDARDS) ?? "").undecided,
+            },
           }),
           [QUALITY],
         )
@@ -211,7 +220,7 @@ export const humanReview = (
   escalations: EscalationCount = { rounds: 0 },
   options: Omit<BuildTailOptions, "fixFirst" | "green"> = {},
 ): Promise<kit.ReviewOutcome> => {
-  const { guard, guardRests, fixAccess, rules } = options
+  const { guard, guardRests, fixAccess, rules, awaitMessage } = options
   const feedback: FeedbackTarget = options.feedback ?? {
     file: REQUIREMENTS,
     collecting,
@@ -234,11 +243,14 @@ export const humanReview = (
     },
     fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
     keepGreen: () => healthy(() => fixCheck(rules), { escalations, guard, guardRests, rules }),
-    awaitReview: (b) => awaitReview(b),
+    awaitReview: (b) => awaitReview(b, awaitMessage?.(b)),
     reviewMissing,
     collecting: feedback.collecting,
     triage: triage(severities),
     decided: (decisions) => decisions.forEach((d) => answered.add(d.anchor)),
+    settles: settlesStandard,
+    learn: learnStandards,
+    pending: standardsPending,
     answerQuestions: answerReviewQuestions,
     fixNits: async (notes) => {
       await guarded((n: typeof notes) => fixNits(n, fixAccess, rules), guard)(notes)
@@ -293,6 +305,8 @@ export interface BuildTailOptions extends TailOptions {
   readonly lap?: t.ReviewRange | undefined
   /** What the triaged quality lap left for the review; absent: nothing. */
   readonly report?: LensReport | undefined
+  /** The review gate's message for the review base; absent: the quality lap's. */
+  readonly awaitMessage?: ((base: string) => string) | undefined
 }
 
 /** The build tail: fix (when entered red), keep green unless `green`, the triaged quality lap, then human review since `base`. */
@@ -358,6 +372,19 @@ const callForm = (
   return undefined
 }
 
+/** Build the concerns a review round collected into `.gtd/REQUIREMENTS.md`, then remove it. */
+export const fixFeedback = async (): Promise<void> => {
+  await t.agentWithSkills("feedback.fixing", t.reviewFeedbackFixPrompt(), {
+    label: "Fixing your review feedback",
+    file: REQUIREMENTS,
+    model: coder(),
+    system: t.finisherSystem(),
+    // An earlier nit fix may already have built the concern.
+    allowEmpty: true,
+  })
+  await run("feedback.closing", removeScript([REQUIREMENTS]), { label: "Closing the feedback" })
+}
+
 /**
  * Undo the human's review-round code edits. A path changed since the human
  * left it is not overwritten; requireRevert names it instead.

package/src/workflows/shared/skills.test.ts

@@ -22,6 +22,8 @@ describe("the bundled workflow's skills export", () => {
         "build.review.fix.risks",
         "notes",
         "feedback",
+        "tests",
+        "tests.health",
         "refactor",
         "refactor.fix.suite",
         "refactor.health",

package/src/workflows/shared/skills.ts

@@ -24,6 +24,9 @@ export const skills = (
     notes: ["incremental-implementation", "code-simplification"],
     // `review`'s turn building what a review round collected.
     feedback: ["test-driven-development", "incremental-implementation"],
+    // The `tests` workflow's sweep and rewrites.
+    tests: ["test-audit", "test-driven-development"],
+    "tests.health": ["debugging-and-error-recovery"],
     // The refactor's own turns load `ponytail`; `refactor.build.*` carry the `build.*` lists.
     ...build,
     ...Object.fromEntries(Object.entries(build).map(([name, list]) => [`refactor.${name}`, list])),

package/src/workflows/shared/standards.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest"
+import {
+  conflictFor,
+  conflictTitle,
+  parseStandards,
+  renderStandards,
+  standardsBlock,
+} from "./standards.js"
+
+const conflict = { text: "Calculators are functions.", olds: ["Calculators are classes."] }
+
+describe("standards file", () => {
+  it("round-trips decided and undecided standards", () => {
+    const standards = { decided: ["Prefer early returns."], undecided: [conflict] }
+    expect(parseStandards(renderStandards(standards))).toEqual(standards)
+  })
+
+  it("reads a hand-edited file: any heading groups decided ones, wrapped lines join", () => {
+    const text = [
+      "# Standards",
+      "",
+      "Some prose.",
+      "",
+      "## Testing",
+      "",
+      "1. Every bug fix",
+      "  gets a test.",
+      "",
+      "## Undecided",
+      "",
+      "- New",
+      "  - contradicts: Old",
+    ].join("\n")
+    expect(parseStandards(text)).toEqual({
+      decided: ["Every bug fix gets a test."],
+      undecided: [{ text: "New", olds: ["Old"] }],
+    })
+  })
+})
+
+describe("a formatter-wrapped file", () => {
+  it("keeps a wrapped contradicts line with its old standard", () => {
+    const text = [
+      "## Undecided",
+      "",
+      "- Calculators are plain functions. (re: subtract has no class)",
+      "  - contradicts: Won't fix: subtract has no class — Calculators read better as",
+      "    classes.",
+    ].join("\n")
+    expect(parseStandards(text).undecided).toEqual([
+      {
+        text: "Calculators are plain functions. (re: subtract has no class)",
+        olds: ["Won't fix: subtract has no class — Calculators read better as classes."],
+      },
+    ])
+  })
+})
+
+describe("conflict notes", () => {
+  it("keep their title when a formatter rewrites the emphasis", () => {
+    const standards = { decided: [], undecided: [{ text: "Use _named_ exports.", olds: [] }] }
+    expect(
+      conflictFor(standards, conflictTitle({ text: "Use *named* exports.", olds: [] })),
+    ).toBeDefined()
+  })
+
+  it("are one per standard, however often the file lists it", () => {
+    const text = "## Undecided\n\n- New\n  - contradicts: Old\n- New\n  - contradicts: Old\n"
+    expect(parseStandards(text).undecided).toHaveLength(1)
+  })
+
+  it("title back to the conflict it asks about", () => {
+    const standards = { decided: [], undecided: [conflict] }
+    expect(conflictFor(standards, conflictTitle(conflict))).toBe(conflict)
+    expect(conflictFor(standards, "Standard conflict 00000000")).toBeUndefined()
+  })
+})
+
+describe("standardsBlock", () => {
+  it("is empty without decided standards", () => {
+    expect(standardsBlock(undefined)).toBe("")
+    expect(standardsBlock(renderStandards({ decided: [], undecided: [conflict] }))).toBe("")
+  })
+
+  it("lists only the decided ones", () => {
+    const block = standardsBlock(renderStandards({ decided: ["A."], undecided: [conflict] }))
+    expect(block).toContain("- A.")
+    expect(block).not.toContain(conflict.text)
+  })
+})