@pmelab/gtd 44.0.0 → 45.1.0

package/src/workflows/shared/standards.ts

@@ -0,0 +1,156 @@
+import { ANSWER_LEAD, FREE_TEXT_PLACEHOLDER } from "../../steering/index.js"
+
+export const STANDARDS = ".gtd/STANDARDS.md"
+
+/** A learned standard that contradicts decided ones, waiting on the human. */
+export interface Conflict {
+  readonly text: string
+  /** The decided standards it contradicts. */
+  readonly olds: readonly string[]
+}
+
+export interface Standards {
+  readonly decided: readonly string[]
+  readonly undecided: readonly Conflict[]
+}
+
+const UNDECIDED = "Undecided"
+
+// The same class as the review's `Gtd-Mark` anchors, so a title reads alike in both.
+export const oneLine = (text: string): string =>
+  // eslint-disable-next-line no-control-regex -- the control range IS the point
+  text.replace(/[\s\x00-\x1f\x7f-\x9f\u2028\u2029]+/g, " ").trim()
+
+const ITEM = /^(?:[-*+]|\d+[.)])\s+(.*)$/
+const CONTRADICTS = /^\s+[-*+]\s+contradicts:\s*(.*)$/i
+
+interface Item {
+  text: string
+  /** Set under `## Undecided`. */
+  olds?: string[]
+}
+
+// A formatter wraps long lines: the tail belongs to the last `contradicts:` once there is one.
+const wrapped = (item: Item, line: string): void => {
+  const olds = item.olds
+  if (olds !== undefined && olds.length > 0) olds[olds.length - 1] += ` ${line.trim()}`
+  else item.text += ` ${line.trim()}`
+}
+
+/** What tells two standards apart: not the emphasis or spacing a formatter may rewrite. */
+export const standardKey = (text: string): string =>
+  oneLine(text.replace(/[*_`\\]/g, "")).toLowerCase()
+
+// Each standard once, so every conflict note gets a title of its own.
+const toStandards = (items: readonly Item[]): Standards => {
+  const seen = new Set<string>()
+  const fresh = (text: string): boolean => {
+    const key = standardKey(text)
+    if (key === "" || seen.has(key)) return false
+    seen.add(key)
+    return true
+  }
+  const decided = items.filter((i) => i.olds === undefined).map((i) => oneLine(i.text))
+  const undecided = items.flatMap((i) =>
+    i.olds === undefined
+      ? []
+      : [{ text: oneLine(i.text), olds: i.olds.map(oneLine).filter((o) => o !== "") }],
+  )
+  return { decided: decided.filter(fresh), undecided: undecided.filter((c) => fresh(c.text)) }
+}
+
+/**
+ * Every top-level bullet is one standard, those under `## Undecided` waiting
+ * on the human; a hand-edited file may group the rest under any heading.
+ */
+export const parseStandards = (text: string): Standards => {
+  const items: Item[] = []
+  let pending = false
+  let last: Item | undefined
+  for (const line of text.split("\n")) {
+    const heading = /^(#{1,6})\s+(.*)$/.exec(line)
+    const item = ITEM.exec(line)
+    const old = CONTRADICTS.exec(line)
+    if (heading !== null) {
+      pending = heading[1]!.length > 1 && heading[2]!.trim() === UNDECIDED
+      last = undefined
+    } else if (item !== null) {
+      last = pending ? { text: item[1]!, olds: [] } : { text: item[1]! }
+      items.push(last)
+    } else if (old !== null && last?.olds !== undefined) last.olds.push(old[1]!)
+    else if (/^\s+\S/.test(line) && last !== undefined) wrapped(last, line)
+    else if (line.trim() !== "") last = undefined
+  }
+  return toStandards(items)
+}
+
+export const renderStandards = ({ decided, undecided }: Standards): string => {
+  const parts = [
+    "# Standards",
+    "Kept from your review answers for every agent turn. One standard per bullet.",
+    ...(decided.length === 0 ? [] : [decided.map((s) => `- ${s}`).join("\n")]),
+    ...(undecided.length === 0
+      ? []
+      : [
+          `## ${UNDECIDED}`,
+          undecided
+            .map((c) => [`- ${c.text}`, ...c.olds.map((o) => `  - contradicts: ${o}`)].join("\n"))
+            .join("\n"),
+        ]),
+  ]
+  return `${parts.join("\n\n")}\n`
+}
+
+// FNV-1a over the key: a conflict's chunk title must survive markdown parsing and a
+// formatter's rewrite of STANDARDS.md, which its text may not.
+const hash = (raw: string): string => {
+  const text = standardKey(raw)
+  let h = 0x811c9dc5
+  for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 0x01000193)
+  return (h >>> 0).toString(16).padStart(8, "0")
+}
+
+const CONFLICT_TITLE = /^Standard conflict ([0-9a-f]{8})$/
+
+export const conflictTitle = (c: Conflict): string => `Standard conflict ${hash(c.text)}`
+
+export const conflictFor = (standards: Standards, title: string): Conflict | undefined => {
+  const id = CONFLICT_TITLE.exec(title)?.[1]
+  return id === undefined ? undefined : standards.undecided.find((c) => hash(c.text) === id)
+}
+
+export const isConflictTitle = (title: string): boolean => CONFLICT_TITLE.test(title)
+
+const KEEP_NEW = "keep the new one (drop the old)"
+const KEEP_OLD = "keep the old one (discard the new)"
+
+/** A conflict's chunk body; its three boxes read as fix / won't fix / own answer by position. */
+export const conflictBody = (c: Conflict): string =>
+  [
+    ...(c.olds.length === 0
+      ? [
+          `A standard learned from your answers contradicted ones another answer since replaced in \`${STANDARDS}\`. Keep it, discard it, or reword it.`,
+          `New: ${c.text}`,
+        ]
+      : [
+          `A standard learned from your answers contradicts ${c.olds.length === 1 ? "one" : "some"} already in \`${STANDARDS}\`. Your own answer replaces both with its wording.`,
+          `New: ${c.text}`,
+          `Old:\n\n${c.olds.map((o) => `- ${o}`).join("\n")}`,
+        ]),
+    `${ANSWER_LEAD}\n\n- [ ] ${KEEP_NEW}\n- [ ] ${KEEP_OLD}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`,
+  ].join("\n\n")
+
+/** What every agent turn is told while `.gtd/STANDARDS.md` holds decided standards. */
+export const standardsBlock = (text: string | undefined): string => {
+  const { decided } = parseStandards(text ?? "")
+  if (decided.length === 0) return ""
+  return `## Standards
+
+\`${STANDARDS}\` holds the standards the human set in earlier reviews.
+Follow every one in what you write. Reviewing, never raise a finding a
+standard rules out — a \`Won't fix:\` standard is a finding the human
+rejected, so never raise it or one like it again — and raise breaking a
+standard as a finding.
+
+${decided.map((s) => `- ${s}`).join("\n")}`
+}

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

@@ -31,7 +31,7 @@ import {
   withSkills,
   composedReview,
 } from "./text.js"
-import { steeringFormatFor, unansweredNotes } from "../../steering/index.js"
+import { reviewDecisions, steeringFormatFor, unansweredNotes } from "../../steering/index.js"
 import { captureStep, renderText } from "./text.fixture.js"
 
 describe("withSkills", () => {
@@ -68,6 +68,28 @@ describe("agentWithSkills", () => {
     expect(request.options).not.toHaveProperty("skills")
   })
 
+  it("ends every prompt with the kept standards, never the undecided ones", async () => {
+    const standards = [
+      "# Standards",
+      "",
+      "- Prefer early returns.",
+      "",
+      "## Undecided",
+      "",
+      "- Use classes.",
+      "  - contradicts: Prefer early returns.",
+    ].join("\n")
+    const request = await captureStep(() => agentWithSkills("name", "do-the-work"), {
+      scope: "a",
+      skills: { a: [] },
+      read: (path) => (path === ".gtd/STANDARDS.md" ? standards : undefined),
+    })
+    if (request.kind !== "agent") throw new Error("unreachable")
+    expect(request.prompt.startsWith("do-the-work\n\n## Standards")).toBe(true)
+    expect(request.prompt.endsWith("- Prefer early returns.")).toBe(true)
+    expect(request.prompt).not.toContain("Use classes.")
+  })
+
   it("leaves the prompt bare when the scope resolves to an empty list", async () => {
     const request = await capture(() => agentWithSkills("name", "do-the-work"), { a: [] })
     if (request.kind !== "agent") throw new Error("unreachable")
@@ -1244,6 +1266,41 @@ describe("buildReviewCollectingPrompt answer boxes", () => {
 describe("composedReview", () => {
   const BASE = "0123456789abcdef0123456789abcdef01234567"
 
+  describe("standards", () => {
+    const conflict = { text: "Calculators are functions.", olds: ["Calculators are classes."] }
+    const withConflict = composedReview(BASE, {
+      notes: [],
+      fixed: [],
+      noise: [],
+      standards: { added: [], undecided: [conflict] },
+    })
+
+    it("asks about each undecided standard in a note that blocks sign-off", () => {
+      expect(withConflict).toMatch(/^## Standard conflict [0-9a-f]{8}$/m)
+      expect(withConflict).toContain("- [ ] keep the new one (drop the old)")
+      expect(unansweredNotes(withConflict)).toHaveLength(1)
+    })
+
+    it("reads its boxes by position, like a note's", () => {
+      const ticked = withConflict.replace("- [ ] keep the old one", "- [x] keep the old one")
+      expect(unansweredNotes(ticked)).toEqual([])
+      expect(reviewDecisions(withConflict, ticked)).toEqual([
+        expect.objectContaining({ choice: "wontfix" }),
+      ])
+    })
+
+    it("lists the standards added", () => {
+      const doc = composedReview(BASE, {
+        notes: [],
+        fixed: [],
+        noise: [],
+        standards: { added: ["Prefer early returns."], undecided: [] },
+      })
+      expect(doc).toContain("## Standards added")
+      expect(doc).toContain("- Prefer early returns.")
+    })
+  })
+
   it("is a valid review with unique chunk titles, so every note matches its own chunk", () => {
     const doc = composedReview(BASE, {
       notes: [

package/src/workflows/shared/text.ts

@@ -1,6 +1,7 @@
 import {
   agent,
   codeThreads,
+  read,
   displayPath,
   env,
   head,
@@ -19,6 +20,13 @@ import {
   FREE_TEXT_PLACEHOLDER,
 } from "../../steering/index.js"
 import { escapeRegExp } from "./registry.js"
+import {
+  conflictBody,
+  conflictTitle,
+  standardsBlock,
+  STANDARDS,
+  type Conflict,
+} from "./standards.js"
 import { defaultFlagRegistry } from "./vars.js"
 import type { CollectRound, RemovedAssertions, Requested } from "../../workflow-kit/index.js"
 import {
@@ -57,7 +65,8 @@ export const agentWithSkills = (
   options: AgentOptions = {},
 ): Promise<void> => {
   const access = accessPreamble(accessFor(name, options.file))
-  const body = access === "" ? prompt : `${access}\n\n${prompt}`
+  const standards = standardsBlock(read(STANDARDS))
+  const body = [access, prompt, standards].filter((part) => part !== "").join("\n\n")
   return agent(name, withSkills(skillsFor(name).join(", "), body), options)
 }
 
@@ -115,6 +124,8 @@ export interface ComposedReview {
     readonly unresolved?: true
     /** A fix turn removed its chunk while renaming another. */
     readonly unclear?: true
+    /** Labels for the first two boxes; absent: fix as suggested, won't fix. Read by position, so only the wording changes. */
+    readonly answers?: readonly [string, string]
   }[]
   readonly fixed: readonly { readonly title: string; readonly commit: string }[]
   readonly noise: readonly { readonly title: string; readonly p: number }[]
@@ -124,12 +135,17 @@ export interface ComposedReview {
   readonly nitFix?: string | undefined
   /** Titles of notes the human already answered, left out. */
   readonly answered?: ReadonlySet<string> | undefined
+  /** Standards added since the review base, and the conflicts still waiting on the human. */
+  readonly standards?:
+    | { readonly added: readonly string[]; readonly undecided: readonly Conflict[] }
+    | undefined
 }
 
 const SUMMARY_TITLES = [
   "Weakened scenarios",
   "Fixed from your notes",
   "Fixed automatically",
+  "Standards added",
   "Dropped as noise",
   "Nothing to note",
 ]
@@ -156,7 +172,12 @@ export const composedReview = (base: string, report: ComposedReview): string =>
   }
   const chunk = (title: string, body: string): string => `## ${title}\n\n${body.trim()}`
   // The lead-in line keeps a body that ends in a list from absorbing the boxes.
-  const answerBoxes = `${ANSWER_LEAD}\n\n- [ ] ${ANSWER_FIX}\n- [ ] ${ANSWER_WONT_FIX}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`
+  const answerBoxes = ([fix, wontFix]: readonly [string, string] = [ANSWER_FIX, ANSWER_WONT_FIX]) =>
+    `${ANSWER_LEAD}\n\n- [ ] ${fix}\n- [ ] ${wontFix}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`
+  const conflicts = (report.standards?.undecided ?? []).map((c) =>
+    chunk(unique(conflictTitle(c)), conflictBody(c)),
+  )
+  const added = report.standards?.added ?? []
   const notes = report.notes
     .map((n) => ({ ...n, title: unique(n.title) }))
     .filter((n) => report.answered?.has(n.title) !== true)
@@ -180,6 +201,7 @@ export const composedReview = (base: string, report: ComposedReview): string =>
             `These scenarios lost an assertion the review base had:\n\n${weakened.join("\n")}`,
           ),
         ]),
+    ...conflicts,
     ...notes.map((n) =>
       chunk(
         n.title,
@@ -189,7 +211,7 @@ export const composedReview = (base: string, report: ComposedReview): string =>
             : n.unclear === true
               ? `_A fix turn removed this while renaming another finding — check whether it was fixed._\n\n${unboxed(n.body)}`
               : unboxed(n.body) || "_No detail given._"
-        }\n\n${answerBoxes}`,
+        }\n\n${answerBoxes(n.answers)}`,
       ),
     ),
     ...(report.fixed.length === 0
@@ -200,6 +222,14 @@ export const composedReview = (base: string, report: ComposedReview): string =>
             report.fixed.map((f) => `- ${f.title} (${short(f.commit)})`).join("\n"),
           ),
         ]),
+    ...(added.length === 0
+      ? []
+      : [
+          chunk(
+            "Standards added",
+            `Learned from your answers and kept in \`${STANDARDS}\`:\n\n${added.map((s) => `- ${s}`).join("\n")}`,
+          ),
+        ]),
     ...(report.noise.length === 0
       ? []
       : [chunk("Dropped as noise", report.noise.map((f) => `- ${f.title} (p=${f.p})`).join("\n"))]),

package/src/workflows/shared/vars.ts

@@ -16,6 +16,14 @@ export const testFileGlobs: readonly string[] = [
 
 export const defaultFlagRegistry = "src/flags/index.ts"
 
+/** The `tests` workflow's own process settings: where it looks for skipped tests, and how a skip reads. */
+export const testsDefaults: Readonly<Record<string, string>> = {
+  testFiles: testFileGlobs.join(", "),
+  // JS/TS runners' `.skip`/`.todo` and `x`-prefixed blocks, and cucumber's skip tags.
+  skipPattern:
+    "^\\s*(?:(?:describe|context|suite|it|test|specify)\\.(?:skip|todo)\\b|x(?:describe|context|it|test|specify)\\s*\\(|(?:@\\S+\\s+)*@(?:skip|ignore)(?:\\s|$))",
+}
+
 /** Process settings. */
 export const defaults: Readonly<Record<string, string>> = {
   reviewBase: "",
@@ -24,6 +32,8 @@ export const defaults: Readonly<Record<string, string>> = {
   reviewNoteActionable: "0.7",
   reviewSeverityMinP: "0.7",
   qualityTriageMinP: "0.7",
+  // How sure the judge must be that an answer at the review gate is a reusable standard.
+  standardMinP: "0.8",
   refactorFlagPattern: "\\bGTD_FLAG_\\w+",
   seamAllow: [...testFileGlobs, ".gtd/**"].join(", "),
   flagMode: "true",

package/src/workflows/tests/index.ts

@@ -0,0 +1,6 @@
+import { tests } from "./tests.js"
+
+export { tests, testsFlow } from "./tests.js"
+export * from "../shared/reserved.js"
+
+export default tests

package/src/workflows/tests/tests-options.feature

@@ -0,0 +1,52 @@
+@inmem
+Feature: the tests workflow's skip detection is a workflow option
+
+  `testFiles` (globs) and `skipPattern` (a per-line regular expression) default
+  to JavaScript/TypeScript runners and cucumber tags; another stack sets its
+  own on the factory.
+
+  Background:
+    Given a gtd config with:
+      """
+      export {
+        feature as default,
+        feature,
+        defaults,
+        envDefaults,
+        summary,
+        steering,
+        skills,
+        access,
+      } from "@pmelab/gtd/workflows/feature"
+      import { tests as shippedTests } from "@pmelab/gtd/workflows/tests"
+      export const tests = shippedTests({
+        testFiles: "tests/test_*.py",
+        skipPattern: "@pytest\\.mark\\.skip\\b",
+      })
+      """
+    And a file "tests/test_calc.py" with:
+      """
+      @pytest.mark.skip
+      def test_add(): pass
+      """
+    And a file "src/calc.test.ts" with:
+      """
+      it.skip("adds", () => {})
+      """
+    And the working tree is committed as "test: python"
+    And step "tests-gate.check" changes nothing
+
+  Scenario: only the configured files and pattern count as skipped
+    Given step "tests.sweeping" is prompted with "tests/test_calc.py:1 — @pytest.mark.skip"
+    And step "tests.sweeping" changes nothing
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "tests/test_calc.py has no section"
+    And driving the process is refused without "src/calc.test.ts"
+
+  Scenario Outline: an unusable skipPattern is refused before any step
+    Then starting workflow "tests" with "--var skipPattern=<pattern>" is refused with "<refusal>"
+
+    Examples:
+      | pattern | refusal                                     |
+      | .*      | skipPattern must not match the empty string |
+      | (       | skipPattern is not a valid regular expression |

package/src/workflows/tests/tests.feature

@@ -0,0 +1,266 @@
+@inmem
+Feature: the tests workflow revives skipped tests or proposes their deletion
+
+  `gtd --workflow tests` sweeps the repository for skipped tests and test-audit
+  findings into `.gtd/TESTS.md`, one section per test file. Each file is
+  rewritten in its own turn until nothing in it is skipped and the suite is
+  green. A test the agent calls obsolete stays skipped and becomes a proposal in
+  `.gtd/RETIRE.md`; the human review asks for one tick on each — delete it, keep
+  it skipped, or an own answer. Only a person's tick deletes a test.
+
+  Background:
+    Given a gtd config with:
+      """
+      export {
+        feature as default,
+        feature,
+        defaults,
+        envDefaults,
+        summary,
+        steering,
+        skills,
+        access,
+      } from "@pmelab/gtd/workflows/feature"
+      export { tests } from "@pmelab/gtd/workflows/tests"
+      """
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And a file "src/calc.test.ts" with:
+      """
+      it.skip("adds", () => expect(add(1, 2)).toBe(3))
+      """
+    And a file "src/legacy.test.ts" with:
+      """
+      it.skip("calls the v1 api", () => {})
+      """
+    And the working tree is committed as "feat: calculator"
+    And step "tests-gate.check" changes nothing
+    And step "tests.sweeping" writes ".gtd/TESTS.md" with:
+      """
+      # Tests
+
+      ## src/calc.test.ts
+
+      "adds" is skipped.
+
+      ## src/legacy.test.ts
+
+      "calls the v1 api" is skipped.
+      """
+    And step "tests.rewriting", when prompted with "\"adds\" is skipped", writes "src/calc.test.ts" with:
+      """
+      it("adds", () => expect(add(1, 2)).toBe(3))
+      """
+    And step "tests.rewriting", when prompted with "\"calls the v1 api\" is skipped", writes ".gtd/RETIRE.md" with:
+      """
+      # Retire
+
+      ## calls the v1 api
+
+      src/legacy.test.ts tests the v1 api, which is gone.
+      """
+    And step "tests.health.check" changes nothing
+    And step "tests.closing" runs its script
+    And step "build.review.composing" runs its script
+    And step "build.review.closing" runs its script
+
+  Scenario: the revivable test is unskipped and the obsolete one is proposed for deletion
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And the commit subjects end with:
+      """
+      gtd(check): tests-gate.check → tests.sweeping
+      gtd(agent): tests.sweeping → tests.rewriting
+      gtd(agent): tests.rewriting → tests.health.check
+      gtd(check): tests.health.check → tests.rewriting
+      gtd(agent): tests.rewriting → tests.closing
+      gtd(check): tests.closing → build.review.composing
+      gtd(check): build.review.composing → build.review.await-review
+      """
+    And "src/calc.test.ts" contains "it(\"adds\""
+    And "src/legacy.test.ts" contains "it.skip"
+    And ".gtd/TESTS.md" does not exist
+    And ".gtd/RETIRE.md" does not exist
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## calls the v1 api
+
+      Delete this skipped test.
+
+      src/legacy.test.ts tests the v1 api, which is gone.
+
+      Tick exactly one:
+
+      - [ ] delete it
+      - [ ] keep it skipped
+      - [ ] _your answer_
+      """
+    And the resting step's content contains "tests removed"
+
+  Scenario: signing off with an unticked proposal is refused
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then landing is refused with "tick exactly one box"
+
+  Scenario: a ticked delete it has the test deleted, then the review comes back
+    Given step "build.review.fix.nits.fixing" deletes "src/legacy.test.ts"
+    And step "build.health.check" changes nothing
+    When gtd starts workflow "tests"
+    And the process is driven
+    And the text "- [ ] delete it" in ".gtd/REVIEW.md" is replaced with "- [x] delete it"
+    And gtd lands
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And "src/legacy.test.ts" does not exist
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+
+  Scenario: a ticked keep it skipped leaves the test skipped and ends the process
+    Given judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"no","p":0.9}]
+      """
+    When gtd starts workflow "tests"
+    And the process is driven
+    And the text "- [ ] keep it skipped" in ".gtd/REVIEW.md" is replaced with "- [x] keep it skipped"
+    And gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And "src/legacy.test.ts" contains "it.skip"
+    And the commit "gtd(human): build.review.await-review → build.review.standards.judge" has a body containing "Gtd-Mark: wontfix=calls the v1 api"
+
+  Scenario: a rewrite leaving a test skipped without a proposal is refused
+    Given step "tests.rewriting", when prompted with "\"calls the v1 api\" is skipped", writes ".gtd/RETIRE.md" with:
+      """
+      # Retire
+      """
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts:1 still skipped"
+
+  Scenario: a rewrite deleting a test file is refused
+    Given step "tests.rewriting" deletes "src/legacy.test.ts"
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts deleted"
+
+  Scenario: a sweep deleting a test file is refused
+    Given step "tests.sweeping" deletes "src/legacy.test.ts"
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts deleted"
+
+  Scenario: a sweep changing anything but its plan is refused
+    Given step "tests.sweeping" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => b + a
+      """
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "the sweep changed src/calc.ts"
+
+  Scenario: a proposal naming its file at the end of a sentence counts
+    Given step "tests.rewriting", when prompted with "\"calls the v1 api\" is skipped", writes ".gtd/RETIRE.md" with:
+      """
+      # Retire
+
+      ## calls the v1 api
+
+      The v1 api is gone, so drop it from src/legacy.test.ts.
+      """
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+
+  Scenario: a sweep planning a file that is no test file is refused
+    Given step "tests.sweeping" writes ".gtd/TESTS.md" with:
+      """
+      # Tests
+
+      ## src/calc.ts
+
+      Nothing is skipped.
+
+      ## src/calc.test.ts
+
+      "adds" is skipped.
+
+      ## src/legacy.test.ts
+
+      "calls the v1 api" is skipped.
+      """
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "is no test file"
+
+  Scenario: a proposal naming its file as ./path counts
+    Given step "tests.rewriting", when prompted with "\"calls the v1 api\" is skipped", writes ".gtd/RETIRE.md" with:
+      """
+      # Retire
+
+      ## calls the v1 api
+
+      ./src/legacy.test.ts tests the v1 api, which is gone.
+      """
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+
+  Scenario: rewrites that change no code and propose nothing end the process
+    Given a file "src/legacy.test.ts" with:
+      """
+      it("calls the v2 api", () => {})
+      """
+    And a file "src/calc.test.ts" with:
+      """
+      it("adds", () => expect(add(1, 2)).toBe(3))
+      """
+    And the working tree is committed as "test: nothing skipped"
+    And step "tests.rewriting" from now on changes nothing
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "idle"
+
+  Scenario: one proposal covers one skip, not every skip in its file
+    Given a file "src/legacy.test.ts" with:
+      """
+      it.skip("calls the v1 api", () => {})
+      it.skip("calls the v1 batch api", () => {})
+      """
+    And the working tree is committed as "test: another legacy test"
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts:2 still skipped"
+
+  Scenario: a sweep leaving out a file with a skipped test is refused
+    Given step "tests.sweeping" writes ".gtd/TESTS.md" with:
+      """
+      # Tests
+
+      ## src/calc.test.ts
+
+      "adds" is skipped.
+      """
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts has no section"
+
+  Scenario: the sweep is told every skipped test, path and line
+    Given step "tests.sweeping" is prompted with "src/legacy.test.ts:1 — it.skip(\"calls the v1 api\", () => {})"
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+
+  Scenario: a sweep with nothing to do ends the process
+    Given a file "src/calc.test.ts" with:
+      """
+      it("adds", () => expect(add(1, 2)).toBe(3))
+      """
+    And the file "src/legacy.test.ts" is deleted
+    And the working tree is committed as "test: revive by hand"
+    And step "tests.sweeping" from now on changes nothing
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "idle"
+
+  Scenario: gtd door tests starts the workflow
+    When gtd opens door "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"