@pmelab/gtd 44.0.0 → 45.0.0

package/src/workflow-kit/review.ts

@@ -70,6 +70,12 @@ export interface ReviewPolicy {
   readonly fixNits: (notes: readonly ReviewNote[]) => Promise<void>
   /** Told every note the human answered this round, before any of them is routed. */
   readonly decided?: (decisions: readonly ReviewDecision[]) => void
+  /** An answer the policy settles in `learn` itself: never routed, recorded or told to `decided`. */
+  readonly settles?: (decision: ReviewDecision) => boolean
+  /** Reads every answer of the round once it is recorded, before any is routed. */
+  readonly learn?: (decisions: readonly ReviewDecision[]) => Promise<void>
+  /** Something still waits on the human's answer: a sign-off writes the review again instead. */
+  readonly pending?: () => boolean
   /** Remove `file` at the end of a round at commit `round`. */
   readonly close: (round: string) => Promise<void>
   /** What a collecting turn reads. */
@@ -222,6 +228,19 @@ const record = (p: ReviewPolicy, decisions: readonly ReviewDecision[]): void =>
   for (const d of decisions) if (d.choice === "wontfix") mark("wontfix", oneLine(d.anchor))
 }
 
+const routed = (p: ReviewPolicy, answers: readonly ReviewDecision[]): readonly ReviewDecision[] =>
+  answers.filter((d) => p.settles?.(d) !== true)
+
+/** Record the routed answers on the gate's commit, then hand every answer to `learn`. */
+const recordAndLearn = async (
+  p: ReviewPolicy,
+  decisions: readonly ReviewDecision[],
+  answers: readonly ReviewDecision[],
+): Promise<void> => {
+  record(p, decisions)
+  if (answers.length > 0 && p.learn !== undefined) await p.learn(answers)
+}
+
 /**
  * Judge every note, then run each verdict's route: answers, then nit fixes,
  * then the edits' lap. Of the human's `decisions`, a fix joins the nit batch
@@ -233,8 +252,9 @@ export const routeNotes = async (
   notes: readonly ReviewNote[],
   r: Round,
   decisions: readonly ReviewDecision[] = [],
+  answers: readonly ReviewDecision[] = decisions,
 ): Promise<Finish> => {
-  record(p, decisions)
+  await recordAndLearn(p, decisions, answers)
   const of = (c: ReviewDecision["choice"]) => decisions.filter((d) => d.choice === c)
   const fixes = of("fix").map((d, i) => decisionNote(d, `fix-${i + 1}`, d.body))
   const judged = [
@@ -313,14 +333,14 @@ const settledAfter = (
 
 const finishNotes = async (
   p: ReviewPolicy,
-  before: string | undefined,
-  decisions: readonly ReviewDecision[],
+  notes: readonly ReviewNote[],
+  answers: readonly ReviewDecision[],
   reopened: boolean,
   ctx: Parameters<typeof routeNotes>[2],
 ): Promise<Finish> => {
-  // An unchanged review file has no baseline entry, which would read as all-new.
-  const notes = reviewNotes(before ?? "", read(p.file) ?? "")
-  if (notes.length + decisions.length > 0) return routeNotes(p, notes, ctx, decisions)
+  // An answer the policy settles still routes, if only to learn: there is nothing to collect.
+  if (notes.length + answers.length > 0)
+    return routeNotes(p, notes, ctx, routed(p, answers), answers)
   if (reopened) return ctx.unfolded()
   await ctx.close()
   return ctx.outcome(await collect(p, p.captures.notes(ctx.round), "notes"))
@@ -343,6 +363,12 @@ const decisionsSince = (
   return reviewDecisions(since.get(p.file)?.before ?? after, after)
 }
 
+// An unchanged review file has no baseline entry, which would read as all-new.
+const notesSince = (
+  p: ReviewPolicy,
+  since: ReturnType<typeof changesSince>,
+): readonly ReviewNote[] => reviewNotes(since.get(p.file)?.before ?? "", read(p.file) ?? "")
+
 const finish = async (
   p: ReviewPolicy,
   reviewed: string,
@@ -368,12 +394,14 @@ const finish = async (
   // Thread-only edits settled the round, but a change note or hand-edit since
   // `reviewed` must still reach a collecting turn when a dropped edit is refused.
   const reopened = isReopened(p, { settled, folded })
-  const decisions = decisionsSince(p, since)
-  if ((settled && !reopened && decisions.length === 0) || (edited.length === 0 && !noted))
+  const answers = decisionsSince(p, since)
+  if ((settled && !reopened && answers.length === 0) || (edited.length === 0 && !noted))
     return unfolded()
+  // Read before `learn`, which may add to the review file.
+  const notes = notesSince(p, since)
   if (edited.length > 0) {
     // A hand-edit plans a lap; its collecting turn reads the answers in the review.
-    record(p, decisions)
+    await recordAndLearn(p, routed(p, answers), answers)
     await close()
     return outcome(
       await collect(p, p.captures.edits(round, reopened ? reviewed : undefined), "edits", {
@@ -382,7 +410,7 @@ const finish = async (
       }),
     )
   }
-  return finishNotes(p, since.get(p.file)?.before, decisions, reopened, {
+  return finishNotes(p, notes, answers, reopened, {
     round,
     close,
     outcome,
@@ -390,6 +418,12 @@ const finish = async (
   })
 }
 
+/** A sign-off while something waits on the human writes the review again instead. */
+const unlessPending = (p: ReviewPolicy, result: Finish): Finish =>
+  "verdict" in result && result.verdict === "signoff" && p.pending?.() === true
+    ? { next: "rereview", carry: undefined }
+    : result
+
 /** Write the review; if it marks risks, fix them, keep green, and write it again — once, so the re-review's own risks reach the human unfixed. */
 const reviewOnce = async (
   p: Pick<ReviewPolicy, "file" | "reviewing" | "fixRisks" | "keepGreen">,
@@ -420,7 +454,7 @@ export const review = async (base: string, p: ReviewPolicy): Promise<ReviewOutco
     for (;;) {
       collectedAt = await converse(p, base, reviewed, collectedAt)
       if (collectedAt === "missing") break
-      const result = await finish(p, reviewed, collectedAt)
+      const result = unlessPending(p, await finish(p, reviewed, collectedAt))
       if (!("next" in result)) return result
       if (result.next === "rereview") {
         carry = result.carry

package/src/workflows/feature/review-answers.feature

@@ -114,12 +114,16 @@ Feature: every note in the review is answered with one tick
     Then landing is refused with "answer-completeness"
 
   Scenario: won't fix drops the note, records it, and signs off
+    Given judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"no","p":0.9}]
+      """
     When the process is driven
     And the text "- [ ] won't fix" in ".gtd/REVIEW.md" is replaced with "- [x] won't fix"
     And gtd lands
     And the process is driven
     Then the process rests at "idle"
-    And the commit "gtd(human): build.review.await-review → build.review.closing" has a body containing "Gtd-Mark: wontfix=AC-1 ignores floating point"
+    And the commit "gtd(human): build.review.await-review → build.review.standards.judge" has a body containing "Gtd-Mark: wontfix=AC-1 ignores floating point"
     And ".gtd/TODO.md" does not exist
     And no commit body contains "build.review.triage"
 
@@ -145,7 +149,11 @@ Feature: every note in the review is answered with one tick
     Then the process rests at "idle"
 
   Scenario: an own answer is judged like a note
-    Given judge step "build.review.triage" answers:
+    Given judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"no","p":0.9}]
+      """
+    And judge step "build.review.triage" answers:
       """
       [{"id":"answer-1","answer":"nit","p":0.9}]
       """
@@ -163,7 +171,8 @@ Feature: every note in the review is answered with one tick
     Then the process rests at "build.review.await-review"
     And the commit subjects end with:
       """
-      gtd(human): build.review.await-review → build.review.triage
+      gtd(human): build.review.await-review → build.review.standards.judge
+      gtd(judge): build.review.standards.judge → build.review.triage
       gtd(judge): build.review.triage → build.review.fix.nits.fixing
       gtd(agent): build.review.fix.nits.fixing → build.health.check
       gtd(check): build.health.check → build.review.closing

package/src/workflows/feature/standards.feature

@@ -0,0 +1,286 @@
+@inmem
+Feature: the review learns standards from the human's answers
+
+  A won't-fix tick or an own answer at the review gate is a candidate
+  standard. A judge asks whether it is reusable; above `standardMinP` it is
+  kept in `.gtd/STANDARDS.md` with no further question, and every later agent
+  turn — lenses and coder alike — is told to follow it. One that contradicts
+  a standard already kept becomes a note in `.gtd/REVIEW.md` the review cannot
+  sign off without: keep the new one, keep the old one, or write the merged
+  wording.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    And an environment variable "GTD_FLAGMODE" set to "false"
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And the working tree is committed as "feat: add calculator"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Subtract
+
+      - `subtract(a, b)` returns `a - b`.
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      """
+    And step "design.gate.answer" changes nothing
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And step "seam.check" changes nothing
+    And step "implement.applying" runs its script
+    And step "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
+    And step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
+      """
+      # Quality
+
+      ## subtract has no class
+
+      Calculators read better as classes.
+      """
+    And step "build.quality.sorting" runs its script
+    And step "build.review.composing" runs its script
+    And judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"design","p":0.9}]
+      """
+    And step "build.review.closing" runs its script
+    And step "build.review.standards.recording" runs its script
+    And step "build.review.standards.raising" runs its script
+
+  Scenario: a won't-fix the judge calls reusable is kept, and the review signs off
+    Given judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"yes","p":0.9}]
+      """
+    When the process is driven
+    And the text "- [ ] won't fix" in ".gtd/REVIEW.md" is replaced with "- [x] won't fix"
+    And gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/STANDARDS.md" contains:
+      """
+      - Won't fix: subtract has no class — Calculators read better as classes.
+      """
+    And the commit subjects end with:
+      """
+      gtd(human): build.review.await-review → build.review.standards.judge
+      gtd(judge): build.review.standards.judge → build.review.standards.recording
+      gtd(check): build.review.standards.recording → build.review.closing
+      gtd(check): build.review.closing → idle
+      """
+
+  Scenario: the next review lists the standards added
+    Given judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"yes","p":0.9}]
+      """
+    And judge step "build.review.triage" answers:
+      """
+      [{"id":"answer-1","answer":"nit","p":0.9}]
+      """
+    And step "build.review.fix.nits.fixing" writes "src/calc.ts" with:
+      """
+      export function add(a: number, b: number) { return a + b }
+      export function subtract(a: number, b: number) { return a - b }
+      """
+    And step "build.health.check" changes nothing
+    When the process is driven
+    And the text "- [ ] _your answer_" in ".gtd/REVIEW.md" is replaced with "- [x] Calculators are plain functions."
+    And gtd lands
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## Standards added
+
+      Learned from your answers and kept in `.gtd/STANDARDS.md`:
+
+      - Calculators are plain functions. (re: subtract has no class)
+      """
+
+  Scenario: an answer below the threshold is not kept
+    Given judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"yes","p":0.6}]
+      """
+    When the process is driven
+    And the text "- [ ] won't fix" in ".gtd/REVIEW.md" is replaced with "- [x] won't fix"
+    And gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/STANDARDS.md" does not exist
+
+  Scenario: a kept standard reaches the lenses and the coder of a later process
+    Given a file ".gtd/STANDARDS.md" with:
+      """
+      # Standards
+
+      - Won't fix: subtract has no class — Calculators read better as classes.
+      """
+    And the working tree is committed as "chore: keep a standard"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      Please add subtract(a, b).
+      """
+    And step "seam.naive" is prompted with "- Won't fix: subtract has no class"
+    And step "build.quality.correctness.reviewing" is prompted with "- Won't fix: subtract has no class"
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+
+  Scenario: a contradicting standard blocks sign-off until the human picks one
+    Given a file ".gtd/STANDARDS.md" with:
+      """
+      # Standards
+
+      - Calculators are classes.
+      """
+    And the working tree is committed as "chore: keep a standard"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      Please add subtract(a, b).
+      """
+    And judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"yes","p":0.9},{"id":"standard-1.contradicts-1","answer":"yes","p":0.8}]
+      """
+    And judge step "build.review.triage" answers:
+      """
+      [{"id":"answer-1","answer":"praise","p":0.9}]
+      """
+    When the process is driven
+    And the text "- [ ] _your answer_" in ".gtd/REVIEW.md" is replaced with "- [x] Calculators are plain functions."
+    And gtd lands
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/STANDARDS.md" contains:
+      """
+      - Calculators are classes.
+
+      ## Undecided
+
+      - Calculators are plain functions. (re: subtract has no class)
+        - contradicts: Calculators are classes.
+      """
+    And ".gtd/REVIEW.md" contains "## Standard conflict "
+    And ".gtd/REVIEW.md" contains:
+      """
+      New: Calculators are plain functions. (re: subtract has no class)
+
+      Old:
+
+      - Calculators are classes.
+
+      Tick exactly one:
+
+      - [ ] keep the new one (drop the old)
+      - [ ] keep the old one (discard the new)
+      - [ ] _your answer_
+      """
+    And ".gtd/REVIEW.md" does not contain "## subtract has no class"
+    And landing is refused with "answer-completeness: 1 note(s) in .gtd/REVIEW.md not answered"
+    When the text "- [ ] keep the new one (drop the old)" in ".gtd/REVIEW.md" is replaced with "- [x] keep the new one (drop the old)"
+    And gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/STANDARDS.md" contains "- Calculators are plain functions. (re: subtract has no class)"
+    And ".gtd/STANDARDS.md" does not contain "Calculators are classes."
+    And ".gtd/STANDARDS.md" does not contain "Undecided"
+
+  Scenario: keeping the old standard discards the new one
+    Given a file ".gtd/STANDARDS.md" with:
+      """
+      # Standards
+
+      - Calculators are classes.
+      """
+    And the working tree is committed as "chore: keep a standard"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      Please add subtract(a, b).
+      """
+    And judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"yes","p":0.9},{"id":"standard-1.contradicts-1","answer":"yes","p":0.8}]
+      """
+    When the process is driven
+    And the text "- [ ] won't fix" in ".gtd/REVIEW.md" is replaced with "- [x] won't fix"
+    And gtd lands
+    And the process is driven
+    And the text "- [ ] keep the old one (discard the new)" in ".gtd/REVIEW.md" is replaced with "- [x] keep the old one (discard the new)"
+    And gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/STANDARDS.md" contains:
+      """
+      # Standards
+
+      Kept from your review answers for every agent turn. One standard per bullet.
+
+      - Calculators are classes.
+      """
+    And ".gtd/STANDARDS.md" does not contain "Won't fix"
+
+  Scenario: an own answer to a conflict replaces both with its wording
+    Given a file ".gtd/STANDARDS.md" with:
+      """
+      # Standards
+
+      - Calculators are classes.
+      """
+    And the working tree is committed as "chore: keep a standard"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      Please add subtract(a, b).
+      """
+    And judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"yes","p":0.9},{"id":"standard-1.contradicts-1","answer":"yes","p":0.8}]
+      """
+    When the process is driven
+    And the text "- [ ] won't fix" in ".gtd/REVIEW.md" is replaced with "- [x] won't fix"
+    And gtd lands
+    And the process is driven
+    And the text "- [ ] _your answer_" in ".gtd/REVIEW.md" is replaced with "- [x] Calculators with state are classes."
+    And gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/STANDARDS.md" contains "- Calculators with state are classes."
+    And ".gtd/STANDARDS.md" does not contain "- Calculators are classes."
+    And ".gtd/STANDARDS.md" does not contain "Won't fix"

