@pmelab/gtd 42.0.0 → 44.0.0

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

@@ -11,6 +11,7 @@ const state = vi.hoisted(() => ({
     | undefined,
   agentThread: false,
   humanThread: false,
+  marks: [] as string[],
 }))
 
 vi.mock("../flows/index.js", () => ({
@@ -24,6 +25,7 @@ vi.mock("../flows/index.js", () => ({
   },
   hasThreadFor: (who: string) => (who === "agent" ? state.agentThread : state.humanThread),
   head: () => state.head,
+  mark: (name: string, value: string) => void state.marks.push(`${name}=${value}`),
   read: (path: string) => (path === "f.md" ? state.feedback : state.files[path]),
   refuse: (m: string) => {
     throw new Error(m)
@@ -41,20 +43,29 @@ import {
   type ReviewPolicy,
   type Verdict,
 } from "./review.js"
-import type { ReviewNote } from "../steering/index.js"
+import type { ReviewDecision, ReviewNote } from "../steering/index.js"
 
 const note = (id: string) => ({ id }) as unknown as ReviewNote
 
 const setup = (verdicts: Record<string, Verdict>, silent = false, dropped = false) => {
   const calls: string[] = []
-  const deferred: string[][] = []
+  const judged: ReviewNote[][] = []
+  const fixed: ReviewNote[][] = []
+  const decided: ReviewDecision[][] = []
   const collected: ReviewNote[][] = []
   const p = {
     file: "r.md",
     feedback: "f.md",
-    triage: async () => new Map(Object.entries(verdicts)),
+    triage: async (ns: readonly ReviewNote[]) => {
+      judged.push([...ns])
+      return new Map(Object.entries(verdicts))
+    },
     answerQuestions: async () => void calls.push("answer"),
-    fixNits: async () => void calls.push("nits"),
+    fixNits: async (ns: readonly ReviewNote[]) => {
+      calls.push("nits")
+      fixed.push([...ns])
+    },
+    decided: (ds: readonly ReviewDecision[]) => void decided.push([...ds]),
     keepGreen: async () => void calls.push("green"),
     collecting: async () => {
       calls.push("collect")
@@ -72,10 +83,6 @@ const setup = (verdicts: Record<string, Verdict>, silent = false, dropped = fals
             `dropped: ${r.notes.map((n) => n.id).join(",")} / ${r.paths.join(",")}`,
         }
       : {},
-    defer: async (ns: readonly ReviewNote[]) => {
-      calls.push("defer")
-      deferred.push(ns.map((n) => n.id))
-    },
   } as unknown as ReviewPolicy
   const r = {
     round: "r1",
@@ -83,7 +90,7 @@ const setup = (verdicts: Record<string, Verdict>, silent = false, dropped = fals
     outcome: (verdict: "signoff" | "feedback") => ({ verdict }) as never,
     unfolded: async () => ({ verdict: "signoff" }) as never,
   }
-  return { p, r, calls, deferred, collected }
+  return { p, r, calls, judged, fixed, decided, collected }
 }
 
 beforeEach(() => {
@@ -95,29 +102,47 @@ beforeEach(() => {
   state.head = "h1"
   state.agentThread = false
   state.humanThread = false
+  state.marks = []
 })
 
-describe("routeNotes defer", () => {
-  it("defer-only round awaits again, no collecting turn", async () => {
-    const t = setup({ a: "defer", b: "defer" })
-    const res = await routeNotes(t.p, [note("a"), note("b")], t.r)
-    expect(res).toEqual({ next: "await", reviewed: "r1" })
-    expect(t.deferred).toEqual([["a", "b"]])
-    expect(t.calls).toEqual(["defer"])
+describe("routeNotes decisions", () => {
+  const decision = (
+    anchor: string,
+    choice: ReviewDecision["choice"],
+    text = "",
+  ): ReviewDecision => ({ anchor, body: `${anchor} body`, choice, text })
+
+  it("a fix joins the nit batch unjudged", async () => {
+    const t = setup({})
+    const res = await routeNotes(t.p, [], t.r, [decision("Rounding", "fix")])
+    expect(res).toEqual({ next: "rereview", carry: undefined })
+    expect(t.judged).toEqual([])
+    expect(t.fixed[0]).toMatchObject([{ anchor: "Rounding", text: "Rounding body" }])
+    expect(t.calls).toEqual(["nits", "green", "close"])
   })
 
-  it("defer + edit collects only the edits and ends feedback", async () => {
-    const t = setup({ a: "defer", b: "edit" })
-    const res = await routeNotes(t.p, [note("a"), note("b")], t.r)
+  it("an own answer is judged like a note", async () => {
+    const t = setup({ "answer-1": "edit" })
+    const res = await routeNotes(t.p, [], t.r, [decision("Rounding", "answer", "round up")])
     expect(res).toEqual({ verdict: "feedback" })
-    expect(t.calls).toEqual(["defer", "close", "collect"])
-    expect(t.collected[0]!.map((n) => n.id)).toEqual(["b"])
+    expect(t.judged[0]).toMatchObject([{ id: "answer-1", anchor: "Rounding", text: "round up" }])
+    expect(t.collected[0]!.map((n) => n.id)).toEqual(["answer-1"])
   })
 
-  it("runs after nit fixes and before the collecting turn", async () => {
-    const t = setup({ a: "nit", b: "defer", c: "edit" })
-    await routeNotes(t.p, [note("a"), note("b"), note("c")], t.r)
-    expect(t.calls).toEqual(["nits", "green", "defer", "close", "collect"])
+  it("a won't-fix is dropped, marked, and signs off a round with nothing else", async () => {
+    const t = setup({})
+    const res = await routeNotes(t.p, [], t.r, [decision("Rounding", "wontfix")])
+    expect(res).toEqual({ verdict: "signoff" })
+    expect(t.calls).toEqual([])
+    expect(t.judged).toEqual([])
+    expect(state.marks).toEqual(["wontfix=Rounding"])
+  })
+
+  it("tells the policy every decision before routing", async () => {
+    const t = setup({})
+    const ds = [decision("A", "fix"), decision("B", "wontfix")]
+    await routeNotes(t.p, [], t.r, ds)
+    expect(t.decided).toEqual([ds])
   })
 })
 
@@ -221,7 +246,6 @@ const driveRound = async (
     },
     answerQuestions: async () => {},
     fixNits: async () => {},
-    defer: async () => {},
     close: async () => {},
     captures: {
       edits: (_round: string, from?: string) => (
@@ -440,3 +464,123 @@ describe("reviewToHandOff", () => {
     expect(calls).toEqual(["handOff"])
   })
 })
+
+describe("a note's answer boxes", () => {
+  const boxes = (fix: string, wont: string): string =>
+    doc(
+      POINTER,
+      "",
+      "## Rounding",
+      "",
+      "Should subtract round?",
+      "",
+      "Tick exactly one:",
+      "",
+      `- [${fix}] fix as suggested`,
+      `- [${wont}] won't fix`,
+      "- [ ] _your answer_",
+    )
+  const open = boxes(" ", " ")
+
+  it("a sign-off with a note unanswered is refused", async () => {
+    const r = await driveRound(open, open)
+    expect(r.result).toBeInstanceOf(Error)
+    expect((r.result as Error).message).toContain("answer-completeness: 1 note(s) in r.md")
+  })
+
+  it("two ticks on one note are refused", async () => {
+    const r = await driveRound(open, boxes("x", "x"))
+    expect((r.result as Error).message).toContain("answer-completeness")
+  })
+
+  it("a won't-fix answer signs off with no judge", async () => {
+    const r = await driveRound(open, boxes(" ", "x"))
+    expect(r.result).toEqual({ verdict: "signoff" })
+    expect(r.triaged).toEqual([])
+    expect(state.marks).toEqual(["wontfix=Rounding"])
+  })
+
+  it("a thread round may leave notes unanswered until the agent replied", async () => {
+    const base = doc(
+      `${POINTER}[^t]`,
+      "",
+      thread("H: why?"),
+      "",
+      "## Rounding",
+      "",
+      "Round?",
+      "",
+      "Tick exactly one:",
+      "",
+      "- [ ] fix as suggested",
+      "- [ ] won't fix",
+      "- [ ] _your answer_",
+    )
+    const replied = base.replace("    - H: why?", "    - H: why?\n    - A: because")
+    const r = await driveRound(base, replied, { inGate: replied })
+    expect(r.rounds).toEqual(["reply"])
+    expect((r.result as Error).message).toContain("answer-completeness")
+  })
+
+  const threaded = (wont: string, withThread: boolean): string =>
+    doc(
+      withThread ? `${POINTER}[^t]` : POINTER,
+      ...(withThread ? ["", thread("H: why?", "A: because")] : []),
+      "",
+      "## Rounding",
+      "",
+      "Round?",
+      "",
+      "Tick exactly one:",
+      "",
+      "- [ ] fix as suggested",
+      `- [${wont}] won't fix`,
+      "- [ ] _your answer_",
+    )
+
+  it("a reply that folds the last thread away rests at the gate again for the answers", async () => {
+    const base = threaded(" ", true).replace("\n    - A: because", "")
+    const r = await driveRound(base, threaded("x", false), { inGate: threaded(" ", false) })
+    expect(r.rounds).toEqual(["reply"])
+    expect(r.result).toEqual({ verdict: "signoff" })
+    expect(state.marks).toEqual(["wontfix=Rounding"])
+  })
+
+  it("an answer ticked beside a thread still routes once the thread settles", async () => {
+    const base = threaded(" ", true).replace("\n    - A: because", "")
+    const ticked = threaded("x", true)
+    const r = await driveRound(base, ticked, { inGate: ticked, settled: true, noDropped: true })
+    expect(r.result).toEqual({ verdict: "signoff" })
+    expect(state.marks).toEqual(["wontfix=Rounding"])
+  })
+
+  it("a hand-edit round still records its answers", async () => {
+    const r = await driveRound(open, boxes(" ", "x"), { handEdit: true })
+    expect(r.rounds).toEqual(["edits"])
+    expect(state.marks).toEqual(["wontfix=Rounding"])
+  })
+})
+
+describe("deleted answer boxes", () => {
+  it("are refused even when a reply turn landed them", async () => {
+    const withBoxes = doc(
+      `${POINTER}[^t]`,
+      "",
+      thread("H: why?"),
+      "",
+      "## Rounding",
+      "",
+      "Round?",
+      "",
+      "Tick exactly one:",
+      "",
+      "- [ ] fix as suggested",
+      "- [ ] won't fix",
+      "- [ ] _your answer_",
+    )
+    const gone = doc(POINTER, "", "## Rounding", "", "Round?")
+    state.since = [{ path: "r.md", status: "modified", before: withBoxes, after: gone }]
+    const r = await driveRound(withBoxes, gone, { inGate: gone })
+    expect((r.result as Error).message).toContain("its answer boxes were deleted")
+  })
+})

package/src/workflow-kit/review.ts

@@ -3,6 +3,7 @@ import {
   changesSince,
   hasThreadFor,
   head,
+  mark,
   read,
   refuse,
   requireReplies,
@@ -11,9 +12,12 @@ import {
 } from "../flows/index.js"
 import {
   parseThreads,
+  reviewDecisions,
   reviewNotes,
   reviewRisks,
   stripCodeThreads,
+  unansweredNotes,
+  type ReviewDecision,
   type ReviewNote,
 } from "../steering/index.js"
 
@@ -39,7 +43,7 @@ export interface Requested {
   readonly paths: readonly string[]
 }
 
-export type Verdict = "edit" | "question" | "nit" | "praise" | "defer"
+export type Verdict = "edit" | "question" | "nit" | "praise"
 
 export type ReviewRisk = ReturnType<typeof reviewRisks>[number]
 
@@ -64,8 +68,8 @@ export interface ReviewPolicy {
   readonly triage: (notes: readonly ReviewNote[]) => Promise<ReadonlyMap<string, Verdict>>
   readonly answerQuestions: (notes: readonly ReviewNote[]) => Promise<void>
   readonly fixNits: (notes: readonly ReviewNote[]) => Promise<void>
-  /** Leave `defer` notes out of the round. */
-  readonly defer: (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
   /** Remove `file` at the end of a round at commit `round`. */
   readonly close: (round: string) => Promise<void>
   /** What a collecting turn reads. */
@@ -112,6 +116,18 @@ const collect = async (
   return refuse(p.refusals.unmatched)
 }
 
+/** Refuse while a note's answer boxes hold anything but exactly one tick, or a note's boxes were deleted. */
+const requireDecisions = (file: string, reviewed: string): void => {
+  const open = unansweredNotes(read(file) ?? "", changesSince(reviewed).get(file)?.before)
+  if (open.length === 0) return
+  const list = open
+    .map((n) => `  - ${file}${n.line > 0 ? `:${n.line}` : ""}: ${n.title} — ${n.reason}`)
+    .join("\n")
+  refuse(
+    `gtd land: answer-completeness: ${open.length} note(s) in ${file} not answered — tick exactly one box per note: fix as suggested, won't fix, or your own answer written over _your answer_:\n${list}`,
+  )
+}
+
 const escapeRe = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
 
 /**
@@ -144,6 +160,7 @@ const notesOf = (text: string): string => {
 const converse = async (
   p: ReviewPolicy,
   base: string,
+  reviewed: string,
   collectedBefore?: string,
 ): Promise<string | undefined> => {
   let collectedAt = collectedBefore
@@ -155,11 +172,19 @@ const converse = async (
       return "missing"
     }
     requireThreadsClosed(p.file)
-    if (!hasThreadFor("agent", p.file)) return collectedAt
+    if (!hasThreadFor("agent", p.file)) {
+      requireDecisions(p.file, reviewed)
+      return collectedAt
+    }
     await p.collecting(p.captures.edits(head()), "reply")
     collectedAt = head()
     requireReplies(p.file)
-    if (!hasThreadFor("human", p.file)) return collectedAt
+    // A reply that folds the last thread away still leaves the notes to answer at the gate.
+    if (
+      !hasThreadFor("human", p.file) &&
+      unansweredNotes(read(p.file) ?? "", changesSince(reviewed).get(p.file)?.before).length === 0
+    )
+      return collectedAt
   }
 }
 
@@ -177,16 +202,51 @@ interface Round {
   readonly unfolded: () => Promise<Finish>
 }
 
-/** Judge every note, then run each verdict's route: answers, then nit fixes, then deferrals, then the edits' lap. */
+const decisionNote = (d: ReviewDecision, id: string, text: string): ReviewNote => ({
+  id,
+  kind: "chunk",
+  anchor: d.anchor,
+  before: d.body,
+  text,
+  forced: /^!(\s|$)/.test(text),
+})
+
+/** One `Gtd-Mark` value per line: a control character would make mark() throw on every replay. */
+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() || "untitled"
+
+/** Tell the policy, and mark each won't-fix on the gate's commit. */
+const record = (p: ReviewPolicy, decisions: readonly ReviewDecision[]): void => {
+  p.decided?.(decisions)
+  for (const d of decisions) if (d.choice === "wontfix") mark("wontfix", oneLine(d.anchor))
+}
+
+/**
+ * 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
+ * unjudged, an own answer is judged like a note, and a won't-fix is dropped
+ * with a `Gtd-Mark` on the gate's commit.
+ */
 export const routeNotes = async (
   p: ReviewPolicy,
   notes: readonly ReviewNote[],
   r: Round,
+  decisions: readonly ReviewDecision[] = [],
 ): Promise<Finish> => {
-  const verdicts = await p.triage(notes)
-  const of = (v: Verdict): ReviewNote[] => notes.filter((n) => (verdicts.get(n.id) ?? "edit") === v)
-  const [edits, questions, nits, deferred] = [of("edit"), of("question"), of("nit"), of("defer")]
-  if (edits.length + questions.length + nits.length + deferred.length === 0) return r.unfolded()
+  record(p, decisions)
+  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 = [
+    ...notes,
+    ...of("answer").map((d, i) => decisionNote(d, `answer-${i + 1}`, d.text)),
+  ]
+  const verdicts = judged.length === 0 ? new Map<string, Verdict>() : await p.triage(judged)
+  const ofVerdict = (v: Verdict): ReviewNote[] =>
+    judged.filter((n) => (verdicts.get(n.id) ?? "edit") === v)
+  const [edits, questions] = [ofVerdict("edit"), ofVerdict("question")]
+  const nits = [...ofVerdict("nit"), ...fixes]
+  if (edits.length + questions.length + nits.length === 0) return r.unfolded()
 
   let answeredAt: string | undefined
   if (questions.length > 0) {
@@ -197,7 +257,6 @@ export const routeNotes = async (
     await p.fixNits(nits)
     await p.keepGreen()
   }
-  if (deferred.length > 0) await p.defer(deferred)
   if (edits.length > 0) {
     await r.close()
     return r.outcome(
@@ -219,10 +278,13 @@ const isCodeEdit = (p: ReviewPolicy, c: Change): boolean =>
   p.isCode(c.path) &&
   stripCodeThreads(c.path, c.before ?? "") !== stripCodeThreads(c.path, c.after ?? "")
 
-/** Whether anything but thread edits and ticks landed in the review file since `commit`. */
+/** Whether a note or an answer, not just thread edits and pointer ticks, landed in the review file since `commit`. */
 const notedSince = (p: ReviewPolicy, commit: string): boolean =>
   changesSince(commit).some(
-    (c) => c.path === p.file && notesOf(c.before ?? "") !== notesOf(read(p.file) ?? ""),
+    (c) =>
+      c.path === p.file &&
+      (notesOf(c.before ?? "") !== notesOf(read(p.file) ?? "") ||
+        reviewDecisions(c.before ?? "", read(p.file) ?? "").length > 0),
   )
 
 /**
@@ -251,13 +313,14 @@ const settledAfter = (
 
 const finishNotes = async (
   p: ReviewPolicy,
-  before: string,
+  before: string | undefined,
+  decisions: 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 > 0) return routeNotes(p, notes, ctx)
+  const notes = reviewNotes(before ?? "", read(p.file) ?? "")
+  if (notes.length + decisions.length > 0) return routeNotes(p, notes, ctx, decisions)
   if (reopened) return ctx.unfolded()
   await ctx.close()
   return ctx.outcome(await collect(p, p.captures.notes(ctx.round), "notes"))
@@ -271,6 +334,15 @@ const toOutcome = (
 const isReopened = (p: ReviewPolicy, r: { settled: boolean; folded: boolean }): boolean =>
   r.settled && !r.folded && p.refusals.dropped !== undefined
 
+/** A carried answer is unchanged, never routed twice; one ticked beside a thread still routes once the thread has settled. */
+const decisionsSince = (
+  p: ReviewPolicy,
+  since: ReturnType<typeof changesSince>,
+): readonly ReviewDecision[] => {
+  const after = read(p.file) ?? ""
+  return reviewDecisions(since.get(p.file)?.before ?? after, after)
+}
+
 const finish = async (
   p: ReviewPolicy,
   reviewed: string,
@@ -296,8 +368,12 @@ 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 })
-  if ((settled && !reopened) || (edited.length === 0 && !noted)) return unfolded()
+  const decisions = decisionsSince(p, since)
+  if ((settled && !reopened && decisions.length === 0) || (edited.length === 0 && !noted))
+    return unfolded()
   if (edited.length > 0) {
+    // A hand-edit plans a lap; its collecting turn reads the answers in the review.
+    record(p, decisions)
     await close()
     return outcome(
       await collect(p, p.captures.edits(round, reopened ? reviewed : undefined), "edits", {
@@ -306,7 +382,7 @@ const finish = async (
       }),
     )
   }
-  return finishNotes(p, since.get(p.file)?.before ?? "", reopened, {
+  return finishNotes(p, since.get(p.file)?.before, decisions, reopened, {
     round,
     close,
     outcome,
@@ -342,7 +418,7 @@ export const review = async (base: string, p: ReviewPolicy): Promise<ReviewOutco
     let reviewed = head()
     let collectedAt: string | undefined
     for (;;) {
-      collectedAt = await converse(p, base, collectedAt)
+      collectedAt = await converse(p, base, reviewed, collectedAt)
       if (collectedAt === "missing") break
       const result = await finish(p, reviewed, collectedAt)
       if (!("next" in result)) return result

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/lens-review.feature

@@ -3,9 +3,10 @@ Feature: the quality lenses are the only agentic review
 
   A judge classifies each `## ` finding the lenses wrote to `.gtd/QUALITY.md`:
   a mechanical one is fixed by the fixer, noise is dropped with its `p` kept in
-  a trailer, and a design one becomes a note in `.gtd/REVIEW.md`. gtd writes
-  that file itself — no reviewer turn runs — and lists, without tick boxes,
-  what was fixed automatically and what was dropped as noise.
+  a trailer, and a design one becomes a note in `.gtd/REVIEW.md`, with answer
+  boxes. gtd writes that file itself — no reviewer turn runs — and lists,
+  without tick boxes, what was fixed automatically and what was dropped as
+  noise.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
@@ -97,6 +98,12 @@ Feature: the quality lenses are the only agentic review
 
       Should subtract round? The criterion does not say.
 
+      Tick exactly one:
+
+      - [ ] fix as suggested
+      - [ ] won't fix
+      - [ ] _your answer_
+
       ## Fixed automatically
 
       - subtract has no negative test (
@@ -108,7 +115,12 @@ Feature: the quality lenses are the only agentic review
 
       - add could be a method (p=0.85)
       """
-    And ".gtd/REVIEW.md" does not contain "[ ]"
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## Fixed automatically
+
+      - subtract has no negative test (
+      """
     And the commit subjects end with:
       """
       gtd(check): implement.closing → build.quality.correctness.reviewing

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