@pmelab/gtd 24.4.0 → 26.0.0

package/src/workflows/feature/packages.ts

@@ -1,6 +1,5 @@
 import {
   changesSince,
-  type Change,
   glob,
   head,
   read,
@@ -10,12 +9,9 @@ import {
   scope,
 } from "../../flows/index.js"
 import { healthy } from "../shared/health.js"
-import { freezeScenarios, guarded, type FrozenScenarios } from "../shared/scenarios.js"
+import { ARCHITECTURE } from "../shared/steps.js"
 import { build, fixSuite } from "./steps.js"
 
-/** Package 0: the e2e scenarios, written red. */
-export const SCENARIO_PACKAGE = ".gtd/packages/00-e2e-scenarios.md"
-
 export interface DeclaredTest {
   readonly level: "unit" | "e2e"
   readonly path: string
@@ -62,68 +58,33 @@ export const requireDeclaredTests = (pkg: string, since: string): void => {
   )
 }
 
-export interface PackageRange {
-  readonly pkg: string
-  readonly from: string
-  readonly to: string
-}
-
-export interface BuiltPlan {
-  readonly ranges: readonly PackageRange[]
-  /** Paths package 0 added / modified outside `.gtd/`. */
-  readonly scenarios: { readonly added: readonly string[]; readonly changed: readonly string[] }
-  /** The wording snapshot after this run, to guard the tail and later laps. */
-  readonly frozen: FrozenScenarios | undefined
-}
-
-/** Build `pkg`, check its declared tests, keep the fast suite green, and close it out, which removes it. */
-export const packageItem = async (pkg: string, frozen?: FrozenScenarios): Promise<PackageRange> => {
+/**
+ * Build `pkg`, check its declared tests, keep the full suite green, and close
+ * it out, which removes it — and `.gtd/ARCHITECTURE.md` with the last one.
+ */
+export const packageItem = async (pkg: string): Promise<void> => {
   const from = head()
   // Rechecked after every fix too: a fix deleting a red declared test would
-  // otherwise green the suite. Before the wording gate, so it refuses the turn.
+  // otherwise green the suite.
   const declared = (turn: () => Promise<void>) => async () => {
     await turn()
     requireDeclaredTests(pkg, from)
   }
-  await guarded(
-    frozen,
-    declared(() => build(pkg)),
-  )()
-  await healthy(guarded(frozen, declared(fixSuite)), { suite: "fast" })
-  await run("closing", removeScript([pkg, ".gtd/SATISFIED.md"]), {
+  await declared(() => build(pkg))()
+  await healthy(declared(fixSuite))
+  const last = glob(".gtd/packages/*.md").length === 1
+  await run("closing", removeScript([pkg, ".gtd/SATISFIED.md", ...(last ? [ARCHITECTURE] : [])]), {
     label: "Closing out the package",
   })
-  return { pkg, from, to: head() }
 }
 
 /** The first queued package — the one a package step works on. */
 export const nextPackage = (): string | undefined => [...glob(".gtd/packages/*.md")].sort()[0]
 
-const outsideGtd = (path: string): boolean => path !== ".gtd" && !path.startsWith(".gtd/")
-
 /** Build every package file under `.gtd/packages/`, in name order. */
-export const packages = (carried?: FrozenScenarios): Promise<BuiltPlan> =>
+export const packages = (): Promise<void> =>
   scope("packages", async () => {
-    let frozen = carried
-    const ranges: PackageRange[] = []
-    // Captured right after package 0: a later diff to the tree would also hold what 01…N touch.
-    let touched: readonly Change[] = []
     for (let pkg = nextPackage(); pkg !== undefined; pkg = nextPackage()) {
-      const range = await scope("item", () =>
-        packageItem(pkg, pkg === SCENARIO_PACKAGE ? undefined : frozen),
-      )
-      ranges.push(range)
-      if (pkg === SCENARIO_PACKAGE) {
-        touched = changesSince(range.from).filter(
-          (c) => outsideGtd(c.path) && c.status !== "deleted",
-        )
-        frozen = freezeScenarios(
-          touched.filter((c) => c.path.endsWith(".feature")).map((c) => c.path),
-          frozen,
-        )
-      }
+      await scope("item", () => packageItem(pkg))
     }
-    const paths = (status: string): string[] =>
-      touched.filter((c) => c.status === status).map((c) => c.path)
-    return { ranges, scenarios: { added: paths("added"), changed: paths("modified") }, frozen }
   })

package/src/workflows/feature/planning.ts

@@ -54,7 +54,7 @@ export const architecture = (): Promise<void> =>
     }
     if (changes(ARCHITECTURE).some((c) => c.status === "deleted")) {
       refuse(
-        "gtd land: decompose: keep .gtd/ARCHITECTURE.md — the build tail's full run needs it; it is removed only once that run is green",
+        "gtd land: decompose: keep .gtd/ARCHITECTURE.md — the packages are built from it; it is removed with the last package",
       )
     }
   })

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

@@ -370,53 +370,6 @@ describe("the default quality lenses", () => {
   })
 })
 
