@pmelab/gtd 43.0.0 → 45.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "43.0.0",
+  "version": "45.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/steering/FORMATS.md

@@ -24,11 +24,11 @@ read them.
   its first line starts `H:`.
 - **Review notes**: what a human added to a `review` document since the reviewer
   wrote it — changed chunk prose, pointer notes, and new one-shot footnotes,
-  never threads. **This is the hand-off from the `review` workflow to the `fix`
-  workflow**: `review` leaves the annotated file beside the reviewer's own copy
+  never threads. **This is the hand-off from a `fix` review to the next `fix`**:
+  the review leaves the annotated file beside the reviewer's own copy
   (`.gtd/REVIEW.orig.md`), and `fix` reads its work from the notes between the
-  two and from the risks, so a file `review` wrote must read the same in any
-  `fix` that consumes it.
+  two and from the risks, so a hand-off file must read the same in any `fix`
+  that consumes it.
 
 ## What may change
 

package/src/workflow-kit/review.test.ts

@@ -199,8 +199,12 @@ const driveRound = async (
     /** Nothing but thread edits lands after the in-gate collecting turn. */
     settled?: boolean
     noDropped?: boolean
+    learn?: ReviewPolicy["learn"]
+    settles?: ReviewPolicy["settles"]
+    pending?: () => boolean
   } = {},
 ) => {
+  let reviews = 0
   const triaged: string[][] = []
   const captured: string[] = []
   const editRanges: (string | undefined)[] = []
@@ -211,9 +215,15 @@ const driveRound = async (
     file: "r.md",
     feedback: "f.md",
     isCode: (path: string) => path.endsWith(".ts"),
-    reviewing: async () => void (state.files["r.md"] = before),
+    reviewing: async () => {
+      reviews++
+      state.files["r.md"] = before
+    },
     fixRisks: async () => {},
     keepGreen: async () => {},
+    learn: opts.learn,
+    settles: opts.settles,
+    pending: opts.pending,
     awaitReview: async () => {
       awaits++
       if (awaits > 2 || (awaits > 1 && opts.inGate === undefined)) throw new Error("stop")
@@ -270,7 +280,7 @@ const driveRound = async (
     },
   } as unknown as ReviewPolicy
   const result = await review("base", p).catch((e: Error) => e)
-  return { result, triaged, dropped, captured, rounds, editRanges }
+  return { result, triaged, dropped, captured, rounds, editRanges, reviews }
 }
 
 describe("a one-shot footnote is a note, a thread footnote is not", () => {
@@ -561,6 +571,74 @@ describe("a note's answer boxes", () => {
   })
 })
 
+describe("learning from the answers", () => {
+  const boxes = (wont: string, own = "_your answer_"): string =>
+    doc(
+      POINTER,
+      "",
+      "## Rounding",
+      "",
+      "Should subtract round?",
+      "",
+      "Tick exactly one:",
+      "",
+      "- [ ] fix as suggested",
+      `- [${wont}] won't fix`,
+      `- [${own === "_your answer_" ? " " : "x"}] ${own}`,
+    )
+
+  it("learn reads every answer once it is marked, before any is routed", async () => {
+    const seen: ReviewDecision[][] = []
+    let marked: string[] = []
+    const r = await driveRound(boxes(" "), boxes("x"), {
+      learn: async (ds) => {
+        seen.push([...ds])
+        marked = [...state.marks]
+      },
+    })
+    expect(seen).toEqual([[expect.objectContaining({ anchor: "Rounding", choice: "wontfix" })]])
+    expect(marked).toEqual(["wontfix=Rounding"])
+    expect(r.result).toEqual({ verdict: "signoff" })
+  })
+
+  it("an answer the policy settles is learned from, never marked, routed or collected", async () => {
+    const seen: ReviewDecision[][] = []
+    const r = await driveRound(boxes(" "), boxes("x"), {
+      settles: () => true,
+      learn: async (ds) => void seen.push([...ds]),
+    })
+    expect(seen).toHaveLength(1)
+    expect(state.marks).toEqual([])
+    expect(r.triaged).toEqual([])
+    expect(r.rounds).toEqual([])
+    expect(r.result).toEqual({ verdict: "signoff" })
+  })
+
+  it("a hand-edit round learns from its answers too", async () => {
+    const seen: ReviewDecision[][] = []
+    await driveRound(boxes(" "), boxes("x"), {
+      handEdit: true,
+      learn: async (ds) => void seen.push([...ds]),
+    })
+    expect(seen).toHaveLength(1)
+  })
+
+  it("learn is not asked when no note was answered", async () => {
+    let asked = false
+    await driveRound(boxes(" "), `${boxes(" ")}\n\nstray prose`, {
+      silent: true,
+      learn: async () => void (asked = true),
+    })
+    expect(asked).toBe(false)
+  })
+
+  it("a sign-off while something is pending writes the review again", async () => {
+    const r = await driveRound(boxes(" "), boxes("x"), { pending: () => true })
+    expect(r.reviews).toBe(2)
+    expect((r.result as Error).message).toBe("stop")
+  })
+})
+
 describe("deleted answer boxes", () => {
   it("are refused even when a reply turn landed them", async () => {
     const withBoxes = doc(

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/coverage.ts

@@ -19,7 +19,7 @@ import {
   type CriteriaSlice,
 } from "./criteria.js"
 import { isTestFile } from "./refactor.js"
-import { isCode } from "./review.js"
+import { isCode } from "../shared/review.js"
 
 /** Below this the judge's `yes` is not trusted: a wrongly covered ID ends the feature without its test. */
 const COVERED_MIN_P = 0.7

package/src/workflows/feature/feature.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest"
 import { runsItsScript, testRepo } from "../../testkit/index.js"
 import { CONFIG_SCAFFOLD } from "../../install/index.js"
 import { reviewDoc } from "../shared/config.fixture.js"
+import type * as featureEntry from "./index.js"
 
 describe("an ordinary feature start", () => {
   it("unwinds a captured TODO, checks the baseline and starts design from it", async () => {
@@ -363,3 +364,10 @@ describe("flagMode", () => {
     expect(repo.subjects()).toEqual(["chore: initial commit"])
   })
 })
+
+// pins the public re-exports from the feature entry point
+export type _PublicBuildTailOptions = [
+  featureEntry.BuildTailOptions,
+  featureEntry.FeedbackTarget,
+  featureEntry.ReviewRange,
+]

package/src/workflows/feature/feature.ts

@@ -26,7 +26,7 @@ import {
   type StatedCriteria,
 } from "./criteria.js"
 import { design } from "./planning.js"
-import { buildTail, isCode, reUnwind, review, type ReviewOutcome } from "./review.js"
+import { buildTail, humanReview, isCode, reUnwind, type ReviewOutcome } from "../shared/review.js"
 import { implement, implementing, seamBuild } from "./seam.js"
 import { sliceCap, sliceCriteria, slicing } from "./slicing.js"
 import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
@@ -153,7 +153,7 @@ const settleQuality = async (): Promise<void> => {
 
 /** The triaged quality lap, then the human review since `base`. */
 const reviewedTail = (base: string, lensBase: string): Promise<ReviewOutcome> =>
-  tail((escalations, report) => review(base, escalations, { report }), {
+  tail((escalations, report) => humanReview(base, escalations, { report }), {
     green: true,
     lensBase,
     triage: true,

package/src/workflows/feature/index.ts

@@ -11,7 +11,7 @@ export {
   type BuildTailOptions,
   type FeedbackTarget,
   type ReviewOutcome,
-} from "./review.js"
+} from "../shared/review.js"
 export type { ReviewRange } from "../shared/text.js"
 export * from "./feature.js"
 export * from "../shared/reserved.js"

package/src/workflows/feature/refactor.ts

@@ -20,7 +20,7 @@ import { healthy, type Guard } from "../shared/health.js"
 import { coder, FEEDBACK, HANDOFF, REFACTOR } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults, testFileGlobs } from "../shared/vars.js"
-import { buildTail, reUnwind, type FeedbackTarget } from "./review.js"
+import { buildTail, reUnwind, type FeedbackTarget } from "../shared/review.js"
 import { refactorCollecting } from "./steps.js"
 
 export const REFACTOR_PACKAGE = REFACTOR

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/seam.ts

@@ -45,7 +45,7 @@ import {
   refactorStrays,
   reviewedRefactor,
 } from "./refactor.js"
-import { isCode } from "./review.js"
+import { isCode } from "../shared/review.js"
 import { flagModeOn } from "../shared/options.js"
 import type { RiskTier } from "./tier.js"
 

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"