@pmelab/gtd 15.10.0 → 17.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "15.10.0",
+  "version": "17.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/schema.json

@@ -5,7 +5,7 @@
   "properties": {
     "vars": {
       "type": "object",
-      "description": "Flat name -> scalar map merged into the workflow's vars. Scalars are coerced to strings.",
+      "description": "Flat name -> scalar map merged into the workflow's process settings (defaults), pinned for the whole process at its start. Scalars are coerced to strings.",
       "additionalProperties": {
         "type": [
           "string",
@@ -14,6 +14,38 @@
         ]
       }
     },
+    "env": {
+      "type": "object",
+      "description": "Flat name -> scalar map merged into the workflow's environment settings (envDefaults) — values that change how a step runs on this machine, like the test command or a model hint. Read fresh on every gtd call, never pinned to a process. GTD_<NAME> environment variables override these entries. Scalars are coerced to strings.",
+      "additionalProperties": {
+        "type": [
+          "string",
+          "number",
+          "boolean"
+        ]
+      }
+    },
+    "judge": {
+      "type": "object",
+      "required": [],
+      "properties": {
+        "provider": {
+          "type": "string",
+          "enum": [
+            "fixed",
+            "jev",
+            "llm"
+          ],
+          "description": "Judge provider `gtd judge run` uses when no --provider flag and no GTD_JUDGE_PROVIDER is set. Absent means auto: jev when TYPESAFE_API_KEY is set, otherwise llm."
+        },
+        "model": {
+          "type": "string",
+          "description": "Model for provider llm, used when no --model flag and no GTD_JUDGE_MODEL is set. Pairing it with another provider is an error."
+        }
+      },
+      "additionalProperties": false,
+      "description": "Which judge `gtd judge run` uses, when no flag or GTD_JUDGE_* variable says."
+    },
     "modes": {
       "type": "object",
       "description": "Steering-file modes a workflow step's mode: may name. Each entry declares at least one of format/validate: shell commands gtd runs via bash with $GTD_FILE set to the steering file's path. format rewrites the file in place; validate exits 0 when valid, non-zero with findings on stdout/stderr otherwise. The halves layer independently, so naming a built-in mode (qa/review) and declaring only format: adds formatting while keeping gtd's own validation. gtd ships no formatter — bring your own (prettier, dprint, a script).",
@@ -63,6 +95,16 @@
       "additionalProperties": false,
       "description": "Settings for `gtd ui`: where it listens, and optional TLS."
     },
+    "skills": {
+      "type": "object",
+      "description": "Flat step full-name -> skill-name array map. Each entry REPLACES the named step's bundled skill list wholesale (never merges into it); [] means no skills at all for that step, and no preamble. A key naming a step the workflow in play does not declare is a load error listing the known names — the schema itself cannot validate a key, only a value's shape.",
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
     "$schema": {
       "type": "string",
       "description": "Editor-only pointer at this schema. Stripped by gtd before validation."

package/src/flows/runtime.ts

@@ -136,8 +136,18 @@ export interface FlowContext {
   readonly threads: (text: string) => readonly ThreadInfo[]
   readonly codeThreads: () => readonly CodeThreadInfo[]
   readonly vars: Readonly<Record<string, string>>
+  readonly env: Readonly<Record<string, string>>
   readonly head: () => string
   readonly start: () => string
+  /**
+   * The skill list `localName` (scoped from here, same as `agent()`) resolves
+   * to — for a prompt preamble. `ownSkills`, when given, is the same
+   * precedence tier as a call's own `skills` option: it stands in for the
+   * bundled default when there isn't one, but a `.gtdrc` entry still beats
+   * it. Shares its resolution with `agent()`'s own wire resolver (both read
+   * `Workflow.ts`'s `configuredSkills`/`skills`), so the two can never drift.
+   */
+  readonly skillsFor: (localName: string, ownSkills?: readonly string[]) => readonly string[]
 }
 
 const CONTEXT_KEY = Symbol.for("@pmelab/gtd/flow-context")
@@ -243,19 +253,35 @@ export const head = (): string => ctx().head()
 /** The process's diff base: the commit before it began, or the base `gtd --entry` fixed. */
 export const start = (): string => ctx().start()
 
-/** The merged workflow variables. */
-export const vars: Readonly<Record<string, string>> = new Proxy(
-  {},
-  {
-    get: (_target, key) => (typeof key === "string" ? ctx().vars[key] : undefined),
-    has: (_target, key) => typeof key === "string" && key in ctx().vars,
-    ownKeys: () => Object.keys(ctx().vars),
-    getOwnPropertyDescriptor: (_target, key) =>
-      typeof key === "string" && key in ctx().vars
-        ? { enumerable: true, configurable: true, value: ctx().vars[key] }
-        : undefined,
-  },
-)
+/** The skill list `localName` (scoped from here, same as `agent()`) resolves to — for a prompt preamble. See `FlowContext.skillsFor` for `ownSkills`. */
+export const skillsFor = (localName: string, ownSkills?: readonly string[]): readonly string[] =>
+  ctx().skillsFor(localName, ownSkills)
+
+const settingsProxy = (
+  read: () => Readonly<Record<string, string>>,
+): Readonly<Record<string, string>> =>
+  new Proxy(
+    {},
+    {
+      get: (_target, key) => (typeof key === "string" ? read()[key] : undefined),
+      has: (_target, key) => typeof key === "string" && key in read(),
+      ownKeys: () => Object.keys(read()),
+      getOwnPropertyDescriptor: (_target, key) =>
+        typeof key === "string" && key in read()
+          ? { enumerable: true, configurable: true, value: read()[key] }
+          : undefined,
+    },
+  )
+
+/** The process settings: pinned at process start, so flow code may branch on them. */
+export const vars: Readonly<Record<string, string>> = settingsProxy(() => ctx().vars)
+
+/**
+ * The environment settings: resolved live on every invocation. Flow code must
+ * read them only where they cannot change the next step (step options, script
+ * bodies) — replay cannot enforce this.
+ */
+export const env: Readonly<Record<string, string>> = settingsProxy(() => ctx().env)
 
 // ── Text utilities ──────────────────────────────────────────────────────────
 
@@ -330,6 +356,7 @@ export interface SummaryContext {
   readonly processCost: number
   readonly processCostByModel: readonly { readonly model: string; readonly cost: number }[]
   readonly vars: Readonly<Record<string, string>>
+  readonly env: Readonly<Record<string, string>>
 }
 
 /** `gtd summary`'s prompt — a workflow module's optional `summary` export. */

package/src/workflows/health.ts

@@ -1,6 +1,7 @@
 import {
   answered,
   check,
+  env,
   human,
   judge,
   numeric,
@@ -17,7 +18,7 @@ export const FIX_CAP = 3
 
 /** 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> =>
-  check(name, vars.testCommand ?? "", { report: FEEDBACK, label })
+  check(name, env.testCommand ?? "", { report: FEEDBACK, label })
 
 /** How many escalation rounds a run of red checks has spent — reset once the suite goes green. */
 export interface EscalationCount {
@@ -95,7 +96,7 @@ export const healthy = async (
   let fixes = options.fixesSoFar ?? 0
   let previous: string | undefined
   for (;;) {
-    const green = await check("health.check", vars.testCommand ?? "", {
+    const green = await check("health.check", env.testCommand ?? "", {
       report: FEEDBACK,
       label: "Running checks",
       // Swept only on green: an unresolved analysis survives every retry.

package/src/workflows/review.ts

@@ -35,8 +35,12 @@ import {
 } from "./steps.js"
 import * as t from "./text.js"
 
-/** The skills the quality lap reviews with, one turn each: the `qualityReviews` var. */
-export const qualityLenses = (): readonly string[] => t.splitSkills(vars.qualityReviews)
+/** The lenses the quality lap reviews with, one turn each: the `qualityReviews` var, split on `,` and trimmed. Unlike a `skills:` entry, this fans out into one whole turn per entry rather than naming one step's skill list — see `build.quality.reviewing` in `./skills.ts` for the (separate) skills a lens turn itself loads. */
+export const qualityLenses = (): readonly string[] =>
+  (vars.qualityReviews ?? "")
+    .split(",")
+    .map((lens) => lens.trim())
+    .filter((lens) => lens.length > 0)
 
 /**
  * One review turn per lens over the whole change, each appending what it

package/src/workflows/skills.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest"
+import { skills } from "./skills.js"
+
+// Pins every bundled step's own declared list, keyed by its full name. This
+// file alone only catches a LOCAL-name rename (the list literally changes);
+// it cannot catch a SCOPE rename (e.g. `scope("architecture")` renamed to
+// `scope("design.architecture")`), because it never runs the real flow — it
+// compares the map against itself. Every one of the sixteen keys has its
+// own e2e grounding closing that gap instead — each runs the actual scoped
+// name through replay, so a scope rename desyncs a preamble assertion there,
+// not just silently drops a step's skills (see AGENTS.md's "workflow is
+// code" rule: a step's full name is public API):
+//   - design.triage, architecture.author, architecture.decompose,
+//     packages.item.building — default-workflow.feature's main scenario
+//   - packages.item.spec.review, packages.item.fix-spec — the same
+//     scenario, continued
+//   - packages.item.fix-suite, packages.item.health.describe — the
+//     "escalation loop ... under packages.item" scenario
+//   - build.fix — state-skills.feature
+//   - build.health.describe — the "repeated check failures escalate"
+//     scenario
+//   - build.quality.reviewing — per-step-skills.feature
+//   - build.fix-quality — quality-review-lap.feature
+//   - build.review.reviewing, build.review.collecting —
+//     default-workflow.feature's review-loop scenarios
+//   - build.review.answer-review-questions, build.review.fix-nits — NOT yet
+//     e2e-grounded; only steps.test.ts's preamble checks, which use local names
+describe("the bundled workflow's skills map", () => {
+  it("declares exactly the sixteen bundled agent steps, by full name", () => {
+    expect(Object.keys(skills).sort()).toEqual(
+      [
+        "design.triage",
+        "architecture.author",
+        "architecture.decompose",
+        "packages.item.building",
+        "packages.item.fix-suite",
+        "packages.item.fix-spec",
+        "packages.item.spec.review",
+        "packages.item.health.describe",
+        "build.fix",
+        "build.health.describe",
+        "build.quality.reviewing",
+        "build.fix-quality",
+        "build.review.reviewing",
+        "build.review.answer-review-questions",
+        "build.review.fix-nits",
+        "build.review.collecting",
+      ].sort(),
+    )
+  })
+
+  it("packages.item.health.describe and build.health.describe are both present, with the same list — the shared escalation loop resolves under both scopes", () => {
+    expect(skills["packages.item.health.describe"]).toEqual(skills["build.health.describe"])
+    expect(skills["packages.item.health.describe"]).toEqual(["debugging-and-error-recovery"])
+  })
+
+  it("pins each step's own declared list", () => {
+    expect(skills["design.triage"]).toEqual([
+      "spec-driven-development",
+      "planning-and-task-breakdown",
+    ])
+    expect(skills["architecture.author"]).toEqual([
+      "api-and-interface-design",
+      "documentation-and-adrs",
+      "ponytail",
+    ])
+    expect(skills["architecture.decompose"]).toEqual([
+      "incremental-implementation",
+      "planning-and-task-breakdown",
+    ])
+    expect(skills["packages.item.building"]).toEqual([
+      "test-driven-development",
+      "incremental-implementation",
+    ])
+    expect(skills["packages.item.fix-suite"]).toEqual(["debugging-and-error-recovery"])
+    expect(skills["build.fix"]).toEqual(["debugging-and-error-recovery"])
+    expect(skills["packages.item.fix-spec"]).toEqual([
+      "incremental-implementation",
+      "code-simplification",
+    ])
+    expect(skills["build.fix-quality"]).toEqual([
+      "incremental-implementation",
+      "code-simplification",
+    ])
+    expect(skills["packages.item.spec.review"]).toEqual([
+      "code-review-and-quality",
+      "spec-driven-development",
+    ])
+    expect(skills["build.review.reviewing"]).toEqual(["code-review-and-quality"])
+    expect(skills["build.review.collecting"]).toEqual(["code-review-and-quality"])
+    expect(skills["build.quality.reviewing"]).toEqual([])
+  })
+})

package/src/workflows/skills.ts

@@ -0,0 +1,37 @@
+// The bundled workflow's default skills, one list per agent step, keyed by
+// the step's FULL name (its scope prefixes included) — the same name a
+// `.gtdrc` `skills:` entry addresses. A step's name is not derivable from
+// flow code alone (loops, branches, shared calls), so this map is the only
+// place every addressable name is declared up front; `steps.test.ts` pins
+// each step's declared list against a renamed map key.
+//
+// `packages.item.health.describe` and `build.health.describe` are not a
+// duplicate: the escalation loop (`healthy()`, in `./health.ts`) is shared
+// code reached from both `scope("packages") -> scope("item")` and
+// `scope("build")`, so the one `health.describe` step name resolves to two
+// different full names depending on which caller is looping.
+export const skills: Readonly<Record<string, readonly string[]>> = {
+  "design.triage": ["spec-driven-development", "planning-and-task-breakdown"],
+  "architecture.author": ["api-and-interface-design", "documentation-and-adrs", "ponytail"],
+  "architecture.decompose": ["incremental-implementation", "planning-and-task-breakdown"],
+  "packages.item.building": ["test-driven-development", "incremental-implementation"],
+  "packages.item.fix-suite": ["debugging-and-error-recovery"],
+  "packages.item.fix-spec": ["incremental-implementation", "code-simplification"],
+  "packages.item.spec.review": ["code-review-and-quality", "spec-driven-development"],
+  "packages.item.health.describe": ["debugging-and-error-recovery"],
+  "build.fix": ["debugging-and-error-recovery"],
+  "build.health.describe": ["debugging-and-error-recovery"],
+  // No bundled default: unlike every other entry, the lens named in the
+  // prompt BODY already varies per turn (see `reviewQuality` in
+  // `./steps.ts`), which is what the preamble falls back to naming instead —
+  // a fixed bundled list here would repeat one entry on every turn. A
+  // `.gtdrc` `skills:` entry still overrides that per-turn fallback, on the
+  // wire and in the preamble alike (`resolveSkills` in `../replay/Replay.ts`
+  // is what both share).
+  "build.quality.reviewing": [],
+  "build.fix-quality": ["incremental-implementation", "code-simplification"],
+  "build.review.reviewing": ["code-review-and-quality"],
+  "build.review.answer-review-questions": ["code-review-and-quality"],
+  "build.review.fix-nits": ["incremental-implementation", "code-simplification"],
+  "build.review.collecting": ["code-review-and-quality"],
+}

package/src/workflows/steps.test.ts

@@ -5,107 +5,114 @@ import * as steps from "./steps.js"
 
 const capture = (
   fn: () => Promise<void>,
-  vars: Readonly<Record<string, string>> = {},
-): Promise<StepRequest> => captureStep(fn, { vars })
+  skills?: Readonly<Record<string, readonly string[]>>,
+): Promise<StepRequest> => captureStep(fn, skills !== undefined ? { skills } : {})
 
-const agentSkills = (request: StepRequest): readonly string[] | undefined => {
+const agentPrompt = (request: StepRequest): string => {
+  if (request.kind !== "agent") throw new Error(`expected an agent step, got ${request.kind}`)
+  return request.prompt
+}
+
+// The preamble (`agentPrompt`) reflects `skillsFor`'s resolved map — but the
+// WIRE `skills` field a request actually carries is whatever `options.skills`
+// the step itself passed; `Replay.ts`'s `resolve()` only overrides it from
+// `.gtdrc` (never reachable here — this fixture skips replay entirely). Most
+// bundled steps pass no `skills` option of their own, so this is normally
+// `undefined`; `reviewQuality` is the one step that does.
+const agentSkillsOption = (request: StepRequest): readonly string[] | undefined => {
   if (request.kind !== "agent") throw new Error(`expected an agent step, got ${request.kind}`)
   return request.options.skills
 }
 
-describe("the bundled workflow's steps declare skills", () => {
-  it("triage declares triageSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.triage("base")))).toEqual([
-      "spec-driven-development",
-      "planning-and-task-breakdown",
-    ])
+describe("the bundled workflow's steps declare skills — a bundled step's rendered prompt carries its bundled skills.ts preamble", () => {
+  it("triage carries design.triage's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.triage("base")))
+    expect(prompt).toContain("spec-driven-development, planning-and-task-breakdown")
+  })
+
+  it("author carries architecture.author's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.author()))
+    expect(prompt).toContain("api-and-interface-design, documentation-and-adrs, ponytail")
+  })
+
+  it("decompose carries architecture.decompose's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.decompose()))
+    expect(prompt).toContain("incremental-implementation, planning-and-task-breakdown")
   })
 
-  it("author declares architectureSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.author()))).toEqual([
-      "api-and-interface-design",
-      "documentation-and-adrs",
-      "ponytail",
-    ])
+  it("build carries packages.item.building's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.build("pkg")))
+    expect(prompt).toContain("test-driven-development, incremental-implementation")
   })
 
-  it("decompose declares decomposeSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.decompose()))).toEqual([
-      "incremental-implementation",
-      "planning-and-task-breakdown",
-    ])
+  it("fixSuite carries packages.item.fix-suite's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.fixSuite()))
+    expect(prompt).toContain("debugging-and-error-recovery")
   })
 
-  it("build declares buildSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.build("pkg")))).toEqual([
-      "test-driven-development",
-      "incremental-implementation",
-    ])
+  it("fixSpec carries packages.item.fix-spec's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.fixSpec("pkg")))
+    expect(prompt).toContain("incremental-implementation, code-simplification")
   })
 
-  it("fixSuite declares fixSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.fixSuite()))).toEqual([
-      "debugging-and-error-recovery",
-    ])
+  it("reviewPackage carries packages.item.spec.review's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.reviewPackage("pkg")))
+    expect(prompt).toContain("code-review-and-quality, spec-driven-development")
   })
 
-  it("fixSpec declares reviewFixSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.fixSpec("pkg")))).toEqual([
-      "incremental-implementation",
-      "code-simplification",
-    ])
+  it("fix carries build.fix's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.fix()))
+    expect(prompt).toContain("debugging-and-error-recovery")
   })
 
-  it("reviewPackage declares specReviewSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.reviewPackage("pkg")))).toEqual([
-      "code-review-and-quality",
-      "spec-driven-development",
-    ])
+  it("describeEscalation carries health.describe's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.describeEscalation()))
+    expect(prompt).toContain("debugging-and-error-recovery")
   })
 
-  it("fix declares fixSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.fix()))).toEqual(["debugging-and-error-recovery"])
+  it("reviewQuality's preamble falls back to the lens itself by default — build.quality.reviewing bundles no fixed skills of its own", async () => {
+    const prompt = agentPrompt(await capture(() => steps.reviewQuality("owasp-security")))
+    expect(prompt).toContain("missing one: owasp-security")
   })
 
-  it("describeEscalation declares escalateSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.describeEscalation()))).toEqual([
-      "debugging-and-error-recovery",
-    ])
+  it("reviewQuality's own wire skills option IS the lens by default — the same list its preamble now names, never one without the other", async () => {
+    const request = await capture(() => steps.reviewQuality("owasp-security"))
+    expect(agentSkillsOption(request)).toEqual(["owasp-security"])
   })
 
-  it("reviewQuality declares exactly the one lens handed to it, not split further", async () => {
-    expect(agentSkills(await capture(() => steps.reviewQuality("owasp-security")))).toEqual([
-      "owasp-security",
-    ])
+  it("reviewQuality's preamble reflects a configured build.quality.reviewing entry, every turn, regardless of lens", async () => {
+    const prompt = agentPrompt(
+      await capture(() => steps.reviewQuality("owasp-security"), {
+        "quality.reviewing": ["my-org-checklist"],
+      }),
+    )
+    expect(prompt).toContain("my-org-checklist")
+    // The body still names the lens — what makes N otherwise identical prompts distinguishable.
+    expect(prompt).toContain("owasp-security")
   })
 
-  it("fixQuality declares reviewFixSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.fixQuality()))).toEqual([
-      "incremental-implementation",
-      "code-simplification",
-    ])
+  it("fixQuality carries build.fix-quality's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.fixQuality()))
+    expect(prompt).toContain("incremental-implementation, code-simplification")
   })
 
-  it("reviewing declares reviewSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.reviewing("base")))).toEqual([
-      "code-review-and-quality",
-    ])
+  it("reviewing carries build.review.reviewing's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.reviewing("base")))
+    expect(prompt).toContain("code-review-and-quality")
   })
 
-  it("collecting declares reviewSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.collecting("capture")))).toEqual([
-      "code-review-and-quality",
-    ])
+  it("collecting carries build.review.collecting's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.collecting("capture")))
+    expect(prompt).toContain("code-review-and-quality")
   })
 
-  it("a blanked *Skills var leaves that step's skills empty, and its rendered prompt bare", async () => {
-    const request = await capture(() => steps.fix(), { fixSkills: "" })
+  it("an empty configured list leaves that step's skills empty, and its rendered prompt bare", async () => {
+    const request = await capture(() => steps.fix(), { fix: [] })
     if (request.kind !== "agent") throw new Error("unreachable")
-    expect(request.options.skills).toEqual([])
     expect(request.prompt).not.toContain("Load whatever's listed here")
   })
 
-  it("answerReviewQuestions answers inline in .gtd/REVIEW.md as the reviewer, with reviewSkills", async () => {
+  it("answerReviewQuestions answers inline in .gtd/REVIEW.md as the reviewer, with its bundled skills", async () => {
     const request = await capture(() =>
       steps.answerReviewQuestions([{ id: "note-1", anchor: "calc ./a.ts#1-1", text: "why?" }]),
     )
@@ -114,8 +121,8 @@ describe("the bundled workflow's steps declare skills", () => {
     expect(request.options).toMatchObject({
       file: ".gtd/REVIEW.md",
       mode: "review",
-      skills: ["code-review-and-quality"],
     })
+    expect(request.prompt).toContain("code-review-and-quality")
     expect(request.prompt).toContain("note-1 — calc ./a.ts#1-1")
     expect(request.prompt).toContain("`A: ` line")
     expect(request.prompt).toContain("gtd check review .gtd/REVIEW.md")
@@ -130,7 +137,7 @@ describe("the bundled workflow's steps declare skills", () => {
     )
     if (request.kind !== "agent") throw new Error("unreachable")
     expect(request.name).toBe("review.fix-nits")
-    expect(request.options.skills).toEqual(["incremental-implementation", "code-simplification"])
+    expect(request.prompt).toContain("incremental-implementation, code-simplification")
     expect(request.prompt).toContain("typo")
     expect(request.prompt).toContain("semicolon")
     expect(request.prompt).toContain("Leave `.gtd/REVIEW.md` untouched")