@pmelab/gtd 46.0.0 → 48.0.0

package/src/workflows/shared/text.ts

@@ -117,16 +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
-  }[]
-  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. */
@@ -154,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 —
@@ -200,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}`,
-      ),
+      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
@@ -229,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
@@ -243,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.
@@ -1125,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,

package/src/workflows/feature/quality-unresolved.feature

@@ -1,121 +0,0 @@
-@inmem
-Feature: quality findings left unresolved between slices hold the next slice back
-
-  Between slices no review reads the quality lap's leftovers, so when the fix
-  cap leaves `.gtd/QUALITY.md` behind the process rests for a person before
-  the next slice. The last slice's leftovers become review notes instead (see
-  `lens-review.feature`).
-
-  Background:
-    Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
-    And an environment variable "GTD_FLAGMODE" set to "false"
-    And an environment variable "GTD_SLICEMAXCRITERIA" set to "1"
-    And a file "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      """
-    And the working tree is committed as "feat: add calculator"
-    And a file "TODO.md" with:
-      """
-      # More arithmetic
-
-      subtract and multiply.
-      """
-    And step "unwind" changes nothing
-    And step "start-gate.check" changes nothing
-    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-      """
-      # Requirements
-
-      ## Acceptance Criteria
-
-      - AC-1: subtract(a, b) returns a - b.
-      - AC-2: multiply(a, b) returns a * b.
-      """
-    And step "design.gate.answer" changes nothing
-    And step "design.slicing" writes ".gtd/SLICES.md" with:
-      """
-      # Slices
-
-      ## Subtract
-
-      - AC-1
-
-      ## Multiply
-
-      - AC-2
-      """
-    And step "seam.naive", when prompted with "This slice builds AC-1 only", writes "src/sub.test.ts" with:
-      """
-      it("[AC-1] subtracts", () => {})
-      """
-    And step "seam.naive", when prompted with "This slice builds AC-2 only", writes "src/mul.test.ts" with:
-      """
-      it("[AC-2] multiplies", () => {})
-      """
-    And step "seam.check" changes nothing
-    And step "implement.applying" runs its script
-    And step "implement.health.check" changes nothing
-    And step "implement.closing" runs its script
-    And judge step "implement.coverage", when its questions contain "AC-1", answers:
-      """
-      [{"id":"AC-1","answer":"yes","p":0.9}]
-      """
-    And judge step "implement.coverage", when its questions contain "AC-2", answers:
-      """
-      [{"id":"AC-2","answer":"yes","p":0.9}]
-      """
-
-  Scenario: findings the fix cap left after a slice rest at build.quality-unresolved
-    Given step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
-      """
-      # Quality
-
-      ## subtract has no negative test
-
-      Add a test subtracting a larger number.
-      """
-    And step "build.fix.quality.fixing" from now on changes nothing
-    And step "build.health.describe" writes ".gtd/ESCALATION.md" with:
-      """
-      # Escalation
-
-      The fix turn changed nothing.
-      """
-    When the process is driven
-    Then the process rests at "build.health.stop"
-    Given step "build.fix" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      // checked
-      """
-    And step "build.health.check" changes nothing
-    When gtd lands
-    And the process is driven
-    Then the process rests at "build.quality-unresolved"
-    And ".gtd/QUALITY.md" contains "subtract has no negative test"
-
-    When gtd lands
-    And the process is driven
-    Then the process rests at "build.quality-unresolved"
-
-    Given the file ".gtd/QUALITY.md" is deleted
-    And step "build.quality.correctness.reviewing" from now on changes nothing
-    And step "build.review.composing" runs its script
-    When gtd lands
-    And the process is driven
-    Then the process rests at "build.review.await-review"
-    And the commit subjects end with:
-      """
-      gtd(human): build.quality-unresolved → build.health.check
-      gtd(check): build.health.check → seam.naive
-      gtd(agent): seam.naive → seam.check
-      gtd(check): seam.check → implement.applying
-      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.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.composing
-      gtd(check): build.review.composing → build.review.await-review
-      """