@pmelab/gtd 24.4.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/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:")
+  })
+})

package/src/workflows/shared/text.ts

@@ -10,7 +10,7 @@ import {
   type AgentOptions,
   type SummaryContext,
 } from "../../flows/index.js"
-import type { WordingDrift } from "../../workflow-kit/index.js"
+import type { RemovedAssertions } from "../../workflow-kit/index.js"
 import {
   accessPreamble,
   skillsPreamble,
@@ -274,7 +274,8 @@ ${footnoteFoldIn}${codeThreadReplies()}
 - Every open point here is TECHNICAL — triage already resolved
   the product ones, one phase earlier. PERMISSIVE: answer it
   yourself unless you genuinely cannot defend a default; a wrong
-  technical call is still caught by the full run and the quality lap
+  technical call is still caught by each package's suite run and the
+  quality lap
 - The narrow exception: a simplification that drops something
   \`.gtd/REQUIREMENTS.md\` mentions is an open question, not a
   silent default
@@ -286,11 +287,13 @@ ${footnoteFoldIn}${codeThreadReplies()}
      only, as fenced TypeScript (or the repository's language)
   3. \`## Call Stacks\` — seam level, entry point → module
      boundary; one line per hop, never per line of code
-  4. \`## E2E Scenarios\` — Gherkin in fenced \`gherkin\` blocks
-     (whatever e2e framework the repository uses), each preceded
-     by a line \`- e2e: <path>\`. With no user-visible
-     behaviour change, the literal line \`No e2e change.\` plus a
-     one-line reason — never empty or missing
+  4. \`## E2E Scenarios\` — one line per user-visible behaviour,
+     \`- e2e: <path> — <behaviour> (covers <concern>)\`, in plain
+     words: the builder writes the scenario in the repository's
+     own e2e framework, so never spell out Gherkin here. With no
+     user-visible behaviour change, the literal line
+     \`No e2e change.\` plus a one-line reason — never empty or
+     missing
   5. \`## Unit Tests\` — one \`### <interface>\` per entry of
      \`## Interfaces\`, each test a line
      \`- unit: <path> — <behaviour> (covers <concern>)\`;
@@ -320,35 +323,31 @@ export const architectureDecomposePrompt = (): string =>
 ${stateFileRules}
 - The only state files this turn touches are the package files
   under \`.gtd/packages/\` — no other files for notes or output.
-  Never delete \`.gtd/ARCHITECTURE.md\`: the build tail's full run
-  still needs it, and package files may reference it
+  Never delete \`.gtd/ARCHITECTURE.md\`: package files may
+  reference it, and it is removed with the last package
 - Work from \`.gtd/ARCHITECTURE.md\` if you wrote it earlier this
   conversation, otherwise read it (the converged technical
   plan). It already lists the concerns, interfaces, e2e scenarios
   and unit tests — this turn groups them into packages. A
   \`## Merged Concerns\` heading there records merges, never a
   concern of its own: write no package file for it
-- A package is a consecutive run of \`## Unit Tests\` entries that go
-  green together on the fast suite, at most ~8 unit-test entries
-  each. Keep the merge rule: concerns whose footprints centre on the
-  same files stay in one package unless the later one only consumes
-  an interface the earlier one creates. Prefer fewer, larger
-  packages. Order them so each stays green on the fast suite —
-  interface-introducing packages first
+- A package is one concern's slice, and each must leave the full
+  suite green — every package boundary costs a full run, so write
+  as few as the concerns allow. Keep the merge rule: concerns whose
+  footprints centre on the same files stay in one package unless
+  the later one only consumes an interface the earlier one creates.
+  Order them interface-introducing packages first
 - Write the packages under \`.gtd/packages/\`, each carrying its
   requirement(s) — both, independently, if merged — its tasks, and
   each task's acceptance criteria as \`- [ ]\` checkboxes and
   relevant paths:
-  - \`.gtd/packages/00-e2e-scenarios.md\` — package 0: it writes
-    \`## E2E Scenarios\` as tests in the repository's own e2e
-    framework and leaves them red. Write no such file when
-    \`## E2E Scenarios\` says "No e2e change."
-  - \`01-…\` onward — the unit-test packages. A requirement no test
-    covers (docs, README, deletions, config) becomes a chore
-    package, or a task of one; chore packages declare no tests
-  - the last numbered package is the wiring package: CLI entry,
-    workflow composition, config. A red e2e after it is a bug, not
-    missing work
+  - \`01-…\` onward — one vertical slice each: the unit tests,
+    the code, the wiring (CLI entry, workflow composition, config)
+    and every \`## E2E Scenarios\` entry its concern covers, so the
+    slice ends with its scenarios passing. A requirement no test
+    covers (docs, README, deletions, config) is a task of the slice
+    it belongs to; only one no slice owns becomes a chore package,
+    which declares no tests
 - Every package with tests has a \`## Tests\` section, one line per
   declared test, copied from the architecture entries:
   \`- unit: \\\`<path>\\\`\` or \`- e2e: \\\`<path>\\\`\`. Chore packages have
@@ -398,10 +397,10 @@ export const packagesItemBuildingPrompt = (pkg: string): string =>
 - Write the tests the package declares under \`## Tests\` first,
   then the code that makes them pass; the turn is refused unless
   every declared test is in your diff
-- Package 0 (\`.gtd/packages/00-e2e-scenarios.md\`) writes the scenarios verbatim
-  from \`## E2E Scenarios\` of \`.gtd/ARCHITECTURE.md\`, with only
-  step code that typechecks, and leaves them red — no
-  implementation
+- A declared e2e test is a scenario in the repository's own e2e
+  framework for the behaviour its \`## E2E Scenarios\` entry names.
+  Word it to fit the existing steps — reuse and generalise them
+  rather than adding one-off ones
 - Implement every task the package describes, no more, no less,
   fanning independent ones out to parallel subagents where your
   harness supports it; leave other package files untouched
@@ -470,34 +469,10 @@ turn, or land untouched to give it one more attempt at the same
 analysis.
 `
 
-/** What the tail's full-run fix needs of a `BuiltPlan` (structural: `packages.ts` imports this module). */
-export interface BuildContext {
-  readonly ranges: readonly { readonly pkg: string; readonly from: string; readonly to: string }[]
-  readonly scenarios: {
-    readonly added: readonly string[]
-    readonly changed: readonly string[]
-  }
-}
-
-const buildContextPrompt = (built: BuildContext): string => {
-  const list = (paths: readonly string[]): string =>
-    paths.length === 0 ? "  (none)" : paths.map((path) => `  - ${path}`).join("\n")
-  return `- Read \`.gtd/ARCHITECTURE.md\` — the plan every package was built from
-- A red scenario that is NEW in this plan likely means missing wiring
-  between packages; new scenarios:
-${list(built.scenarios.added)}
-- A red CHANGED or existing scenario or test is a regression a package
-  introduced; scenarios this plan changed:
-${list(built.scenarios.changed)}
-- Each package's commits, to bisect a break:
-${built.ranges.map((r) => `  git log --oneline ${r.from}..${r.to}  # ${r.pkg}`).join("\n")}
-`
-}
-
-export const buildFixPrompt = (built?: BuildContext): string =>
+export const buildFixPrompt = (): string =>
   `${stateFileRules}
 ${fixFeedbackPrompt}
-${built === undefined ? "" : buildContextPrompt(built)}- Leave everything uncommitted — do not commit
+- Leave everything uncommitted — do not commit
 `
 
 export const finisherSystem = (): string =>
@@ -888,7 +863,28 @@ actionability, and never dismiss a real note or edit as approval.
   the sign-off
 `
 
-export const buildReviewReviewingPrompt = (base: string, carry?: string): string =>
+const scenariosPrompt = (removed: readonly RemovedAssertions[]): string =>
+  `- When a scenario in a \`.feature\` file was added or changed since the
+  base, the first chunk is \`## Scenarios\`: one pointer per such
+  scenario, its note saying in plain words what behaviour it now pins
+  down — the human signs off the scenarios here, nowhere else
+${
+  removed.length === 0
+    ? ""
+    : `- These assertions of scenarios that existed at the base are gone:
+${removed.map(({ path, lines }) => lines.map((a) => `    ${path} — ${a.scenario} — ${a.line}\n`).join("")).join("")}  Open the note of each scenario that lost one with \`Weakened:\`,
+  naming the lost line and whether \`.gtd/REQUIREMENTS.md\` asked
+  for it. A scenario that no longer exists has no pointer of its own:
+  put its \`Weakened:\` note on a pointer of the chunk covering its
+  removal
+`
+}`
+
+export const buildReviewReviewingPrompt = (
+  base: string,
+  carry?: string,
+  removed: readonly RemovedAssertions[] = [],
+): string =>
   `${styleBlock}
 
 ${styleFormatContract}
@@ -931,7 +927,7 @@ review the changes:
   A note sitting entirely on the line(s) beneath the pointer is
   also valid. Either way, the note must never start with a bare \`./path\` token
   — that parses as a second pointer, not a note
-No diff is given — read the changes yourself. The range runs
+${scenariosPrompt(removed)}No diff is given — read the changes yourself. The range runs
 from \`${base}\` to the working tree (committed turns
 plus anything pending); on a feedback round that's the previous
 review's boundary, so it covers only what's new.
@@ -986,19 +982,3 @@ ${it.processCostByModel.map((m) => `- ${m.model}: ${m.cost}\n`).join("")}
 Print the closing message and stop — this writes nothing itself.
 `
 }
-
-export const scenarioWordingMessage = (at: string, drifted: readonly WordingDrift[]): string =>
-  `The e2e scenario wording was frozen when package 0 landed, and the last
-turn changed it. Removed lines are marked \`-\`, added ones \`+\`:
-
-${drifted.map(({ path, lines }) => `${path}\n${lines.join("\n")}`).join("\n\n")}
-
-To accept the change, land untouched.
-
-To reject it, run
-
-    git checkout ${at} -- ${drifted.map(({ path }) => quote(path)).join(" ")}
-
-and land. Restoring only some of the files is a partial accept: every file
-still differing from the frozen wording is accepted.
-`

package/src/workflows/shared/vars.ts

@@ -20,7 +20,6 @@ export const defaults: Readonly<Record<string, string>> = {
 /** Environment settings. */
 export const envDefaults: Readonly<Record<string, string>> = {
   testCommand: "npm test",
-  fastTestCommand: "",
   plannerModel: "smart",
   coderModel: "base",
 }