@pmelab/gtd 23.2.0 → 24.1.0

package/src/workflow-kit/review.ts

@@ -0,0 +1,324 @@
+import {
+  changes,
+  changesSince,
+  hasThreadFor,
+  head,
+  read,
+  refuse,
+  requireReplies,
+  requireThreadsClosed,
+  type Change,
+} from "../flows/index.js"
+import { reviewNotes, reviewRisks, stripCodeThreads, type ReviewNote } from "../steering/index.js"
+
+/** How a review round ended. `feedback` carries what the human edited, for the re-unwind to undo. */
+export type ReviewOutcome =
+  | { readonly verdict: "signoff" }
+  | {
+      readonly verdict: "feedback"
+      /** The last round's commit, the re-plan base. */
+      readonly base: string
+      /** The commit the review file was written at; edits are restored from it. */
+      readonly restoreFrom: string
+      /** The code paths the rounds changed, with their content before. */
+      readonly edited: readonly Change[]
+    }
+
+export type Verdict = "edit" | "question" | "nit" | "praise"
+
+export type ReviewRisk = ReturnType<typeof reviewRisks>[number]
+
+/** Everything a review round decides or says, passed in: its files, steps, judge and texts. */
+export interface ReviewPolicy {
+  /** The review steering file the reviewer writes and the human annotates. */
+  readonly file: string
+  /** The file a collecting turn folds feedback into; its presence means feedback. */
+  readonly feedback: string
+  /** Whether a path is code, as opposed to steering state. */
+  readonly isCode: (path: string) => boolean
+  /** Write `file` over everything since `base`, carrying the answers of commit `carry` when given. */
+  readonly reviewing: (base: string, carry?: string) => Promise<void>
+  readonly fixRisks: (risks: readonly ReviewRisk[]) => Promise<void>
+  readonly keepGreen: () => Promise<void>
+  readonly awaitReview: (base: string) => Promise<void>
+  /** The round at commit `round` left no `file`. */
+  readonly reviewMissing: (round: string) => Promise<void>
+  /** Turn the round `capture` describes into `feedback`, or change nothing. */
+  readonly collecting: (capture: string) => Promise<void>
+  /** One verdict per note, keyed by note id; a note without one is an edit. */
+  readonly triage: (notes: readonly ReviewNote[]) => Promise<ReadonlyMap<string, Verdict>>
+  readonly answerQuestions: (notes: readonly ReviewNote[]) => Promise<void>
+  readonly fixNits: (notes: readonly ReviewNote[]) => Promise<void>
+  /** Remove `file` at the end of a round at commit `round`. */
+  readonly close: (round: string) => Promise<void>
+  /** What a collecting turn reads. */
+  readonly captures: {
+    readonly edits: (round: string) => string
+    readonly notes: (round: string) => string
+    readonly editNotes: (
+      round: string,
+      edits: readonly ReviewNote[],
+      answeredAt: string | undefined,
+    ) => string
+  }
+  readonly refusals: {
+    /** `file` was deleted at the gate. */
+    readonly deleted: string
+    /** The collecting turn changed something without writing `feedback`. */
+    readonly unmatched: string
+  }
+}
+
+const collect = async (p: ReviewPolicy, capture: string): Promise<"signoff" | "feedback"> => {
+  await p.collecting(capture)
+  if (read(p.feedback) !== undefined) return "feedback"
+  if (changes().length === 0) return "signoff"
+  return refuse(p.refusals.unmatched)
+}
+
+/** A review with ticks, footnote markers and thread definitions removed: what is left is line notes. */
+const notesOf = (text: string): string =>
+  text
+    .replace(/^\[\^[^\]]+\]:[^\n]*(\n(?: {2,}|\t)[^\n]*|\n(?=\s*\n(?: {2,}|\t)))*/gm, "")
+    .replace(/\[\^[^\]]+\]/g, "")
+    .replace(/\[x\]/gi, "[ ]")
+    .replace(/\s+/g, " ")
+    .trim()
+
+/**
+ * The human gate and its reply rounds: a question gets an answer inside
+ * the review file and rests at the gate again, without a lap. Resolves the
+ * commit of the last collecting turn, `"missing"` when the round left no
+ * review, or `undefined` when no such turn ran.
+ */
+const converse = async (
+  p: ReviewPolicy,
+  base: string,
+  collectedBefore?: string,
+): Promise<string | undefined> => {
+  let collectedAt = collectedBefore
+  for (;;) {
+    await p.awaitReview(base)
+    if (changes(p.file).some((c) => c.status === "deleted")) refuse(p.refusals.deleted)
+    if (read(p.file) === undefined) {
+      await p.reviewMissing(head())
+      return "missing"
+    }
+    requireThreadsClosed(p.file)
+    if (!hasThreadFor("agent", p.file)) return collectedAt
+    await p.collecting(p.captures.edits(head()))
+    collectedAt = head()
+    requireReplies(p.file)
+    if (!hasThreadFor("human", p.file)) return collectedAt
+  }
+}
+
+/** What `finish` hands back to `review`: an outcome, or another lap at the gate. */
+type Finish =
+  | ReviewOutcome
+  | { readonly next: "await"; readonly reviewed: string }
+  | { readonly next: "rereview"; readonly carry: string | undefined }
+
+/** What a round's routing needs from `finish`: its closing step and the ways it ends. */
+interface Round {
+  readonly round: string
+  readonly close: () => Promise<void>
+  readonly outcome: (verdict: "signoff" | "feedback") => ReviewOutcome
+  readonly unfolded: () => Promise<Finish>
+}
+
+/** Judge every note, then run each verdict's route: answers, then nit fixes, then the edits' lap. */
+const routeNotes = async (
+  p: ReviewPolicy,
+  notes: readonly ReviewNote[],
+  r: Round,
+): Promise<Finish> => {
+  const verdicts = await p.triage(notes)
+  const of = (v: Verdict): ReviewNote[] => notes.filter((n) => (verdicts.get(n.id) ?? "edit") === v)
+  const [edits, questions, nits] = [of("edit"), of("question"), of("nit")]
+  if (edits.length + questions.length + nits.length === 0) return r.unfolded()
+
+  let answeredAt: string | undefined
+  if (questions.length > 0) {
+    await p.answerQuestions(questions)
+    answeredAt = head()
+  }
+  if (nits.length > 0) {
+    await p.fixNits(nits)
+    await p.keepGreen()
+  }
+  if (edits.length > 0) {
+    await r.close()
+    return r.outcome(await collect(p, p.captures.editNotes(r.round, edits, answeredAt)))
+  }
+  if (nits.length > 0) {
+    await r.close()
+    return { next: "rereview", carry: answeredAt }
+  }
+  return { next: "await", reviewed: answeredAt! }
+}
+
+/** A code edit, not a thread-only change: lines that only add, answer or remove code threads don't count. */
+const isCodeEdit = (p: ReviewPolicy, c: Change): boolean =>
+  p.isCode(c.path) &&
+  stripCodeThreads(c.path, c.before ?? "") !== stripCodeThreads(c.path, c.after ?? "")
+
+/** Whether anything but thread edits and ticks landed in the review file since `commit`. */
+const notedSince = (p: ReviewPolicy, commit: string): boolean =>
+  changesSince(commit).some(
+    (c) => c.path === p.file && notesOf(c.before ?? "") !== notesOf(read(p.file) ?? ""),
+  )
+
+/**
+ * What the in-loop collecting turn left: `folded` when it wrote `feedback`
+ * (those folds need their lap whatever is judged later), `settled` when only
+ * thread edits and ticks landed after it.
+ */
+const afterCollect = (
+  p: ReviewPolicy,
+  collectedAt: string | undefined,
+): { folded: boolean; settled: boolean } =>
+  // While the collecting turn is still pending its commit has no hash, so no
+  // range can start there; the flow rests at the close before it matters.
+  collectedAt === "" ? { folded: false, settled: false } : settledAfter(p, collectedAt)
+
+const settledAfter = (
+  p: ReviewPolicy,
+  collectedAt: string | undefined,
+): { folded: boolean; settled: boolean } => ({
+  folded: collectedAt !== undefined && read(p.feedback) !== undefined,
+  settled:
+    collectedAt !== undefined &&
+    changesSince(collectedAt).every((c) => !isCodeEdit(p, c)) &&
+    !notedSince(p, collectedAt),
+})
+
+const finish = async (
+  p: ReviewPolicy,
+  reviewed: string,
+  collectedAt: string | undefined,
+): Promise<Finish> => {
+  // Everything the human did is read before any agent turn runs, so a nit fix
+  // is never counted as a hand-edit.
+  const round = head()
+  const since = changesSince(reviewed)
+  const edited = since.filter((c) => isCodeEdit(p, c))
+  const baselineText = since.get(p.file)?.before ?? ""
+  const record = read(p.file) ?? ""
+  const { folded, settled } = afterCollect(p, collectedAt)
+  // The review gate clears every tick before its commit, so a changed
+  // review file is a note, never a tick.
+  const noted = since.some((c) => c.path === p.file)
+  const close = (): Promise<void> => p.close(round)
+  const outcome = (verdict: "signoff" | "feedback"): ReviewOutcome =>
+    verdict === "signoff" ? { verdict } : { verdict, base: round, restoreFrom: reviewed, edited }
+  const unfolded = async (): Promise<Finish> => {
+    await close()
+    return outcome(folded ? "feedback" : "signoff")
+  }
+
+  const collectWith = async (capture: string): Promise<Finish> => {
+    await close()
+    return outcome(await collect(p, capture))
+  }
+  if (settled || (edited.length === 0 && !noted)) return unfolded()
+  if (edited.length > 0) return collectWith(p.captures.edits(round))
+  const notes = reviewNotes(baselineText, record)
+  if (notes.length === 0) return collectWith(p.captures.notes(round))
+  return routeNotes(p, notes, { round, close, outcome, unfolded })
+}
+
+/** Write the review; if it marks risks, fix them, keep green, and write it again — once, so the re-review's own risks reach the human unfixed. */
+const reviewOnce = async (
+  p: Pick<ReviewPolicy, "file" | "reviewing" | "fixRisks" | "keepGreen">,
+  base: string,
+  carry: string | undefined,
+) => {
+  await p.reviewing(base, carry)
+  const risks = reviewRisks(read(p.file) ?? "")
+  if (risks.length === 0) return
+  await p.fixRisks(risks)
+  await p.keepGreen()
+  await p.reviewing(base, carry)
+}
+
+/**
+ * A reviewer writes the review over everything since `base`, a human
+ * reviews and signs off or comments, and each note is judged: edits go to
+ * another lap, questions are answered in place, nits fixed in one batch,
+ * praise dropped.
+ */
+export const review = async (base: string, p: ReviewPolicy): Promise<ReviewOutcome> => {
+  let carry: string | undefined
+  for (;;) {
+    await reviewOnce(p, base, carry)
+    carry = undefined
+    let reviewed = head()
+    let collectedAt: string | undefined
+    for (;;) {
+      collectedAt = await converse(p, base, collectedAt)
+      if (collectedAt === "missing") break
+      const result = await finish(p, reviewed, collectedAt)
+      if (!("next" in result)) return result
+      if (result.next === "rereview") {
+        carry = result.carry
+        break
+      }
+      reviewed = result.reviewed
+    }
+  }
+}
+
+/** What a review round that hands its notes on decides or says, passed in. */
+export interface HandOffPolicy extends Pick<
+  ReviewPolicy,
+  "file" | "reviewing" | "fixRisks" | "keepGreen" | "awaitReview" | "reviewMissing" | "close"
+> {
+  /** Keep `file` with the human's notes for another workflow; `reviewed` holds the reviewer's own version. */
+  readonly handOff: (reviewed: string) => Promise<void>
+  /** `file` was deleted at the gate. */
+  readonly deleted: string
+  /** A thread waits on the agent at the gate, and no turn here answers it. */
+  readonly threadsPending: string
+  /** The review was edited but the edit parses to no note, so `fix` would have nothing to act on. */
+  readonly unparsed: string
+}
+
+/**
+ * A reviewer writes the review over everything since `base` and a human
+ * reviews it. No note signs off and closes; any note ends the round with the
+ * review left in place, for another workflow to read its notes — nothing is
+ * judged or re-planned here.
+ */
+export const reviewToHandOff = async (base: string, p: HandOffPolicy): Promise<void> => {
+  for (;;) {
+    await reviewOnce(p, base, undefined)
+    const reviewed = head()
+    await p.awaitReview(base)
+    if (changes(p.file).some((c) => c.status === "deleted")) refuse(p.deleted)
+    const record = read(p.file)
+    if (record === undefined) {
+      await p.reviewMissing(head())
+      continue
+    }
+    // `fix` runs in a new process, where a code thread is no longer "changed"
+    // and nothing answers it — so none may be left waiting on the agent.
+    requireThreadsClosed(p.file)
+    if (hasThreadFor("agent", p.file)) refuse(p.threadsPending)
+    const since = changesSince(reviewed)
+    const before = since.get(p.file)?.before ?? record
+    if (notesOf(before) === notesOf(record)) {
+      // A hand edit in a sign-off round was never checked or reviewed.
+      if (since.paths.some((f) => !f.startsWith(".gtd/"))) {
+        await p.keepGreen()
+      }
+      await p.close(head())
+      return
+    }
+    // `fix` acts only on parsed notes: an edit with none (a deleted chunk,
+    // stray prose) would be closed away unread, so it is refused here.
+    if (reviewNotes(before, record).length === 0) refuse(p.unparsed)
+    await p.handOff(reviewed)
+    return
+  }
+}