package/src/workflows/review/review-door.feature

@@ -59,6 +59,10 @@ Feature: the review door fixes its notes in the same process
       """
 
   Scenario: a won't-fix signs off, and no review is left for fix
+    Given judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"no","p":0.9}]
+      """
     When gtd opens door "review" with "HEAD~1"
     And the process is driven
     And the text "- [ ] won't fix" in ".gtd/REVIEW.md" is replaced with "- [x] won't fix"
@@ -96,7 +100,11 @@ Feature: the review door fixes its notes in the same process
     And ".gtd/REVIEW.orig.md" does not exist
 
   Scenario: an own answer asking for a change is fixed in place, then reviewed again
-    Given judge step "build.review.triage" answers:
+    Given judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"no","p":0.9}]
+      """
+    And judge step "build.review.triage" answers:
       """
       [{"id":"answer-1","answer":"edit","p":0.9}]
       """
@@ -123,7 +131,8 @@ Feature: the review door fixes its notes in the same process
     Then the process rests at "build.review.await-review"
     And the commit subjects end with:
       """
-      gtd(human): build.review.await-review → build.review.triage
+      gtd(human): build.review.await-review → build.review.standards.judge
+      gtd(judge): build.review.standards.judge → build.review.triage
       gtd(judge): build.review.triage → build.review.closing
       gtd(check): build.review.closing → build.review.collecting
       gtd(agent): build.review.collecting → re-unwind

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([])
+  })
+})