-describe("scenario wording in review's fix turns", () => {
-  const frozen = { at: "h1", texts: { "e2e/a.feature": "Given a" } }
-  const risky = doc(["Risk: drops the carry", "sub"])
-
-  it("a green-keeping fix after a risk fix that rewrites a scenario stops at review.scenario-wording", async () => {
-    const log: string[] = []
-    let red = false
-    let drifted = false
-    installContext(
-      fixtureContext(
-        {},
-        {
-          step: (request: StepRequest) => {
-            if (request.kind === "restart") return Promise.resolve()
-            log.push(request.name)
-            if (request.name === "health.check") red = !red && !drifted
-            if (request.name === "fix") drifted = true
-            if (request.name === "scenario-wording") throw new Stop()
-            return Promise.resolve()
-          },
-          pushScope: () => undefined,
-          popScope: () => undefined,
-          read: (path) =>
-            path === REVIEW
-              ? risky
-              : path === "e2e/a.feature"
-                ? drifted
-                  ? "Given b"
-                  : "Given a"
-                : undefined,
-          changes: (): readonly Change[] =>
-            red
-              ? [{ path: ".gtd/FEEDBACK.md", status: "added", before: undefined, after: "red" }]
-              : [],
-          matches: (path, pattern) => path === pattern,
-          head: () => "h2",
-          start: () => "h0",
-        },
-      ),
-    )
-    await review("base", undefined, frozen).catch((e: unknown) => {
-      if (!(e instanceof Stop)) throw e
-    })
-    expect(log.slice(-2)).toEqual(["fix", "scenario-wording"])
-  })
-})
-
 describe("severityOf", () => {
   const note = (forced = false): ReviewNote => ({
     id: "n",

package/src/workflows/feature/review.ts

@@ -10,7 +10,6 @@ import {
 import type { ReviewNote } from "../../steering/index.js"
 import * as kit from "../../workflow-kit/index.js"
 import { healthy, type EscalationCount } from "../shared/health.js"
-import { guarded, type FrozenScenarios } from "../shared/scenarios.js"
 import {
   awaitReview,
   fixCheck,
@@ -22,7 +21,6 @@ import {
 } from "../shared/steps.js"
 import { closeReview, tail } from "../shared/tail.js"
 import * as t from "../shared/text.js"
-import type { BuiltPlan } from "./packages.js"
 import { answerReviewQuestions, collecting, deferNotes, fixNits } from "./steps.js"
 
 export type { ReviewOutcome } from "../../workflow-kit/index.js"
@@ -167,7 +165,6 @@ const isCode = (path: string): boolean => path !== ".gtd" && !path.startsWith(".
 export const review = (
   base: string,
   escalations: EscalationCount = { rounds: 0 },
-  frozen?: FrozenScenarios,
 ): Promise<kit.ReviewOutcome> => {
   const severities = new Map<string, Severity>()
   // Armed by a defer-only round and spent at the very next gate; a fresh
@@ -181,8 +178,8 @@ export const review = (
       deferred = []
       return reviewing(b, carry)
     },
-    fixRisks: (risks) => guarded(frozen, () => fixRisks(risks), "review")(),
-    keepGreen: () => healthy(guarded(frozen, fixCheck, "review"), { escalations }),
+    fixRisks,
+    keepGreen: () => healthy(fixCheck, { escalations }),
     awaitReview: (b) => {
       const notes = deferred
       deferred = []
@@ -203,7 +200,7 @@ export const review = (
       return deferNotes(deferred, head())
     },
     answerQuestions: answerReviewQuestions,
-    fixNits: (notes) => guarded(frozen, () => fixNits(notes), "review")(),
+    fixNits,
     close: closeReview,
     captures: {
       edits: t.reviewEditsCapture,
@@ -238,10 +235,9 @@ export const review = (
   })
 }
 
-/** The build tail: fix (when entered red), keep green, the 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 const buildTail = (
   fixFirst: boolean,
   base: string,
-  built?: BuiltPlan,
-): Promise<kit.ReviewOutcome> =>
-  tail(fixFirst, (escalations, frozen) => review(base, escalations, frozen), built)
+  green = false,
+): Promise<kit.ReviewOutcome> => tail(fixFirst, (escalations) => review(base, escalations), green)

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/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.ts

@@ -18,7 +18,6 @@ export const ShippedOptions = Schema.Struct({
   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> =>

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 { 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,36 +52,31 @@ 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)
   })
 
 /**
@@ -105,7 +89,7 @@ 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,

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

@@ -182,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)
   })
 })
 
@@ -459,3 +420,24 @@ describe("deferNotesScript — the in-memory recognizer agrees with the real sh
     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:")
+  })
+})