package/src/{workflows → workflow-kit}/scenarios.ts

@@ -1,5 +1,4 @@
-import { head, human, read, scope } from "../flows/index.js"
-import * as t from "./text.js"
+import { head, read } from "../flows/index.js"
 
 /** Mutable: an accepted change moves the snapshot forward. */
 export interface FrozenScenarios {
@@ -93,26 +92,33 @@ const lineDiff = (a: readonly string[], b: readonly string[]): string[] => {
   return [...out, ...a.slice(i).map((l) => `- ${l}`), ...b.slice(j).map((l) => `+ ${l}`)]
 }
 
-export const wordingDrift = (frozen: FrozenScenarios, path: string): t.WordingDrift => ({
+export interface WordingDrift {
+  readonly path: string
+  /** `- `/`+ `-prefixed, in file order. */
+  readonly lines: readonly string[]
+}
+
+export const wordingDrift = (frozen: FrozenScenarios, path: string): WordingDrift => ({
   path,
   lines: lineDiff(lines(frozen.texts[path]), lines(textOf(path))),
 })
 
-/** After a turn: stop at `scenario-wording` while wording drifted; accept moves the snapshot. */
-export const holdWording = async (frozen: FrozenScenarios | undefined): Promise<void> => {
+/**
+ * After a turn: rest at `stop` while wording drifted from `frozen`. Whatever
+ * still differs after it is accepted and moves the snapshot; what was
+ * restored stays frozen as it was.
+ */
+export const holdWording = async (
+  frozen: FrozenScenarios | undefined,
+  stop: (at: string, drifted: readonly WordingDrift[]) => Promise<void>,
+): Promise<void> => {
   if (frozen === undefined) return
   const drifted = driftedScenarios(frozen)
   if (drifted.length === 0) return
-  await human("scenario-wording", {
-    message: t.scenarioWordingMessage(
-      frozen.at,
-      drifted.map((path) => wordingDrift(frozen, path)),
-    ),
-    label: "Scenario wording changed",
-    acceptClean: true,
-    base: frozen.at,
-  })
-  // Still differing is accepted; restored is rejected and stays frozen as it was.
+  await stop(
+    frozen.at,
+    drifted.map((path) => wordingDrift(frozen, path)),
+  )
   const accepted = driftedScenarios(frozen)
   if (accepted.length === 0) return
   for (const path of accepted) {
@@ -122,16 +128,3 @@ export const holdWording = async (frozen: FrozenScenarios | undefined): Promise<
   }
   frozen.at = head()
 }
-
-/** `turn`, then `holdWording`; `within` names the scope the gate rests in. */
-export const guarded =
-  (
-    frozen: FrozenScenarios | undefined,
-    turn: () => Promise<void>,
-    within?: string,
-  ): (() => Promise<void>) =>
-  async () => {
-    await turn()
-    if (within === undefined) await holdWording(frozen)
-    else await scope(within, () => holdWording(frozen))
-  }

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest"
+import { testRepo } from "../../testkit/index.js"
+import { CONFIG_SCAFFOLD } from "../../install/index.js"
+import { reviewDoc } from "../shared/config.fixture.js"
+
+describe("an ordinary feature start", () => {
+  it("unwinds a captured TODO, checks the baseline and starts design from it", async () => {
+    const repo = testRepo({ workflow: CONFIG_SCAFFOLD, env: { GTD_QUALITYREVIEWS: "" } })
+    repo.write("TODO.md", "# Add numbers\n\nadd(a, b) returns the sum.\n")
+    const rest = await repo.drive({ unwind: () => undefined, "start-gate.check": () => undefined })
+    expect(rest).toMatchObject({
+      state: "design.triage",
+      actor: "agent",
+      file: ".gtd/REQUIREMENTS.md",
+    })
+    expect(repo.subjects().slice(1)).toEqual([
+      "gtd(human): idle → unwind",
+      "gtd(check): unwind → start-gate.check",
+      "gtd(check): start-gate.check → design.triage",
+    ])
+  })
+
+  it("refuses a pending hand-off right after idle, before unwinding", async () => {
+    const repo = testRepo({
+      workflow: CONFIG_SCAFFOLD,
+      files: { ".gtd/REVIEW.md": reviewDoc("note"), ".gtd/REVIEW.orig.md": reviewDoc("orig") },
+    })
+    repo.write("TODO.md", "# Add numbers\n")
+    await expect(repo.land()).rejects.toThrow(".gtd/REVIEW.orig.md is a pending hand-off")
+    expect(repo.subjects()).toEqual(["chore: initial commit"])
+  })
+})

package/src/workflows/{bundled.ts → feature/feature.ts}

@@ -7,43 +7,22 @@ import {
   revertScript,
   run,
   start,
-  type Doors,
-  type WorkflowBase,
-  type Summary,
-} from "../flows/index.js"
-import { baseline, gate } from "./health.js"
+} from "../../flows/index.js"
+import { gate } from "../shared/health.js"
+import { shipped } from "../shared/options.js"
+import type { FrozenScenarios } from "../shared/scenarios.js"
+import { FEEDBACK, REVIEW } from "../shared/steps.js"
+import { refusePendingHandOff } from "../shared/tail.js"
+import * as t from "../shared/text.js"
 import { packages } from "./packages.js"
 import { architecture, design } from "./planning.js"
-import type { FrozenScenarios } from "./scenarios.js"
 import { buildTail, type ReviewOutcome } from "./review.js"
-import { ARCHITECTURE, FEEDBACK, REQUIREMENTS, REVIEW } from "./steps.js"
-import { shipped } from "./options.js"
-import * as t from "./text.js"
 
-// gtd's bundled workflows. Any change to the tree starts a process:
-// `idle` → `unwind` reverts the sketch (its intent survives in history) → a
+// The ordinary start. Any change to the tree starts a process: `idle` →
+// `unwind` reverts the sketch (its intent survives in history) → a
 // green-baseline gate → design, architecture and one package per concern →
 // the quality lap → human review, which signs off (the episode ends back at
-// `idle`) or sends a full re-plan lap. `feature` is that ordinary start;
-// `gtd --workflow fix` and `gtd --workflow review --var reviewBase=<commitish>`
-// enter the same build tail further in. Each of the three is a factory over
-// the settings in `./vars.ts`; its flow is exported too, for composing.
-//
-// Every part is exported for other workflows to compose; see the modules
-// re-exported below.
-
-export { threads, type ThreadInfo } from "../flows/index.js"
-export { defaults, envDefaults } from "./vars.js"
-export { ShippedOptions } from "./options.js"
-export { skills } from "./skills.js"
-export { access } from "./access.js"
-export { agentWithSkills } from "./text.js"
-export * from "./steps.js"
-export * from "./health.js"
-export * from "./planning.js"
-export * from "./packages.js"
-export * from "./scenarios.js"
-export * from "./review.js"
+// `idle`) or sends a full re-plan lap.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -97,6 +76,7 @@ export const afterTail = async (outcome: ReviewOutcome): Promise<void> => {
 /** An ordinary start: wait at `idle`, unwind the sketch, check the baseline, then plan and build. */
 export const ordinaryStart = async (): Promise<void> => {
   await human("idle", { message: t.idleMessage(), label: "Idle", file: ".gtd/TODO.md" })
+  refusePendingHandOff()
   await unwind()
   if (changes(FEEDBACK).some((c) => c.status !== "deleted")) {
     await human("unwind-failed", {
@@ -109,36 +89,4 @@ export const ordinaryStart = async (): Promise<void> => {
   await planAndBuild(start())
 }
 
-/** Repair a red baseline through the build tail, as its own reviewed commit. */
-export const fixFlow = async (): Promise<void> => {
-  if (await baseline("fix-precheck")) return
-  return afterTail(await buildTail(true, start()))
-}
-
-/** Pure review of everything since `reviewBase`. */
-export const reviewFlow = async (): Promise<void> => {
-  await gate("review-gate", t.reviewGateBlockedMessage())
-  return afterTail(await buildTail(false, start()))
-}
-
 export const feature = shipped(ordinaryStart)
-export const fix = shipped(fixFlow)
-export const review = shipped(reviewFlow)
-
-export default feature
-
-export const summary: Summary = t.summaryPrompt
-
-export const steering = { [REQUIREMENTS]: "qa", [ARCHITECTURE]: "qa", [REVIEW]: "review" }
-
-export const base: WorkflowBase = (workflow, vars) =>
-  workflow === "review" ? (vars.reviewBase ?? "") : undefined
-
-export const doors: Doors = {
-  fix: { workflow: "fix" },
-  review: {
-    workflow: "review",
-    args: [{ name: "base", optional: true }],
-    vars: ({ base }) => (base === undefined ? {} : { reviewBase: base }),
-  },
-}

package/src/workflows/feature/index.ts

@@ -0,0 +1,10 @@
+import { feature } from "./feature.js"
+
+export * from "./steps.js"
+export * from "./planning.js"
+export * from "./packages.js"
+export { buildTail, type ReviewOutcome } from "./review.js"
+export * from "./feature.js"
+export * from "../shared/reserved.js"
+
+export default feature

package/src/workflows/{packages.test.ts → feature/packages.test.ts}

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, it } from "vitest"
-import { installContext, type Change, type StepRequest } from "../flows/index.js"
+import { installContext, type Change, type StepRequest } from "../../flows/index.js"
 import { declaredTests, packages, SCENARIO_PACKAGE } from "./packages.js"
-import { fixtureContext } from "./text.fixture.js"
+import { fixtureContext } from "../shared/text.fixture.js"
 
 afterEach(() => installContext(undefined))
 

package/src/workflows/{packages.ts → feature/packages.ts}

@@ -8,9 +8,9 @@ import {
   removeScript,
   run,
   scope,
-} from "../flows/index.js"
-import { healthy } from "./health.js"
-import { freezeScenarios, guarded, type FrozenScenarios } from "./scenarios.js"
+} from "../../flows/index.js"
+import { healthy } from "../shared/health.js"
+import { freezeScenarios, guarded, type FrozenScenarios } from "../shared/scenarios.js"
 import { build, fixSuite } from "./steps.js"
 
 /** Package 0: the e2e scenarios, written red. */

package/src/workflows/{planning.ts → feature/planning.ts}

@@ -7,14 +7,13 @@ import {
   requireThreadsClosed,
   requireProgress,
   scope,
-} from "../flows/index.js"
+} from "../../flows/index.js"
+import { ARCHITECTURE, REQUIREMENTS } from "../shared/steps.js"
 import {
   answerProductQuestions,
   answerTechnicalQuestions,
-  ARCHITECTURE,
   author,
   decompose,
-  REQUIREMENTS,
   triage,
 } from "./steps.js"
 

package/src/workflows/{review.test.ts → feature/review.test.ts}

@@ -1,8 +1,13 @@
 import { afterEach, describe, expect, it } from "vitest"
-import { installContext, type Change, type JudgeAnswer, type StepRequest } from "../flows/index.js"
-import { fixQualityFindings, review, type ReviewOutcome } from "./review.js"
-import * as bundled from "./index.js"
-import { fixtureContext } from "./text.fixture.js"
+import {
+  installContext,
+  type Change,
+  type JudgeAnswer,
+  type StepRequest,
+} from "../../flows/index.js"
+import { review, type ReviewOutcome } from "./review.js"
+import * as bundled from "../index.js"
+import { fixtureContext } from "../shared/text.fixture.js"
 
 afterEach(() => installContext(undefined))
 
@@ -378,43 +383,3 @@ describe("scenario wording in review's fix turns", () => {
     expect(log.slice(-2)).toEqual(["fix", "scenario-wording"])
   })
 })
-
-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"])
-  })
-})