@pmelab/gtd 45.2.0 → 47.0.0

package/src/workflows/index.ts

@@ -5,13 +5,12 @@ import { feature } from "./feature/feature.js"
 
 export { threads, type ThreadInfo } from "../flows/index.js"
 export * from "./shared/reserved.js"
-export { FlagOptions, ShippedOptions, TestsOptions } from "./shared/options.js"
+export { FlagOptions, ShippedOptions } from "./shared/options.js"
 export { agentWithSkills, type ReviewRange } from "./shared/text.js"
 export * from "./shared/steps.js"
 export * from "./shared/health.js"
 export {
   closeReview,
-  fixQualityFindings,
   handOffReview,
   handOffTail,
   qualityLap,
@@ -38,7 +37,6 @@ export { base, review, reviewFlow } from "./review/review.js"
 export { fix, fixFlow, fixReviewNotes } from "./fix/fix.js"
 export { rollout, rolloutFlow } from "./rollout/rollout.js"
 export { cleanup, cleanupFlow } from "./cleanup/cleanup.js"
-export { tests, testsFlow } from "./tests/tests.js"
 
 export default feature
 

package/src/workflows/review/review.ts

@@ -1,11 +1,23 @@
-import { read, refuse, start, type WorkflowBase } from "../../flows/index.js"
-import { buildTail, fixFeedback, reUnwind } from "../shared/review.js"
+import { read, refuse, removeScript, run, start, type WorkflowBase } from "../../flows/index.js"
+import { buildTail, reUnwind } from "../shared/review.js"
 import { gate } from "../shared/health.js"
 import { shipped } from "../shared/options.js"
-import { REQUIREMENTS } from "../shared/steps.js"
+import { coder, REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 
+const fixFeedback = async (): Promise<void> => {
+  await t.agentWithSkills("feedback.fixing", t.reviewFeedbackFixPrompt(), {
+    label: "Fixing your review feedback",
+    file: REQUIREMENTS,
+    model: coder(),
+    system: t.finisherSystem(),
+    // An earlier nit fix may already have built the concern.
+    allowEmpty: true,
+  })
+  await run("feedback.closing", removeScript([REQUIREMENTS]), { label: "Closing the feedback" })
+}
+
 /**
  * The feature's review of everything since `reviewBase` — a green gate, the
  * triaged quality lap, then the human review — with no design phase: a

package/src/workflows/shared/lenses.ts

@@ -15,6 +15,7 @@ import {
 import { FIX_CAP, guarded, healthy, type EscalationCount, type Guard } from "./health.js"
 import { fixCheck, fixQuality, QUALITY } from "./steps.js"
 import * as t from "./text.js"
+import type { Origin } from "./text.js"
 
 /** One `## ` section of `.gtd/QUALITY.md`. */
 export interface Finding {
@@ -29,17 +30,30 @@ type FindingKind = "mechanical" | "noise" | "design"
 /** What the triaged quality lap did with its findings, for the review to list. */
 export interface LensReport {
   /** Design findings, then the mechanical ones the fix cap left. */
-  readonly notes: readonly (Finding & {
-    readonly unresolved?: true
-    readonly unclear?: true
-    readonly answers?: readonly [string, string]
-  })[]
-  readonly fixed: readonly (Finding & { readonly commit: string })[]
-  readonly noise: readonly (Finding & { readonly p: number })[]
+  readonly notes: readonly (Finding &
+    Origin & {
+      readonly unresolved?: true
+      readonly unclear?: true
+    })[]
+  readonly fixed: readonly (Finding & Origin & { readonly commit: string })[]
+  readonly noise: readonly (Finding & Origin & { readonly p: number })[]
 }
 
 export const NO_FINDINGS: LensReport = { notes: [], fixed: [], noise: [] }
 
+/** `reports` as one, each finding labelled with the slice it came from, in slice order. */
+export const joinReports = (
+  reports: readonly { readonly slice: string; readonly report: LensReport }[],
+): LensReport => {
+  const tag = <F extends Origin>(slice: string, fs: readonly F[]): F[] =>
+    fs.map((f) => ({ ...f, slice }))
+  return {
+    notes: reports.flatMap((r) => tag(r.slice, r.report.notes)),
+    fixed: reports.flatMap((r) => tag(r.slice, r.report.fixed)),
+    noise: reports.flatMap((r) => tag(r.slice, r.report.noise)),
+  }
+}
+
 const UNTITLED = "Quality findings"
 
 const below = (section: string): string => section.split("\n").slice(1).join("\n").trim()
@@ -133,6 +147,8 @@ export interface TriageOptions {
   readonly guard?: Guard | undefined
   readonly guardRests?: boolean | undefined
   readonly rules?: string | undefined
+  /** The lens that wrote a finding, when known; asked once per finding, in file order. */
+  readonly lensOf?: ((f: Finding) => string | undefined) | undefined
 }
 
 /**
@@ -143,7 +159,11 @@ export interface TriageOptions {
  */
 export const triageFindings = async (options: TriageOptions): Promise<LensReport> => {
   const { escalations, guard, guardRests, rules } = options
-  const findings = findingsOf(read(QUALITY) ?? "")
+  const withLens = (f: Finding): Finding & Origin => {
+    const lens = options.lensOf?.(f)
+    return lens === undefined ? f : { ...f, lens }
+  }
+  const findings = findingsOf(read(QUALITY) ?? "").map(withLens)
   if (findings.length === 0) return NO_FINDINGS
   const { mechanical, noise, design } = await classify(findings)
   // Rewritten whenever it is not one chunk per mechanical finding: the fixer deletes chunks.
@@ -164,7 +184,8 @@ export const triageFindings = async (options: TriageOptions): Promise<LensReport
     const commit = head()
     fixed.push(...turn.fixed.map((f) => ({ ...f, commit })))
     unclear.push(...turn.unclear)
-    open = turn.open
+    // A turn that renamed a chunk hands back fresh parses: keep the lens a same-titled finding had.
+    open = turn.open.map((f) => ({ ...mechanical.find((m) => m.title === f.title), ...f }))
   }
   if (mechanical.length > 0)
     await healthy(() => fixCheck(rules), { escalations, guard, guardRests, rules })

package/src/workflows/shared/options.ts

@@ -9,7 +9,7 @@ import {
   scope,
   vars,
 } from "../../flows/index.js"
-import { defaultFlagRegistry, defaults, envDefaults, testsDefaults } from "./vars.js"
+import { defaultFlagRegistry, defaults, envDefaults } from "./vars.js"
 
 const setting = Schema.optionalWith(Schema.String, { exact: true })
 
@@ -107,23 +107,3 @@ export const flagShipped = (
       }
     },
   )
-
-export const TestsOptions = Schema.Struct({
-  ...ShippedOptions.fields,
-  testFiles: setting,
-  skipPattern: setting,
-})
-
-export type TestsOptions = Schema.Schema.Encoded<typeof TestsOptions>
-
-export const testsShipped = (flow: Flow): WorkflowFactory<TestsOptions> =>
-  defineWorkflow(
-    Schema.standardSchemaV1(TestsOptions, { onExcessProperty: "error", errors: "all" }),
-    ({ contextLimit, ...options }) => ({
-      flow: limited(flow, contextLimit),
-      defaults: over({ ...defaults, ...testsDefaults }, options),
-      envDefaults: over(envDefaults, options),
-      doors: { tests: {} },
-      base: undefined,
-    }),
-  )

package/src/workflows/shared/review.ts

@@ -5,7 +5,6 @@ import {
   judge,
   numeric,
   read,
-  removeScript,
   requireRevert,
   restoreScript,
   run,
@@ -23,12 +22,10 @@ import { NO_FINDINGS, type LensReport } from "./lenses.js"
 import {
   answerReviewQuestions,
   awaitReview,
-  coder,
   collecting,
   fixCheck,
   fixNits,
   fixRisks,
-  QUALITY,
   REQUIREMENTS,
   REVIEW,
   reviewMissing,
@@ -175,7 +172,7 @@ export const isCode = (path: string): boolean => path !== ".gtd" && !path.starts
 
 /**
  * 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
+ * turn. 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.
  */
@@ -201,7 +198,6 @@ const composing = (
               undecided: parseStandards(read(STANDARDS) ?? "").undecided,
             },
           }),
-          [QUALITY],
         )
       : showScript(carry, REVIEW, REVIEW),
     { label: "Composing the review", file: REVIEW, base },
