@pmelab/gtd 24.3.0 → 25.0.0

package/src/workflows/index.ts

@@ -9,7 +9,6 @@ export { ShippedOptions } from "./shared/options.js"
 export { agentWithSkills } from "./shared/text.js"
 export * from "./shared/steps.js"
 export * from "./shared/health.js"
-export * from "./shared/scenarios.js"
 export {
   closeReview,
   fixQualityFindings,
@@ -18,7 +17,6 @@ export {
   qualityLap,
   REVIEW_ORIG,
   tail,
-  type TailPlan,
 } from "./shared/tail.js"
 export { lensesOf } from "../workflow-kit/index.js"
 export * from "./feature/steps.js"

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

@@ -13,6 +13,7 @@ describe("the bundled workflow's access export", () => {
       architecture: { write: [".gtd/REQUIREMENTS.md"] },
       "architecture.decompose": { write: [".gtd/packages/**", ".gtd/ARCHITECTURE.md"] },
       "build.review": { write: [".gtd/REVIEW.md"] },
+      "build.review.defer": { write: [".gtd/TODO.md"] },
       "build.review.fix.nits": {},
       "build.review.fix.risks": {},
       "build.quality.correctness": { write: [] },
@@ -33,8 +34,9 @@ describe("the bundled workflow's access export", () => {
     ).toEqual(["build.quality.correctness", "build.quality.my-lens"])
   })
 
-  it("keys only scopes that run a turn (every key is a skills key)", () => {
-    const known = Object.keys(workflow.skills(defaults))
+  it("keys only turn or script scopes", () => {
+    // `build.review.defer` is a script scope: no turn, so no skills entry.
+    const known = [...Object.keys(workflow.skills(defaults)), "build.review.defer"]
     for (const key of Object.keys(bundled)) expect(known).toContain(key)
   })
 })

package/src/workflows/shared/access.ts

@@ -13,6 +13,7 @@ export const access = (
   architecture: { write: [".gtd/REQUIREMENTS.md"] },
   "architecture.decompose": { write: [".gtd/packages/**", ".gtd/ARCHITECTURE.md"] },
   "build.review": { write: [".gtd/REVIEW.md"] },
+  "build.review.defer": { write: [".gtd/TODO.md"] },
   // `{}` reopens what `build.review` restricted: the fixes edit code.
   "build.review.fix.nits": {},
   "build.review.fix.risks": {},

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

@@ -1,7 +1,6 @@
 import { describe, expect, it } from "vitest"
 import { toRequest } from "../../judges/index.js"
-import { fastSuiteGuard, retryQuestion } from "./health.js"
-import { renderText } from "./text.fixture.js"
+import { retryQuestion } from "./health.js"
 
 describe("retryQuestion", () => {
   it.each([true, false])("is sendable to jev (comparable=%s)", (comparable) => {
@@ -12,22 +11,3 @@ describe("retryQuestion", () => {
     ).toBeGreaterThanOrEqual(2)
   })
 })
-
-describe("fastSuiteGuard", () => {
-  it("unset: names the setting and exits 0", () => {
-    const lines = renderText(fastSuiteGuard).join("\n")
-    expect(lines).toContain("fastTestCommand")
-    expect(lines).toContain("GTD_FASTTESTCOMMAND")
-    expect(lines).toContain("exit 0")
-  })
-
-  it("blank after trim counts as unset", () => {
-    expect(renderText(fastSuiteGuard, { env: { fastTestCommand: "  \t " } })).toContain("exit 0")
-  })
-
-  it("set: only removes SETUP", () => {
-    const lines = renderText(fastSuiteGuard, { env: { fastTestCommand: "true" } })
-    expect(lines.join("\n")).not.toContain("exit 0")
-    expect(lines.join("\n")).toContain("rm -f")
-  })
-})

package/src/workflows/shared/health.ts

@@ -1,4 +1,3 @@
-import { dirname } from "node:path"
 import {
   answered,
   check,
@@ -6,8 +5,6 @@ import {
   human,
   judge,
   numeric,
-  quote,
-  read,
   vars,
   type JudgeQuestion,
 } from "../../flows/index.js"
@@ -15,35 +12,12 @@ import * as kit from "../../workflow-kit/index.js"
 import { describeEscalation, escalate, escalationExhausted, ESCALATION, FEEDBACK } from "./steps.js"
 import * as t from "./text.js"
 
-/** Written while `fastTestCommand` is unset; its presence rests the process at the check. */
-export const SETUP = ".gtd/SETUP.md"
-
-const SETUP_TEXT =
-  "The bundled workflow needs the `fastTestCommand` setting: the fast suite (everything but e2e).\nSet it as a workflow option in `gtd.config.ts` or as GTD_FASTTESTCOMMAND."
-
-/** Shell lines for a check's preamble: unset (blank after trim) setting writes `SETUP` and skips the suite. */
-export const fastSuiteGuard = (): string[] =>
-  (env.fastTestCommand ?? "").trim() === ""
-    ? [
-        `mkdir -p ${quote(dirname(SETUP))}`,
-        `printf '%s\\n' ${quote(SETUP_TEXT)} > ${quote(SETUP)}`,
-        `printf '%s\\n' ${quote(SETUP_TEXT)} >&2`,
-        "exit 0",
-      ]
-    : [`rm -f ${quote(SETUP)}`]
-
 /** Fix turns a run of red checks gets before it escalates. */
 export const FIX_CAP = 3
 
-const unconfigured = (): boolean => read(SETUP) !== undefined
-
 /** Run the suite as step `name`; resolves `true` when it passed. A failure is in `.gtd/FEEDBACK.md`. */
 export const baseline = (name: string, label = "Checking the baseline"): Promise<boolean> =>
-  kit.untilSettled(
-    () =>
-      check(name, env.testCommand ?? "", { report: FEEDBACK, label, preamble: fastSuiteGuard() }),
-    unconfigured,
-  )
+  check(name, env.testCommand ?? "", { report: FEEDBACK, label })
 
 export type { EscalationCount } from "../../workflow-kit/index.js"
 
@@ -103,22 +77,17 @@ export interface HealthOptions {
   readonly fixesSoFar?: number
   /** Escalation rounds shared with other callers in the same run of red checks. */
   readonly escalations?: kit.EscalationCount
-  /** `fast` runs `fastTestCommand` (default `full`: `testCommand`). */
-  readonly suite?: "full" | "fast"
   /** Paths removed on a green run. */
   readonly sweepOnGreen?: readonly string[]
 }
 
-const runSuite = (options: HealthOptions): Promise<boolean> => {
-  const fast = options.suite === "fast"
-  return check("health.check", (fast ? env.fastTestCommand : env.testCommand) ?? "", {
+const runSuite = (options: HealthOptions): Promise<boolean> =>
+  check("health.check", env.testCommand ?? "", {
     report: FEEDBACK,
     label: "Running checks",
     // Swept only on green: an unresolved analysis survives every retry.
     sweepOnGreen: [ESCALATION, ...(options.sweepOnGreen ?? [])],
-    ...(fast ? { preamble: fastSuiteGuard() } : {}),
   })
-}
 
 /**
  * Loop until the suite is green: check, and on red run `fix` — escalating
@@ -127,11 +96,7 @@ const runSuite = (options: HealthOptions): Promise<boolean> => {
  */
 export const healthy = (fix: () => Promise<void>, options: HealthOptions = {}): Promise<void> =>
   kit.healthy(fix, {
-    // Unconfigured: straight back to the check, no fix turn or count.
-    check:
-      options.suite === "fast"
-        ? () => kit.untilSettled(() => runSuite(options), unconfigured)
-        : () => runSuite(options),
+    check: () => runSuite(options),
     report: FEEDBACK,
     fixCap: FIX_CAP,
     fixesSoFar: options.fixesSoFar ?? 0,

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

@@ -22,6 +22,14 @@ describe("the shipped workflow factories", () => {
     })
   })
 
+  it("default reviewSeverityMinP to 0.7 and let a factory override win", () => {
+    expect(defaults.reviewSeverityMinP).toBe("0.7")
+    expect(configure(feature({ reviewSeverityMinP: "0.9" }))).toMatchObject({
+      ok: true,
+      build: { defaults: { reviewSeverityMinP: "0.9" } },
+    })
+  })
+
   it("build the shipped settings unchanged with no options", () => {
     for (const factory of [feature, fix, review]) {
       expect(configure(factory)).toMatchObject({ ok: true, build: { defaults, envDefaults } })

package/src/workflows/shared/options.ts

@@ -15,9 +15,9 @@ export const ShippedOptions = Schema.Struct({
   judgeBudgetBytes: setting,
   judgeIdenticalMinP: setting,
   reviewNoteActionable: setting,
+  reviewSeverityMinP: setting,
   qualityReviews: setting,
   testCommand: setting,
-  fastTestCommand: setting,
   plannerModel: setting,
   coderModel: setting,
 })

package/src/workflows/shared/steps.ts

@@ -1,4 +1,5 @@
-import { env, human } from "../../flows/index.js"
+import { changesSince, env, human } from "../../flows/index.js"
+import { removedAssertions } from "../../workflow-kit/index.js"
 import * as t from "./text.js"
 
 // The bundled workflow's single steps. A step's name is relative to the
@@ -18,8 +19,8 @@ export const coder = (): string => env.coderModel ?? ""
 
 // ── Keeping the suite green ─────────────────────────────────────────────────
 
-export const fixCheck = (built?: t.BuildContext): Promise<void> =>
-  t.agentWithSkills("fix", t.buildFixPrompt(built), {
+export const fixCheck = (): Promise<void> =>
+  t.agentWithSkills("fix", t.buildFixPrompt(), {
     label: "Fixing the check",
     file: FEEDBACK,
     model: coder(),
@@ -90,14 +91,18 @@ export const fixQuality = (): Promise<void> =>
 
 /** Write `.gtd/REVIEW.md` over everything since `base`, carrying the answers of commit `carry` when given. */
 export const reviewing = (base: string, carry?: string): Promise<void> =>
-  t.agentWithSkills("review.reviewing", t.buildReviewReviewingPrompt(base, carry), {
-    label: "Reviewing",
-    file: REVIEW,
-    mode: "review",
-    model: planner(),
-    system: t.reviewerSystem(),
-    base,
-  })
+  t.agentWithSkills(
+    "review.reviewing",
+    t.buildReviewReviewingPrompt(base, carry, removedAssertions(changesSince(base))),
+    {
+      label: "Reviewing",
+      file: REVIEW,
+      mode: "review",
+      model: planner(),
+      system: t.reviewerSystem(),
+      base,
+    },
+  )
 
 /** Fix the `Risk:`-marked notes the reviewer named; an empty turn means the risk was judged false. */
 export const fixRisks = (notes: readonly t.NoteInput[]): Promise<void> =>
@@ -112,6 +117,7 @@ export const fixRisks = (notes: readonly t.NoteInput[]): Promise<void> =>
 export const awaitReview = (
   base: string,
   message = t.buildReviewAwaitReviewMessage(base),
+  acceptClean = false,
 ): Promise<void> =>
   human("review.await-review", {
     message,
@@ -119,6 +125,7 @@ export const awaitReview = (
     file: REVIEW,
     mode: "review",
     base,
+    ...(acceptClean ? { acceptClean } : {}),
   })
 
 /** The round at commit `round` left no `.gtd/REVIEW.md`. */

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

@@ -5,51 +5,11 @@ import {
   type CodeThreadInfo,
   type StepRequest,
 } from "../../flows/index.js"
-import { fixQualityFindings, handOffReview, REVIEW_ORIG } from "./tail.js"
+import { handOffReview, REVIEW_ORIG } from "./tail.js"
 import { fixtureContext } from "./text.fixture.js"
 
 afterEach(() => installContext(undefined))
 
-describe("the quality fix loop", () => {
-  it("a fix that resolves QUALITY.md and rewrites a scenario ends after the wording gate", async () => {
-    const QUALITY = ".gtd/QUALITY.md"
-    const log: string[] = []
-    const files = new Map([
-      [QUALITY, "- finding"],
-      ["e2e/a.feature", "Given a"],
-    ])
-    let last: readonly Change[] = []
-    installContext(
-      fixtureContext(
-        {},
-        {
-          step: (request: StepRequest) => {
-            if (request.kind === "restart") return Promise.resolve()
-            log.push(request.name)
-            last = []
-            if (request.name === "fix.quality.fixing") {
-              files.delete(QUALITY)
-              files.set("e2e/a.feature", "Given b")
-              last = [{ path: QUALITY, status: "deleted", before: "- finding", after: undefined }]
-            }
-            return Promise.resolve()
-          },
-          pushScope: () => undefined,
-          popScope: () => undefined,
-          read: (path) => files.get(path),
-          changes: () => last,
-          matches: (path, pattern) => path === pattern,
-          head: () => "h2",
-          start: () => "h0",
-        },
-      ),
-    )
-    const frozen = { at: "h1", texts: { "e2e/a.feature": "Given a" } }
-    expect(await fixQualityFindings({ rounds: 0 }, frozen)).toBe(true)
-    expect(log).toEqual(["fix.quality.fixing", "scenario-wording"])
-  })
-})
-
 const REVIEW = ".gtd/REVIEW.md"
 const reviewDoc = (note: string): string =>
   [

package/src/workflows/shared/tail.ts

@@ -1,9 +1,7 @@
-import { quote, read, refuse, removeScript, run, scope, vars } from "../../flows/index.js"
+import { read, refuse, removeScript, run, scope, showScript, vars } from "../../flows/index.js"
 import * as kit from "../../workflow-kit/index.js"
 import { escalation, FIX_CAP, healthy, type EscalationCount } from "./health.js"
-import { guarded, type FrozenScenarios } from "./scenarios.js"
 import {
-  ARCHITECTURE,
   awaitReview,
   fixCheck,
   fixQuality,
@@ -15,7 +13,6 @@ import {
   reviewQuality,
 } from "./steps.js"
 import * as t from "./text.js"
-import type { BuildContext } from "./text.js"
 
 /** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
 export const REVIEW_ORIG = ".gtd/REVIEW.orig.md"
@@ -29,22 +26,14 @@ export const qualityLap = (): Promise<"clean" | "findings"> =>
   kit.qualityLap(kit.lensesOf(vars.qualityReviews ?? ""), reviewQuality, QUALITY)
 
 /** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
-export const fixQualityFindings = (
-  escalations: EscalationCount,
-  frozen?: FrozenScenarios,
-): Promise<boolean> =>
+export const fixQualityFindings = (escalations: EscalationCount): Promise<boolean> =>
   kit.fixFindings({
-    fix: guarded(frozen, fixQuality),
+    fix: fixQuality,
     findings: QUALITY,
     cap: FIX_CAP,
     escalate: () => escalation(escalations),
   })
 
-/** What the tail's full run knows of a plan the process built. */
-export interface TailPlan extends BuildContext {
-  readonly frozen: FrozenScenarios | undefined
-}
-
 /** `.gtd/REVIEW.md` removed at the end of a round at commit `round`. */
 export const closeReview = (round: string): Promise<void> =>
   run("review.closing", removeScript([REVIEW, REVIEW_ORIG]), {
@@ -63,47 +52,33 @@ export const refusePendingHandOff = (): void => {
 
 /**
  * The build tail: fix (when entered red), keep green, the quality lap, then
- * `finish` — the human review, as the calling workflow runs it.
+ * `finish` — the human review, as the calling workflow runs it. `green`: the
+ * caller just left the full suite green (the package loop), so no run opens it.
  */
 export const tail = <T>(
   fixFirst: boolean,
-  finish: (escalations: EscalationCount, frozen: FrozenScenarios | undefined) => Promise<T>,
-  built?: TailPlan,
+  finish: (escalations: EscalationCount) => Promise<T>,
+  green = false,
 ): Promise<T> =>
   scope("build", async () => {
-    const frozen = built?.frozen
     const escalations: EscalationCount = { rounds: 0 }
-    const guardedFix = guarded(frozen, () => fixCheck())
+    const fix = fixCheck
     const repair = async () => {
-      await guardedFix()
-      await healthy(guardedFix, { fixesSoFar: 1, escalations })
+      await fix()
+      await healthy(fix, { fixesSoFar: 1, escalations })
     }
     // fixFirst's own fix + healthy below already is the full run.
     if (fixFirst) await repair()
-    else {
-      await healthy(
-        guarded(frozen, () => fixCheck(built)),
-        { escalations, sweepOnGreen: [ARCHITECTURE] },
-      )
-    }
+    else if (!green) await healthy(fix, { escalations })
     // The lap runs once a tail: after its findings are fixed, review follows.
     if ((await qualityLap()) === "findings") {
-      if (await fixQualityFindings(escalations, frozen)) {
-        await healthy(guardedFix, { escalations })
+      if (await fixQualityFindings(escalations)) {
+        await healthy(fix, { escalations })
       } else await repair()
     }
-    return finish(escalations, frozen)
+    return finish(escalations)
   })
 
-// The committed blob, not the working copy: the human's notes already landed over it.
-const handOffScript = (reviewed: string): string =>
-  [
-    "#!/usr/bin/env sh",
-    "set -e",
-    `git show ${quote(`${reviewed}:${REVIEW}`)} > ${quote(REVIEW_ORIG)}`,
-    "",
-  ].join("\n")
-
 /**
  * The review and fix workflows' human review since `base`: a sign-off closes
  * `.gtd/REVIEW.md`; a note leaves it, with the reviewer's own version as
@@ -114,12 +89,13 @@ export const handOffReview = (base: string, escalations: EscalationCount): Promi
     file: REVIEW,
     reviewing,
     fixRisks,
-    keepGreen: () => healthy(() => fixCheck(), { escalations }),
+    keepGreen: () => healthy(fixCheck, { escalations }),
     awaitReview: (b) => awaitReview(b, t.handOffAwaitReviewMessage(b)),
     reviewMissing,
     close: closeReview,
     handOff: (reviewed) =>
-      run("review.handing-off", handOffScript(reviewed), {
+      // The committed blob, not the working copy: the human's notes already landed over it.
+      run("review.handing-off", showScript(reviewed, REVIEW, REVIEW_ORIG), {
         label: "Handing your notes to fix",
       }),
     threadsPending:

package/src/workflows/shared/text.fixture.ts

@@ -114,6 +114,7 @@ export const captureStep = async (
         captured = request
         return Promise.resolve()
       },
+      changesSince: () => [],
     }),
   )
   try {

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

@@ -1,5 +1,11 @@
+import { execFileSync } from "node:child_process"
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
 import { describe, expect, it } from "vitest"
 import {
+  buildReviewTriageMessage,
+  deferNotesScript,
   buildReviewReviewingPrompt,
   agentWithSkills,
   architectureAuthorPrompt,
@@ -14,6 +20,7 @@ import {
   summaryPrompt,
   withSkills,
 } from "./text.js"
+import { applyEmittedScript, InMemRepo } from "../../testkit/index.js"
 import { captureStep, renderText } from "./text.fixture.js"
 
 describe("withSkills", () => {
@@ -175,50 +182,11 @@ describe("architectureAuthorPrompt", () => {
   })
 })
 
-describe("buildFixPrompt with build context", () => {
-  const built = {
-    ranges: [
-      { pkg: "00-scenarios", from: "aaa1111", to: "bbb2222" },
-      { pkg: "01-engine", from: "bbb2222", to: "ccc3333" },
-    ],
-    scenarios: { added: ["tests/new.feature"], changed: ["tests/old.feature"] },
-  }
-
-  it("points at the architecture document", () => {
-    expect(renderText(() => buildFixPrompt(built))).toContain(".gtd/ARCHITECTURE.md")
-  })
-
-  it("lists new scenario paths as likely missing wiring", () => {
-    const prompt = renderText(() => buildFixPrompt(built))
-    expect(prompt).toContain("tests/new.feature")
-    expect(prompt).toContain("missing wiring")
-  })
-
-  it("lists changed or existing scenarios as regressions", () => {
-    const prompt = renderText(() => buildFixPrompt(built))
-    expect(prompt).toContain("regression")
-    expect(prompt).toContain("tests/old.feature")
-  })
-
-  it("lists one range line per package", () => {
-    const prompt = renderText(() => buildFixPrompt(built))
-    expect(prompt).toContain("git log --oneline aaa1111..bbb2222  # 00-scenarios")
-    expect(prompt).toContain("git log --oneline bbb2222..ccc3333  # 01-engine")
-  })
-
-  it("is today's prompt without a build context", () => {
+describe("buildFixPrompt", () => {
+  it("starts each bullet on its own line", () => {
     const prompt = renderText(() => buildFixPrompt())
-    expect(renderText(() => buildFixPrompt(undefined))).toBe(prompt)
     expect(prompt).toMatch(/\n- Leave everything uncommitted — do not commit\n$/)
     expect(prompt).toContain("writes its own\n- Leave")
-    expect(prompt).not.toContain("ARCHITECTURE")
-    expect(prompt).not.toContain("git log --oneline")
-  })
-
-  it("starts each bullet on its own line", () => {
-    const prompt = renderText(() => buildFixPrompt(built))
-    expect(prompt).toMatch(/^- Read `\.gtd\/ARCHITECTURE\.md`/m)
-    expect(prompt).toMatch(/^- Leave everything uncommitted/m)
   })
 })
 
@@ -353,3 +321,123 @@ describe("buildReviewReviewingPrompt risk marking", () => {
     expect(prompt).toContain("re-mark only a risk the fix did not resolve")
   })
 })
+
+describe("deferNotesScript", () => {
+  const run = (notes: Parameters<typeof deferNotesScript>[0], existing?: string): string => {
+    const dir = mkdtempSync(join(tmpdir(), "defer-"))
+    mkdirSync(join(dir, ".gtd"))
+    if (existing !== undefined) writeFileSync(join(dir, ".gtd/TODO.md"), existing)
+    execFileSync("sh", ["-c", deferNotesScript(notes, "abcdef1234567890")], { cwd: dir })
+    return readFileSync(join(dir, ".gtd/TODO.md"), "utf8")
+  }
+  const notes = [{ id: "note-1", anchor: "a.ts:3", text: "plain", label: "could: tiny" }]
+
+  it("creates the file with one section headed by the round's short sha", () => {
+    expect(run(notes)).toBe(
+      "## Deferred review notes (abcdef1)\n\n- note-1 — a.ts:3 (could: tiny): plain\n",
+    )
+  })
+
+  it("appends after a blank line, never truncating", () => {
+    const out = run(notes, "# Sketch\n\nkeep me\n")
+    expect(out.startsWith("# Sketch\n\nkeep me\n\n## Deferred review notes (abcdef1)\n")).toBe(true)
+  })
+
+  it("separates from a file lacking a trailing newline", () => {
+    expect(run(notes, "keep")).toContain("keep\n\n## Deferred")
+  })
+
+  it("lands quotes, dollars and backticks verbatim", () => {
+    const text = 'it\'s $HOME `x` "q" \\n'
+    const out = run([{ id: "note-1", anchor: "a", text }])
+    expect(out).toContain(text)
+  })
+
+  it("is an oxfmt fixed point, for a note longer than one line", () => {
+    const long = [
+      {
+        id: "note-3",
+        anchor: "Parser accepts CRLF ./src/parse.ts#30-31",
+        text: "rename the helper to something clearer please",
+        label: "could",
+      },
+    ]
+    const dir = mkdtempSync(join(tmpdir(), "fmt-"))
+    const file = join(dir, "TODO.md")
+    writeFileSync(file, run(long, "# Sketch\n"))
+    execFileSync("npx", ["oxfmt", "--check", file], { cwd: process.cwd() })
+  })
+})
+
+describe("severity wording", () => {
+  it("triage message names the four severity ids", () => {
+    const m = renderText(() => buildReviewTriageMessage())
+    for (const id of ["note-<n>.security", ".reversibility", ".blastRadius", ".newConcept"])
+      expect(m).toContain(id)
+  })
+
+  it("collecting prompt keeps capture order and carries labels", () => {
+    const p = renderText(() => buildReviewCollectingPrompt("capture"))
+    expect(p).toContain("capture order")
+    expect(p).toContain("(tier: reason)")
+  })
+
+  it("design triage parks deferred review notes", () => {
+    expect(renderText(() => designTriagePrompt("base"))).toContain("## Deferred review notes")
+  })
+})
+
+describe("deferNotesScript — the in-memory recognizer agrees with the real sh script", () => {
+  const notes = [
+    { id: "note-1", anchor: "a.ts:3", text: 'it\'s $HOME `x` "q" 100%', label: "could" },
+    {
+      id: "note-2",
+      anchor: "Parser accepts CRLF ./src/parse.ts#30-31",
+      text: "rename the helper to something clearer please",
+      label: "could",
+    },
+  ]
+  const cases: [string, string | undefined][] = [
+    ["no file", undefined],
+    ["an empty file", ""],
+    ["a file without a trailing newline", "keep"],
+    ["a file with a trailing newline", "# Sketch\n\nkeep\n"],
+  ]
+
+  it.each(cases)("%s", (_name, existing) => {
+    const script = deferNotesScript(notes, "abcdef1234567890")
+    const dir = mkdtempSync(join(tmpdir(), "defer-contract-"))
+    if (existing !== undefined) {
+      mkdirSync(join(dir, ".gtd"))
+      writeFileSync(join(dir, ".gtd/TODO.md"), existing)
+    }
+    execFileSync("sh", ["-c", script], { cwd: dir })
+    const real = readFileSync(join(dir, ".gtd/TODO.md"), "utf8")
+
+    const repo = new InMemRepo()
+    if (existing !== undefined) repo.writeFile(".gtd/TODO.md", existing)
+    expect(applyEmittedScript(repo, new Map(), script).ok).toBe(true)
+    expect(repo.readFile(".gtd/TODO.md")).toBe(real)
+  })
+})
+
+describe("buildReviewReviewingPrompt scenarios", () => {
+  it("names each removed assertion and asks for a Weakened: note", () => {
+    const prompt = renderText(() =>
+      buildReviewReviewingPrompt("base", undefined, [
+        {
+          path: "e2e/a.feature",
+          lines: [{ scenario: "Scenario: shown", line: "Then it is shown" }],
+        },
+      ]),
+    )
+    expect(prompt).toContain("e2e/a.feature — Scenario: shown — Then it is shown")
+    expect(prompt).toContain("`Weakened:`")
+  })
+
+  it("asks for no Weakened: note when nothing was removed", () => {
+    const prompt = renderText(() => buildReviewReviewingPrompt("base"))
+    expect(prompt).toContain("## Scenarios")
+    expect(prompt).not.toContain("Weakened:")
+  })
+})