@pmelab/gtd 41.0.0 → 43.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.feature

@@ -61,13 +61,13 @@ Feature: a feature is done only when every acceptance criterion has a passing te
       [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
       """
     When the process is driven
-    Then the process rests at "build.review.reviewing"
+    Then the process rests at "build.review.composing"
     And the commit subjects end with:
       """
       gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
-      gtd(check): implement.closing → build.review.reviewing
+      gtd(check): implement.closing → build.review.composing
       """
     And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
     And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-2"
@@ -144,7 +144,7 @@ Feature: a feature is done only when every acceptance criterion has a passing te
       """
     And step "implement.uncovered" changes nothing
     When the process is driven
-    Then the process rests at "build.review.reviewing"
+    Then the process rests at "build.review.composing"
     And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
     And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: uncovered=AC-2"
 

package/src/workflows/feature/fast-path.feature

@@ -64,7 +64,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       """
     And step "implement.applying" runs its script
     When the process is driven
-    Then the process rests at "build.review.reviewing"
+    Then the process rests at "build.review.composing"
     And "src/greeting.ts" contains "Hello, world"
     And the commit subjects end with:
       """
@@ -80,7 +80,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
+      gtd(agent): build.quality.correctness.reviewing → build.review.composing
       """
     And the output of gtd "summary" <summary> "needs a human reviewer"
 

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest"
-import { runsItsScript, testRepo, type Actor } from "../../testkit/index.js"
+import { runsItsScript, testRepo } from "../../testkit/index.js"
 import { CONFIG_SCAFFOLD } from "../../install/index.js"
 import { reviewDoc } from "../shared/config.fixture.js"
 
@@ -75,10 +75,7 @@ describe("afterTail feedback lap", () => {
     `}`,
   ].join("\n")
 
-  const prompts: string[] = []
-
   const feedbackLap = async () => {
-    prompts.length = 0
     const repo = testRepo({
       workflow: TAIL,
       env: {
@@ -93,10 +90,7 @@ describe("afterTail feedback lap", () => {
     await repo.drive({
       "review-gate.check": () => undefined,
       "build.health.check": () => undefined,
-      "build.review.reviewing": (beat, r) => {
-        prompts.push(beat.content)
-        r.write(".gtd/REVIEW.md", review())
-      },
+      "build.review.composing": (_, r) => r.write(".gtd/REVIEW.md", review()),
     })
     repo.write(".gtd/REVIEW.md", review("also export multiply"))
     await repo.land()
@@ -137,35 +131,6 @@ describe("afterTail feedback lap", () => {
     expect(rest.content).not.toContain("write the change fresh")
     expect(repo.subjects().some((subject) => subject.includes("seam."))).toBe(false)
   })
-
-  it("the first review says everything since base, the one after feedback only what is new", async () => {
-    const repo = await feedbackLap()
-    expect(prompts[0]).toContain("it covers everything since the base")
-    expect(prompts[0]).not.toContain("only what is new since the previous review")
-    const writes: Record<string, () => [string, string]> = {
-      "design.triage": () => [
-        ".gtd/REQUIREMENTS.md",
-        "# Requirements\n\n- multiply, designed\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-      ],
-      "implement.building": () => ["src/calc.ts", `${CALC}// again\n`],
-    }
-    const actors = new Proxy({} as Record<string, Actor>, {
-      get: (_, state: string): Actor | undefined =>
-        state === "build.review.await-review" || state === "idle"
-          ? undefined
-          : (beat, r) => {
-              if (state === "implement.coverage") return '[{"id":"AC-1","answer":"yes","p":0.9}]'
-              if (state === "build.review.reviewing") {
-                prompts.push(beat.content)
-                r.write(".gtd/REVIEW.md", review())
-              } else if (writes[state]) r.write(...writes[state]())
-              else if (state.endsWith("closing") || state === "re-unwind") r.runScript(beat.content)
-            },
-    })
-    await repo.drive(actors, { maxBeats: 80 })
-    expect(prompts[1]).toContain("it covers only what is new since the previous review")
-    expect(prompts[1]).not.toContain("everything since the base")
-  })
 })
 
 describe("an in-flight 28.0.0 naive-pass process", () => {

package/src/workflows/feature/feature.ts

@@ -9,7 +9,7 @@ import {
   slice,
   start,
 } from "../../flows/index.js"
-import { gate, healthy, type EscalationCount } from "../shared/health.js"
+import { gate, healthy } from "../shared/health.js"
 import { flagModeOn, shipped } from "../shared/options.js"
 import { FEEDBACK, fixCheck, QUALITY, REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff, tail } from "../shared/tail.js"
@@ -135,8 +135,8 @@ const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> =
   })
 }
 
-// The lap's findings the fix cap left must not reach the review, nor the next process's lap,
-// which appends to the file. Empty counts as resolved, as the lap reads it.
+// Between slices nothing reviews the lap's leftovers, and the next lap appends to the file.
+// Empty counts as resolved, as the lap reads it.
 const settleQuality = async (): Promise<void> => {
   let rested = false
   while ((read(QUALITY) ?? "").length > 0) {
@@ -151,15 +151,13 @@ const settleQuality = async (): Promise<void> => {
   if (rested) await healthy(() => fixCheck())
 }
 
-/** The quality lap, then the human review since `base`. */
-const reviewedTail = (base: string, lensBase: string, lap?: "feedback"): Promise<ReviewOutcome> =>
-  tail(
-    async (escalations: EscalationCount) => {
-      await settleQuality()
-      return review(base, escalations, { lap })
-    },
-    { green: true, lensBase },
-  )
+/** 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 }), {
+    green: true,
+    lensBase,
+    triage: true,
+  })
 
 // seam.naive / seam.judge never run on a feedback lap: its design → implement is built unjudged
 // and unrefactored, held to every criterion's coverage since the process start.
@@ -181,7 +179,7 @@ const featureFeedback = async (
     })
     const tier = riskTierOn() ? recordRisk() : undefined
     closed = await implementing({ tier, amend: true })
-    outcome = await reviewedTail(outcome.base, lensBase, "feedback")
+    outcome = await reviewedTail(outcome.base, lensBase)
   }
 }
 
@@ -201,7 +199,7 @@ export const afterTail = async (first: ReviewOutcome): Promise<void> => {
     await design(outcome.base)
     const tier = riskTierOn() ? recordRisk() : undefined
     await implement({ tier, amend: true })
-    outcome = await buildTail(outcome.base, { green: true, lap: "feedback" })
+    outcome = await buildTail(outcome.base, { green: true })
   }
 }