@@ -220,7 +216,7 @@ export const humanReview = (
   escalations: EscalationCount = { rounds: 0 },
   options: Omit<BuildTailOptions, "fixFirst" | "green"> = {},
 ): Promise<kit.ReviewOutcome> => {
-  const { guard, guardRests, fixAccess, rules, awaitMessage } = options
+  const { guard, guardRests, fixAccess, rules } = options
   const feedback: FeedbackTarget = options.feedback ?? {
     file: REQUIREMENTS,
     collecting,
@@ -243,7 +239,7 @@ export const humanReview = (
     },
     fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
     keepGreen: () => healthy(() => fixCheck(rules), { escalations, guard, guardRests, rules }),
-    awaitReview: (b) => awaitReview(b, awaitMessage?.(b)),
+    awaitReview,
     reviewMissing,
     collecting: feedback.collecting,
     triage: triage(severities),
@@ -305,11 +301,9 @@ export interface BuildTailOptions extends TailOptions {
   readonly lap?: t.ReviewRange | undefined
   /** What the triaged quality lap left for the review; absent: nothing. */
   readonly report?: LensReport | undefined
-  /** The review gate's message for the review base; absent: the quality lap's. */
-  readonly awaitMessage?: ((base: string) => string) | undefined
 }
 
-/** The build tail: fix (when entered red), keep green unless `green`, the triaged quality lap, then human review since `base`. */
+/** The build tail: fix (when entered red), keep green unless `green`, the 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(
@@ -333,10 +327,7 @@ export function buildTail(
     )
   }
   const [base, form] = options
-  return tail((escalations, report) => humanReview(base, escalations, { ...form, report }), {
-    ...form,
-    triage: true,
-  })
+  return tail((escalations, report) => humanReview(base, escalations, { ...form, report }), form)
 }
 
 const isOptionalBoolean = (value: unknown): value is boolean | null | undefined =>
@@ -372,19 +363,6 @@ const callForm = (
   return undefined
 }
 
-/** Build the concerns a review round collected into `.gtd/REQUIREMENTS.md`, then remove it. */
-export const fixFeedback = async (): Promise<void> => {
-  await t.agentWithSkills("feedback.fixing", t.reviewFeedbackFixPrompt(), {
-    label: "Fixing your review feedback",
-    file: REQUIREMENTS,
-    model: coder(),
-    system: t.finisherSystem(),
-    // An earlier nit fix may already have built the concern.
-    allowEmpty: true,
-  })
-  await run("feedback.closing", removeScript([REQUIREMENTS]), { label: "Closing the feedback" })
-}
-
 /**
  * Undo the human's review-round code edits. A path changed since the human
  * left it is not overwritten; requireRevert names it instead.

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

@@ -22,8 +22,6 @@ describe("the bundled workflow's skills export", () => {
         "build.review.fix.risks",
         "notes",
         "feedback",
-        "tests",
-        "tests.health",
         "refactor",
         "refactor.fix.suite",
         "refactor.health",

package/src/workflows/shared/skills.ts

@@ -24,9 +24,6 @@ export const skills = (
     notes: ["incremental-implementation", "code-simplification"],
     // `review`'s turn building what a review round collected.
     feedback: ["test-driven-development", "incremental-implementation"],
-    // The `tests` workflow's sweep and rewrites.
-    tests: ["test-audit", "test-driven-development"],
-    "tests.health": ["debugging-and-error-recovery"],
     // The refactor's own turns load `ponytail`; `refactor.build.*` carry the `build.*` lists.
     ...build,
     ...Object.fromEntries(Object.entries(build).map(([name, list]) => [`refactor.${name}`, list])),

package/src/workflows/shared/tail.ts

@@ -1,17 +1,18 @@
-import { read, refuse, removeScript, run, scope, showScript, vars } from "../../flows/index.js"
-import * as kit from "../../workflow-kit/index.js"
 import {
-  escalation,
-  FIX_CAP,
-  guarded,
-  healthy,
-  type EscalationCount,
-  type Guard,
-} from "./health.js"
+  read,
+  refuse,
+  removeScript,
+  run,
+  scope,
+  showScript,
+  vars,
+  writeScript,
+} from "../../flows/index.js"
+import * as kit from "../../workflow-kit/index.js"
+import { guarded, healthy, type EscalationCount, type Guard } from "./health.js"
 import {
   awaitReview,
   fixCheck,
-  fixQuality,
   fixRisks,
   QUALITY,
   REVIEW,
@@ -19,7 +20,7 @@ import {
   reviewMissing,
   reviewQuality,
 } from "./steps.js"
-import { NO_FINDINGS, triageFindings, type LensReport } from "./lenses.js"
+import { findingsOf, NO_FINDINGS, triageFindings, type Finding, type LensReport } from "./lenses.js"
 import * as t from "./text.js"
 
 /** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
@@ -34,29 +35,30 @@ export const qualityLap = (
   guard?: Guard,
   lenses?: readonly string[],
   base?: string,
+): Promise<"clean" | "findings"> => lensLap(guard, lenses, base, () => {})
+
+// `seen` gets each lens and every finding in the file once its turn is done.
+const lensLap = (
+  guard: Guard | undefined,
+  lenses: readonly string[] | undefined,
+  base: string | undefined,
+  seen: (lens: string, findings: readonly Finding[]) => void,
 ): Promise<"clean" | "findings"> =>
   kit.qualityLap(
     lenses ?? kit.lensEntriesOf(vars.qualityReviews ?? ""),
-    guarded((entry: string) => {
+    guarded(async (entry: string) => {
       const { lens, model } = kit.lensOf(entry)
-      return reviewQuality(lens, base, model)
+      await reviewQuality(lens, base, model)
+      seen(lens, findingsOf(read(QUALITY) ?? ""))
     }, guard),
     QUALITY,
   )
 
-/** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
-export const fixQualityFindings = (
-  escalations: EscalationCount,
-  guard?: Guard,
-  guardRests = true,
-  rules?: string,
-): Promise<boolean> =>
-  kit.fixFindings({
-    fix: guarded(() => fixQuality(rules), guard),
-    findings: QUALITY,
-    cap: FIX_CAP,
-    escalate: () => escalation(escalations, guard, guardRests, rules),
-  })
+// What the fixer left is in the lap's report by now; the next lap must not append to it.
+const closeQuality = async (): Promise<void> => {
+  if (read(QUALITY) === undefined) return
+  await run("quality.closing", removeScript([QUALITY]), { label: "Clearing quality findings" })
+}
 
 /** `.gtd/REVIEW.md` removed at the end of a round at commit `round`. */
 export const closeReview = (round: string): Promise<void> =>
@@ -89,17 +91,12 @@ export interface TailOptions {
   readonly lensBase?: string | undefined
   /** Appended to every fix and describe prompt of the tail. */
   readonly rules?: string | undefined
-  /**
-   * Judge the lap's findings: fix the mechanical ones, drop noise, and hand
-   * `finish` the rest as notes for the human review; default `false`. `finish`
-   * must remove `.gtd/QUALITY.md`, which still holds what the fixer left.
-   */
-  readonly triage?: boolean | undefined
 }
 
 /**
- * The build tail: fix (when entered red), keep green, the quality lap, then
- * `finish` — whatever the calling workflow runs last, a human review or nothing.
+ * The build tail: fix (when entered red), keep green, the quality lap — a
+ * judge sorts its findings, the mechanical ones are fixed, noise dropped —
+ * then `finish` with the rest as notes: a human review, or carrying them on.
  */
 export function tail<T>(
   finish: (escalations: EscalationCount, report: LensReport) => Promise<T>,
@@ -108,7 +105,7 @@ export function tail<T>(
 /** @deprecated Pass `tail(finish, { fixFirst, green, guard, lenses, guardRests, lensBase, rules })`. */
 export function tail<T>(
   fixFirst: boolean,
-  finish: (escalations: EscalationCount) => Promise<T>,
+  finish: (escalations: EscalationCount, report: LensReport) => Promise<T>,
   green?: boolean,
   guard?: Guard,
   lenses?: readonly string[],
@@ -164,29 +161,34 @@ const runTail = <T>(finish: Finish<T>, options: TailOptions): Promise<T> =>
     const guardRests = options.guardRests === undefined ? true : options.guardRests
     const escalations: EscalationCount = { rounds: 0 }
     const fix = () => fixCheck(rules)
-    const repair = async () => {
-      await guarded(fix, guard)()
-      await healthy(fix, { fixesSoFar: 1, escalations, guard, guardRests, rules })
-    }
     // fixFirst's own fix + healthy below already is the full run.
     // Truthy, not `true`: an untyped config's flags read as they always did.
-    if (options.fixFirst) await repair()
-    else if (!options.green) await healthy(fix, { escalations, guard, guardRests, rules })
+    if (options.fixFirst) {
+      await guarded(fix, guard)()
+      await healthy(fix, { fixesSoFar: 1, escalations, guard, guardRests, rules })
+    } else if (!options.green) await healthy(fix, { escalations, guard, guardRests, rules })
     // The lap runs once a tail: after its findings are fixed, `finish` follows.
-    const lap = await qualityLap(guard, lenses, lensBase)
-    if (options.triage) {
-      const report =
-        lap === "findings"
-          ? await triageFindings({ escalations, guard, guardRests, rules })
-          : NO_FINDINGS
-      return finish(escalations, report)
-    }
-    if (lap === "findings") {
-      if (await fixQualityFindings(escalations, guard, guardRests, rules)) {
-        await healthy(fix, { escalations, guard, guardRests, rules })
-      } else await repair()
+    // Lenses append, so a title the file did not hold before a lens's turn is that lens's.
+    const byTitle: { title: string; lens: string }[] = []
+    const lap = await lensLap(guard, lenses, lensBase, (lens, findings) => {
+      const before = byTitle.map((f) => f.title)
+      for (const { title } of findings) {
+        const at = before.indexOf(title)
+        if (at >= 0) before.splice(at, 1)
+        else byTitle.push({ title, lens })
+      }
+    })
+    // Asked once per finding in file order, so a title two lenses wrote goes to each in turn.
+    const lensOf = (f: Finding): string | undefined => {
+      const at = byTitle.findIndex((e) => e.title === f.title)
+      return at < 0 ? undefined : byTitle.splice(at, 1)[0]!.lens
     }
-    return finish(escalations, NO_FINDINGS)
+    const report =
+      lap === "findings"
+        ? await triageFindings({ escalations, guard, guardRests, rules, lensOf })
+        : NO_FINDINGS
+    await closeQuality()
+    return finish(escalations, report)
   })
 
 /**
@@ -198,10 +200,22 @@ export const handOffReview = (
   base: string,
   escalations: EscalationCount,
   guard?: Guard,
+  report: LensReport = NO_FINDINGS,
 ): Promise<void> =>
   kit.reviewToHandOff(base, {
     file: REVIEW,
-    reviewing: guarded((b, carry) => reviewing(b, carry), guard),
+    reviewing: guarded(async (b, carry) => {
+      await reviewing(b, carry)
+      // gtd adds the lap's chunks itself: .gtd/QUALITY.md is gone, so a reviewer leaving one out would lose it.
+      const review = read(REVIEW)
+      if (review === undefined) return
+      const full = t.withLapFindings(review, report)
+      if (full !== review) {
+        await run("review.carrying", writeScript(REVIEW, full), {
+          label: "Adding the quality lap's findings",
+        })
+      }
+    }, guard),
     fixRisks: guarded(fixRisks, guard),
     keepGreen: () => healthy(fixCheck, { escalations, guard }),
     awaitReview: (b) => awaitReview(b, t.handOffAwaitReviewMessage(b)),
@@ -220,6 +234,9 @@ export const handOffReview = (
       "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note to hand to fix.",
   })
 
-/** The tail the fix workflow runs: ends at the hand-off review since `base`. */
+/** The tail the fix workflow runs: ends at the hand-off review since `base`, which gets what the lap left. */
 export const handOffTail = (fixFirst: boolean, base: string, guard?: Guard): Promise<void> =>
-  tail((escalations) => handOffReview(base, escalations, guard), { fixFirst, guard })
+  tail((escalations, report) => handOffReview(base, escalations, guard, report), {
+    fixFirst,
+    guard,
+  })

package/src/workflows/shared/text.ts

@@ -117,18 +117,22 @@ export const qualityFindingsFile = (
 ): string =>
   `# Quality\n\n${findings.map((f) => `## ${f.title}\n\n${f.body}`.trim()).join("\n\n")}\n`
 
+/** Where a reported finding came from; absent when unknown or, for `slice`, a single-slice build. */
+export interface Origin {
+  readonly lens?: string | undefined
+  readonly slice?: string | undefined
+}
+
 export interface ComposedReview {
-  readonly notes: readonly {
+  readonly notes: readonly (Origin & {
     readonly title: string
     readonly body: string
     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 }[]
+  })[]
+  readonly fixed: readonly (Origin & { readonly title: string; readonly commit: string })[]
+  readonly noise: readonly (Origin & { readonly title: string; readonly p: number })[]
   /** `Then` lines a `.feature` file at the review base no longer carries. */
   readonly weakened?: readonly RemovedAssertions[]
   /** The commit that fixed the human's nits, on the review that follows it. */
@@ -156,6 +160,34 @@ const unboxed = (body: string): string =>
 
 const short = (hash: string): string => hash.slice(0, 7)
 
+/** `slice 2, lens tests`; empty when neither is known. */
+const originOf = (f: Origin): string =>
+  [
+    ...(f.slice === undefined ? [] : [`slice ${f.slice}`]),
+    ...(f.lens === undefined ? [] : [`lens ${f.lens}`]),
+  ].join(", ")
+
+const originLine = (f: Origin): string => {
+  const origin = originOf(f)
+  return origin === "" ? "" : `_From ${origin}._\n\n`
+}
+
+const withOrigin = (f: Origin, rest: string): string =>
+  [rest, originOf(f)].filter((s) => s !== "").join(", ")
+
+type LapNote = ComposedReview["notes"][number]
+
+const noteBody = (n: LapNote): string => {
+  const body = unboxed(n.body) || "_No detail given._"
+  if (n.unresolved === true) return `_The fixer left this unresolved._\n\n${body}`
+  if (n.unclear === true)
+    return `_A fix turn removed this while renaming another finding — check whether it was fixed._\n\n${body}`
+  return body
+}
+
+// A one-slice review needs no provenance: only carried findings name their slice and lens.
+const carriedOnly = (f: Origin): Origin => (f.slice === undefined ? {} : f)
+
 /**
  * \`.gtd/REVIEW.md\` as gtd writes it: one chunk per note, each ending in its
  * answer boxes, then the fixed and noise lists. Chunk titles are made unique —
@@ -172,8 +204,7 @@ 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 = ([fix, wontFix]: readonly [string, string] = [ANSWER_FIX, ANSWER_WONT_FIX]) =>
-    `${ANSWER_LEAD}\n\n- [ ] ${fix}\n- [ ] ${wontFix}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`
+  const answerBoxes = `${ANSWER_LEAD}\n\n- [ ] ${ANSWER_FIX}\n- [ ] ${ANSWER_WONT_FIX}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`
   const conflicts = (report.standards?.undecided ?? []).map((c) =>
     chunk(unique(conflictTitle(c)), conflictBody(c)),
   )
@@ -203,23 +234,14 @@ export const composedReview = (base: string, report: ComposedReview): string =>
         ]),
     ...conflicts,
     ...notes.map((n) =>
-      chunk(
-        n.title,
-        `${
-          n.unresolved === true
-            ? `_The fixer left this unresolved._\n\n${unboxed(n.body)}`
-            : 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.answers)}`,
-      ),
+      chunk(n.title, `${originLine(carriedOnly(n))}${noteBody(n)}\n\n${answerBoxes}`),
     ),
     ...(report.fixed.length === 0
       ? []
       : [
           chunk(
             "Fixed automatically",
-            report.fixed.map((f) => `- ${f.title} (${short(f.commit)})`).join("\n"),
+            report.fixed.map((f) => fixedLine(f, carriedOnly(f))).join("\n"),
           ),
         ]),
     ...(added.length === 0
@@ -232,7 +254,12 @@ export const composedReview = (base: string, report: ComposedReview): string =>
         ]),
     ...(report.noise.length === 0
       ? []
-      : [chunk("Dropped as noise", report.noise.map((f) => `- ${f.title} (p=${f.p})`).join("\n"))]),
+      : [
+          chunk(
+            "Dropped as noise",
+            report.noise.map((f) => noiseLine(f, carriedOnly(f))).join("\n"),
+          ),
+        ]),
   ]
   const body =
     chunks.length > 0
@@ -246,19 +273,6 @@ export const composedReview = (base: string, report: ComposedReview): string =>
   return `# Review: ${short(base)}\n\n<!-- base: ${base} -->\n\n${body.join("\n\n")}\n`
 }
 
-export const qualityUnresolvedMessage = (): string =>
-  `The quality lap's fix turns hit their cap and \`.gtd/QUALITY.md\` still
-holds findings. Nothing after this fixes them, so the process will not
-go on with them open.
-
-Fix what matters by hand, then delete or empty \`.gtd/QUALITY.md\` —
-dropping a finding is your call to make.
-
-What each change does next (then run \`gtd land\`):
-- **Delete or empty \`.gtd/QUALITY.md\`** — the suite runs on your edits, then the next slice is built, or after the last one you review the change (**build.review.reviewing**).
-- **Anything else** — rests here again.
-`
-
 export const startGateBlockedMessage = (): string =>
   `The test baseline is red — gtd will not start new work on a broken suite.
 \`.gtd/FEEDBACK.md\` holds the failing output.
@@ -1128,6 +1142,45 @@ const lapRange: Record<ReviewRange, string> = {
     "it covers the whole refactor since it started, on every round. A refactor may update an existing test's call sites only: give any test-file hunk its own chunk, and say so if it changes a test, an assertion or an expected value.",
 }
 
+/** What the quality lap left for a reviewer-written review: its notes, fixes and noise. */
+export type LapFindings = Pick<ComposedReview, "notes" | "fixed" | "noise">
+
+const fixedLine = (f: ComposedReview["fixed"][number], origin: Origin = f): string =>
+  `- ${f.title} (${withOrigin(origin, short(f.commit))})`
+
+const noiseLine = (f: ComposedReview["noise"][number], origin: Origin = f): string =>
+  `- ${f.title} (${withOrigin(origin, `p=${f.p}`)})`
+
+/**
+ * `review` with the lap's notes appended as prose chunks — no pointer, no
+ * answer boxes — then what it fixed and dropped. A title the review already
+ * holds gets a numbered suffix, as notes are told apart by title.
+ */
+export const withLapFindings = (review: string, { notes, fixed, noise }: LapFindings): string => {
+  const used = new Set(
+    review
+      .split("\n")
+      .filter((line) => line.startsWith("## "))
+      .map((line) => line.slice(3).trim()),
+  )
+  const unique = (title: string): string => {
+    let name = title
+    for (let n = 2; used.has(name); n++) name = `${title} (${n})`
+    used.add(name)
+    return name
+  }
+  const chunks = [
+    ...notes.map((n) => `## ${unique(n.title)}\n\n${originLine(n)}${noteBody(n)}`),
+    ...(fixed.length === 0
+      ? []
+      : [`## ${unique("Fixed automatically")}\n\n${fixed.map((f) => fixedLine(f)).join("\n")}`]),
+    ...(noise.length === 0
+      ? []
+      : [`## ${unique("Dropped as noise")}\n\n${noise.map((f) => noiseLine(f)).join("\n")}`]),
+  ]
+  return chunks.length === 0 ? review : `${review.trimEnd()}\n\n${chunks.join("\n\n")}\n`
+}
+
 export const buildReviewReviewingPrompt = (
   base: string,
   lap: ReviewRange,