@pmelab/gtd 41.0.0 → 43.0.0

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

@@ -48,7 +48,7 @@ interface Drive {
   readonly vars?: Readonly<Record<string, string>>
   /** The REVIEW.md the human leaves; defaults to `notes` laid over the baseline. */
   readonly after?: string
-  /** The REVIEW.md each `review.reviewing` turn writes, in order; also raises the review-turn stop to one past the last. */
+  /** The REVIEW.md each `review.composing` turn writes, in order; also raises the review-turn stop to one past the last. */
   readonly reviewDocs?: readonly (string | undefined)[]
   /** Let the run pass the second gate, stopping at the first range read after it. */
   readonly passSecondGate?: boolean
@@ -95,7 +95,7 @@ const drive = async (d: Drive): Promise<Run> => {
   let awaits = 0
   let reviews = 0
   const effects: Record<string, () => void> = {
-    "review.reviewing": () => {
+    "review.composing": () => {
       const docs = d.reviewDocs
       if (++reviews > (docs?.length ?? 0) + (docs === undefined ? 1 : 0)) throw new Stop()
       const written = docs?.[reviews - 1]
@@ -116,6 +116,7 @@ const drive = async (d: Drive): Promise<Run> => {
       gateMessages.push(request.options.message ?? "")
     }
     if (request.kind === "agent") prompts.set(request.name, request.prompt)
+    if (request.kind === "run") prompts.set(request.name, request.body)
     if (request.kind === "judge") asked.push(...request.questions)
   }
   const context = fixtureContext(
@@ -184,10 +185,10 @@ describe("the risk-fix pass", () => {
   it("a marked risk is fixed, kept green, re-reviewed, then rests at the gate", async () => {
     const run = await drive({ notes: [], reviewDocs: [risky, clean] })
     expect(run.log.slice(0, 5)).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.fix.risks.fixing",
       "health.check",
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
     ])
     expect(run.prompts.get("review.fix.risks.fixing")).toContain("risk-1")
@@ -199,10 +200,10 @@ describe("the risk-fix pass", () => {
     const run = await drive({ notes: [], reviewDocs: [risky, risky] })
     expect(run.log.filter((n) => n === "review.fix.risks.fixing")).toHaveLength(1)
     expect(run.log.slice(0, 5)).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.fix.risks.fixing",
       "health.check",
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
     ])
   })
@@ -232,7 +233,7 @@ describe("the risk-fix pass", () => {
   it("no marker means no fix-risks step", async () => {
     const run = await drive({ notes: [], reviewDocs: [clean] })
     expect(run.log).not.toContain("review.fix.risks.fixing")
-    expect(run.log[0]).toBe("review.reviewing")
+    expect(run.log[0]).toBe("review.composing")
     expect(run.log[1]).toBe("review.await-review")
   })
 
@@ -243,16 +244,16 @@ describe("the risk-fix pass", () => {
       reviewDocs: [undefined, risky, clean],
     })
     expect(run.log).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
       "review.triage",
       "review.fix.nits.fixing",
       "health.check",
       "review.closing",
-      "review.reviewing",
+      "review.composing",
       "review.fix.risks.fixing",
       "health.check",
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
     ])
   })
@@ -265,7 +266,7 @@ describe("the guard", () => {
   it("runs right after the risk-fix turn", async () => {
     const run = await drive({ notes: [], reviewDocs: [risky, clean], guarded: true })
     expect(run.log.slice(0, 4)).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.fix.risks.fixing",
       "guard",
       "health.check",
@@ -443,7 +444,7 @@ describe("review verdict routing", () => {
   it("an unanswered note counts as edit", async () => {
     const run = await drive({ notes: ["add — typo", "sub", "mul"], answers: {} })
     expect(run.log).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
       "review.triage",
       "review.closing",
@@ -478,7 +479,7 @@ describe("review verdict routing", () => {
   it("only praise closes and signs off with no agent turn", async () => {
     const run = await drive({ notes, answers: { "note-1": verdict("praise") } })
     expect(run.log).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
       "review.triage",
       "review.closing",
@@ -492,7 +493,7 @@ describe("review verdict routing", () => {
       answers: { "note-1": verdict("question"), "note-2": verdict("question") },
     })
     expect(run.log).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
       "review.triage",
       "review.answer-review-questions",
@@ -508,17 +509,17 @@ describe("review verdict routing", () => {
       answers: { "note-1": verdict("question"), "note-2": verdict("nit") },
     })
     expect(run.log).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
       "review.triage",
       "review.answer-review-questions",
       "review.fix.nits.fixing",
       "health.check",
       "review.closing",
-      "review.reviewing",
+      "review.composing",
     ])
     expect(run.prompts.get("review.fix.nits.fixing")).not.toContain("why?")
-    expect(run.prompts.get("review.reviewing")).toContain("Carry-over: commit `c4`")
+    expect(run.prompts.get("review.composing")).toContain("git show 'c4:.gtd/REVIEW.md'")
     expect(run.result).toBe("stopped")
   })
 
@@ -527,7 +528,8 @@ describe("review verdict routing", () => {
       notes: ["add — typo", "sub", "mul"],
       answers: { "note-1": verdict("nit") },
     })
-    expect(run.prompts.get("review.reviewing")).not.toContain("Carry-over")
+    expect(run.prompts.get("review.composing")).not.toContain("git show")
+    expect(run.prompts.get("review.composing")).toContain("## Fixed from your notes")
   })
 
   it("edits run after questions and nits, and the capture names only the edits and the answering commit", async () => {
@@ -536,7 +538,7 @@ describe("review verdict routing", () => {
       answers: { "note-2": verdict("question"), "note-3": verdict("nit") },
     })
     expect(run.log).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
       "review.triage",
       "review.answer-review-questions",
@@ -556,7 +558,7 @@ describe("review verdict routing", () => {
   it("a noted round with no extractable note collects as one edit, without judging", async () => {
     const run = await drive({ notes: [], after: BEFORE + "\nSome stray prose.\n" })
     expect(run.log).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
       "review.closing",
       "review.collecting",
@@ -673,18 +675,19 @@ describe("severity routing", () => {
     expect(run.prompts.get("review.collecting")).toContain("(critical: forced by `!`)")
   })
 
-  it("a confident could edit defers and, alone, returns to the review gate", async () => {
+  it("a confident could edit is still re-planned, labelled could", async () => {
     const run = await drive({
       notes: ["add — quote", "sub", "mul"],
       answers: { "note-1": verdict("edit"), ...sev("note-1", could) },
     })
     expect(run.log).toEqual([
-      "review.reviewing",
+      "review.composing",
       "review.await-review",
       "review.triage",
-      "review.defer",
-      "review.await-review",
+      "review.closing",
+      "review.collecting",
     ])
+    expect(run.prompts.get("review.collecting")).toContain("(could)")
   })
 
   it("severity answers on a nit leave it a nit", async () => {
@@ -728,68 +731,19 @@ describe("severity routing", () => {
     expect(run.judged).toContain("note-1.security")
   })
 
-  it("the gate after a deferral accepts a clean land and lists the deferred notes", async () => {
-    const run = await drive({
-      notes: ["add — quote", "sub", "mul"],
-      answers: { "note-1": verdict("edit"), ...sev("note-1", could) },
-    })
-    expect(run.gates).toEqual([true, true])
-    expect(run.gateMessages[1]).toContain("NOT acted on")
-    expect(run.gateMessages[1]).toContain("note-1")
-    expect(run.gateMessages[0]).not.toContain("NOT acted on")
-  })
-
   it("the first round's gate accepts a clean land", async () => {
     const run = await drive({ notes: ["add", "sub", "mul"] })
     expect(run.gates.length).toBeGreaterThan(0)
     expect(run.gates.every((g) => g)).toBe(true)
   })
 
-  it("a later gate still accepts a clean land after a deferral round with a nit", async () => {
-    const run = await drive({
-      notes: ["add — quote", "sub — typo", "mul"],
-      answers: {
-        "note-1": verdict("edit"),
-        ...sev("note-1", could),
-        "note-2": verdict("nit"),
-      },
-      reviewDocs: [undefined, doc(["add", "sub"])],
-    })
-    expect(run.log).toContain("review.defer")
-    expect(run.log.at(-1)).toBe("review.await-review")
-    expect(run.gates).toEqual([true, true])
-  })
-
-  it("a question and a could note in one round: the gate's base is the answering commit", async () => {
-    const run = await drive({
-      notes: ["add — why?", "sub — quote", "mul"],
-      answers: {
-        "note-1": verdict("question"),
-        "note-2": verdict("edit"),
-        ...sev("note-2", could),
-      },
-      passSecondGate: true,
-    })
-    expect(run.log).toEqual([
-      "review.reviewing",
-      "review.await-review",
-      "review.triage",
-      "review.answer-review-questions",
-      "review.defer",
-      "review.await-review",
-    ])
-    // c4 is the answering commit, not the defer commit (c5) or the round (c2)
-    expect(run.since.at(-1)).toBe("c4")
-  })
-
   it("a blank reviewSeverityMinP makes every confident could critical", async () => {
     const run = await drive({
       notes: ["add — quote", "sub", "mul"],
       answers: { "note-1": verdict("edit"), ...sev("note-1", could) },
       vars: { reviewSeverityMinP: "" },
     })
-    expect(run.log).toContain("review.collecting")
-    expect(run.log).not.toContain("review.defer")
+    expect(run.prompts.get("review.collecting")).toContain("(critical: judge unsure)")
   })
 })
 
@@ -807,7 +761,7 @@ describe("BuildTailOptions.lensBase", () => {
             if (request.kind === "restart") return Promise.resolve()
             if (request.kind === "agent" && request.name.startsWith("quality."))
               prompts.push(request.prompt)
-            if (request.name === "review.reviewing") throw new Stop()
+            if (request.name === "review.composing") throw new Stop()
             return Promise.resolve()
           },
           pushScope: () => undefined,
@@ -1048,10 +1002,12 @@ describe("buildTail without rules", () => {
             if (request.kind === "agent") prompts.set(request.name, request.prompt)
             if (request.name === "health.check") checks++
             if (request.name === "fix.quality.fixing") files.delete(".gtd/QUALITY.md")
-            if (request.name === "review.reviewing" || request.name === "health.stop")
+            if (request.name === "review.composing" || request.name === "health.stop")
               throw new Stop()
             return Promise.resolve(
-              request.kind === "judge" ? { answers: {}, truncated: [] } : undefined,
+              request.kind === "judge"
+                ? { answers: { Q1: { answer: "mechanical", p: 0.9 } }, truncated: [] }
+                : undefined,
             )
           },
           pushScope: () => undefined,

package/src/workflows/feature/review.ts

@@ -1,12 +1,15 @@
 import {
   answered,
+  changesSince,
   head,
   judge,
   numeric,
   requireRevert,
   restoreScript,
   run,
+  showScript,
   vars,
+  writeScript,
   type JudgeQuestion,
   type Judgment,
   type ScopeAccess,
@@ -14,18 +17,19 @@ import {
 import type { ReviewNote } from "../../steering/index.js"
 import * as kit from "../../workflow-kit/index.js"
 import { guarded, healthy, type EscalationCount } from "../shared/health.js"
+import { NO_FINDINGS, type LensReport } from "../shared/lenses.js"
 import {
   awaitReview,
   fixCheck,
   fixRisks,
+  QUALITY,
   REQUIREMENTS,
   REVIEW,
-  reviewing,
   reviewMissing,
 } from "../shared/steps.js"
 import { closeReview, isOptionalObject, tail, type TailOptions } from "../shared/tail.js"
 import * as t from "../shared/text.js"
-import { answerReviewQuestions, collecting, deferNotes, fixNits } from "./steps.js"
+import { answerReviewQuestions, collecting, fixNits } from "./steps.js"
 
 export type { ReviewOutcome } from "../../workflow-kit/index.js"
 
@@ -42,6 +46,12 @@ const verdictQuestion = (note: ReviewNote): JudgeQuestion => ({
 
 type Tier = "critical" | "should" | "could"
 
+const TIER_ORDER: Readonly<Record<Tier, number>> = { critical: 0, should: 1, could: 2 }
+
+/** Capture order: critical, should, could; within a tier one-way doors, then new concepts. */
+const captureKey = (s: Severity | undefined): number =>
+  s === undefined ? 2 : TIER_ORDER[s.tier] * 3 + s.rank
+
 const SEVERITY_ANSWERS: Readonly<Record<string, readonly string[]>> = {
   security: ["yes", "no"],
   reversibility: ["one-way", "two-way"],
@@ -56,10 +66,7 @@ interface Severity {
   readonly rank: 0 | 1 | 2
 }
 
-/**
- * Deferring is the risky direction: anything unanswered, unrecognised, cut or
- * below `minP` is `critical`, never `could`.
- */
+/** Anything unanswered, unrecognised, cut or below `minP` is `critical`, never `could`. */
 export const severityOf = (note: ReviewNote, judgment: Judgment, minP: number): Severity => {
   const ans = (q: string) => judgment.answers[`${note.id}.${q}`]
   const a = (q: string): string | undefined => ans(q)?.answer
@@ -121,7 +128,7 @@ const severityQuestions = (note: ReviewNote): JudgeQuestion[] => [
  * nothing) plus four severity answers. Dismissing a note is the risky
  * direction, so only a confident non-`edit` verdict on uncut evidence counts;
  * a cut, unanswered or below-floor note is an `edit`. Severity answers on a
- * non-`edit` note are ignored. A confident `could` edit becomes `defer`.
+ * non-`edit` note are ignored; on an `edit` they order the collecting turn.
  */
 const triage =
   (severities: Map<string, Severity>) =>
@@ -151,9 +158,8 @@ const triage =
           ? undefined
           : VERDICTS.find((v) => v !== "edit" && answered(answers[n.id], v, minP))
         if (verdict !== undefined && !truncated.includes(n.id)) return [n.id, verdict]
-        const severity = severityOf(n, judgment, severityMinP)
-        severities.set(n.id, severity)
-        return [n.id, severity.tier === "could" ? "defer" : "edit"]
+        severities.set(n.id, severityOf(n, judgment, severityMinP))
+        return [n.id, "edit"]
       }),
     )
   }
@@ -161,10 +167,41 @@ const triage =
 export const isCode = (path: string): boolean => path !== ".gtd" && !path.startsWith(".gtd/")
 
 /**
- * A reviewer writes `.gtd/REVIEW.md` over everything since `base`, a human
- * reviews and signs off or comments, and each note is judged: edits go to
- * another planning lap, questions are answered in place, nits fixed in one
- * batch, praise dropped.
+ * gtd writes `.gtd/REVIEW.md` from the quality lap's `report` — no reviewer
+ * turn — and removes what the fixer left in `.gtd/QUALITY.md`. A re-review
+ * after fixed nits restores the doc as committed at `carry`, answers kept;
+ * a fresh one leaves out the notes the human already answered.
+ */
+const composing = (
+  base: string,
+  report: LensReport,
+  carry?: string,
+  nitFix?: string,
+  answered: ReadonlySet<string> = new Set(),
+): Promise<void> =>
+  run(
+    "review.composing",
+    carry === undefined
+      ? writeScript(
+          REVIEW,
+          t.composedReview(base, {
+            ...report,
+            weakened: kit.removedAssertions(changesSince(base)),
+            nitFix,
+            answered,
+          }),
+          [QUALITY],
+        )
+      : showScript(carry, REVIEW, REVIEW),
+    { label: "Composing the review", file: REVIEW, base },
+  )
+
+/**
+ * The quality lap's notes reach a human over everything since `base`, who
+ * answers each one — fix as suggested, won't fix, or their own answer — and
+ * may comment. A fix joins the nit batch, a won't-fix is dropped, and an own
+ * answer or comment is judged: edits go to another planning lap, questions
+ * are answered in place, nits fixed in one batch, praise dropped.
  */
 export const review = (
   base: string,
@@ -179,40 +216,31 @@ export const review = (
       "gtd land: no declared pattern matches the pending changes — write .gtd/REQUIREMENTS.md from the feedback, or change nothing when it asks for nothing",
   }
   const severities = new Map<string, Severity>()
-  // Armed by a defer-only round to pick the next gate's message; a fresh
-  // review (`reviewing`) disarms it.
-  let deferred: readonly t.NoteInput[] = []
+  // Set by a nit fix, so the fresh review that follows names its commit.
+  let nitFix: string | undefined
+  // Every note the human answered in this review, left out of a fresh one.
+  const answered = new Set<string>()
   return kit.review(base, {
     file: REVIEW,
     feedback: feedback.file,
     isCode,
     reviewing: (b, carry) => {
-      deferred = []
-      return reviewing(b, carry, options.lap)
+      const fixedAt = nitFix
+      nitFix = undefined
+      return composing(b, options.report ?? NO_FINDINGS, carry, fixedAt, answered)
     },
     fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
     keepGreen: () => healthy(() => fixCheck(rules), { escalations, guard, guardRests, rules }),
-    awaitReview: (b) => {
-      const notes = deferred
-      deferred = []
-      return notes.length > 0
-        ? awaitReview(b, t.buildReviewAwaitAfterDeferMessage(b, notes))
-        : awaitReview(b)
-    },
+    awaitReview: (b) => awaitReview(b),
     reviewMissing,
     collecting: feedback.collecting,
     triage: triage(severities),
-    defer: (notes) => {
-      deferred = notes.map((n) => ({
-        id: n.id,
-        anchor: n.anchor,
-        text: n.text,
-        label: severities.get(n.id)!.reason,
-      }))
-      return deferNotes(deferred, head())
-    },
+    decided: (decisions) => decisions.forEach((d) => answered.add(d.anchor)),
     answerQuestions: answerReviewQuestions,
-    fixNits: guarded((notes) => fixNits(notes, fixAccess, rules), guard),
+    fixNits: async (notes) => {
+      await guarded((n: typeof notes) => fixNits(n, fixAccess, rules), guard)(notes)
+      nitFix = head()
+    },
     close: closeReview,
     captures: {
       edits: t.reviewEditsCapture,
@@ -221,14 +249,13 @@ export const review = (
         t.reviewEditNotesCapture(
           round,
           edits
-            .map((n, i) => ({ n, i, s: severities.get(n.id) }))
-            // critical before should, then one-way doors, then new concepts
-            .sort(
-              (x, y) =>
-                Number(x.s?.tier === "should") - Number(y.s?.tier === "should") ||
-                (x.s?.rank ?? 2) - (y.s?.rank ?? 2) ||
-                x.i - y.i,
-            )
+            .map((n, i) => ({
+              n,
+              i,
+              s: severities.get(n.id),
+              key: captureKey(severities.get(n.id)),
+            }))
+            .sort((x, y) => x.key - y.key || x.i - y.i)
             .map(({ n, s }) => ({
               id: n.id,
               anchor: n.anchor,
@@ -259,11 +286,13 @@ export interface BuildTailOptions extends TailOptions {
   readonly feedback?: FeedbackTarget | undefined
   /** Write access for the nit and risk fix turns; absent: the bundled `access` export decides. */
   readonly fixAccess?: ScopeAccess | undefined
-  /** Absent: "first". */
+  /** @deprecated No reviewer turn reads it since the review is composed. */
   readonly lap?: t.ReviewRange | undefined
+  /** What the triaged quality lap left for the review; absent: nothing. */
+  readonly report?: LensReport | undefined
 }
 
-/** The build tail: fix (when entered red), keep green unless `green`, the quality lap, then human review since `base`. */
+/** The build tail: fix (when entered red), keep green unless `green`, the triaged quality lap, then human review since `base`. */
 export function buildTail(base: string, options?: BuildTailOptions): Promise<kit.ReviewOutcome>
 /** @deprecated Pass `buildTail(base, { fixFirst, green, ...options })`. */
 export function buildTail(
@@ -287,7 +316,10 @@ export function buildTail(
     )
   }
   const [base, form] = options
-  return tail((escalations) => review(base, escalations, form), form)
+  return tail((escalations, report) => review(base, escalations, { ...form, report }), {
+    ...form,
+    triage: true,
+  })
 }
 
 const isOptionalBoolean = (value: unknown): value is boolean | null | undefined =>

package/src/workflows/feature/seam-rejection.feature

@@ -100,7 +100,7 @@ Feature: rejected naive passes walk one fixed path through the steer gate to the
     And step "implement.applying" runs its script
     When gtd lands
     And 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(human): idle → unwind
@@ -124,7 +124,7 @@ Feature: rejected naive passes walk one fixed path through the steer gate to the
       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(human): idle → unwind" has a body containing "Gtd-Var: flag_risk_tier=0"
     And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"

package/src/workflows/feature/seam.feature

@@ -152,7 +152,7 @@ Feature: the naive pass and seam judge decide how a feature is built
       [{"id":"AC-1","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 "src/calc.ts" contains "subtract"
     And the commit subjects end with:
       """
@@ -160,7 +160,7 @@ Feature: the naive pass and seam judge decide how a feature is built
       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 ".gtd/REQUIREMENTS.md" does not exist
 

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

@@ -335,7 +335,7 @@ const driveSeam = async (
     note: () => void files.set(NOTE, "Seam: a shared op"),
     deriving: () => void files.set(REFACTOR, "package"),
     closing: () => void files.delete(REFACTOR),
-    "review.reviewing": () => void files.set(REVIEW, reviewDoc),
+    "review.composing": () => void files.set(REVIEW, reviewDoc),
     "review.closing": () => {
       files.delete(REVIEW)
       current = "after-refactor"

package/src/workflows/feature/slicing.feature

@@ -51,7 +51,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       [{"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(human): design.gate.answer → seam.naive
@@ -60,7 +60,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       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 output lines of gtd "slices" start with:
       """
@@ -112,7 +112,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       [{"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(agent): design.triage → design.gate.answer
@@ -129,7 +129,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       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 output lines of gtd "slices" start with:
       """
@@ -268,7 +268,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       """
     When gtd lands
     And 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(human): seam.steer → seam.naive
@@ -277,7 +277,7 @@ Feature: a change with more criteria than the cap is built in coarse slices
       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 ".gtd/REQUIREMENTS.md" does not exist
     And ".gtd/SLICES.md" does not exist

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

@@ -111,18 +111,6 @@ describe("the feature workflow's own steps declare skills — a step's rendered
     expect(scopes).toEqual([{ name: "review.fix.nits", access }])
     expect(steps_.map((r) => ("name" in r ? r.name : ""))).toEqual(["fixing"])
   })
-
-  it("deferNotes rests at build.review.defer as a script writing .gtd/TODO.md", async () => {
-    const request = await capture(
-      () =>
-        steps.deferNotes([{ id: "note-1", anchor: "a", text: "x", label: "could" }], "abcdef123"),
-      "build",
-    )
-    if (request.kind !== "run") throw new Error("unreachable")
-    expect(request.name).toBe("review.defer")
-    expect(request.body).toContain("## Deferred review notes (abcdef1)")
-    expect(request.options).toMatchObject({ file: ".gtd/TODO.md" })
-  })
 })
 
 describe("the feature workflow's planning steps run on the planner model", () => {

package/src/workflows/feature/steps.ts

@@ -1,4 +1,4 @@
-import { human, run, scope, type ScopeAccess } from "../../flows/index.js"
+import { human, scope, type ScopeAccess } from "../../flows/index.js"
 import type { CollectRound } from "../../workflow-kit/index.js"
 import * as t from "../shared/text.js"
 import { riskTierOn } from "./tier.js"
@@ -52,8 +52,8 @@ export const fixNits = (
 }
 
 /** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
-export const collecting = (capture: string): Promise<void> =>
-  t.agentWithSkills("review.collecting", t.buildReviewCollectingPrompt(capture), {
+export const collecting = (capture: string, round?: CollectRound): Promise<void> =>
+  t.agentWithSkills("review.collecting", t.buildReviewCollectingPrompt(capture, undefined, round), {
     label: "Collecting your feedback",
     file: REQUIREMENTS,
     mode: "qa",
@@ -79,10 +79,3 @@ export const refactorCollecting = (
       allowEmpty: true,
     },
   )
-
-/** `build.review.defer`: append `notes` to `.gtd/TODO.md` as one section; the step's landing is the commit. */
-export const deferNotes = (notes: readonly t.NoteInput[], round: string): Promise<void> =>
-  run("review.defer", t.deferNotesScript(notes, round), {
-    label: "Deferring could-notes to TODO.md",
-    file: ".gtd/TODO.md",
-  })