@pmelab/gtd 27.3.0 → 27.5.0

package/src/workflows/feature/seam.feature

@@ -0,0 +1,387 @@
+@inmem
+Feature: the naive pass and seam judge replace architecture behind GTD_FLAG_NAIVE_PASS
+
+  With the flag on, after design a naive pass is set aside under a kept ref, the
+  judge reads its diff, and the process either implements straight away, refactors
+  the seam first behind a human approval, or retries the naive pass. With the flag
+  off nothing changes: architecture and packages run as before.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And the gtd config ends with:
+      """
+      export const config = {
+        skills: {
+          implement: ["my-tdd", "my-runbook"],
+        },
+      }
+      """
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    And an environment variable "GTD_FLAG_NAIVE_PASS" set to "1"
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And a file "src/calc.test.ts" with:
+      """
+      import { expect, it } from "vitest"
+      it("adds", () => expect(1 + 1).toBe(2))
+      """
+    And the working tree is committed as "feat: add calculator"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Subtract
+
+      - `subtract(a, b)` returns `a - b`.
+      """
+    And step "design.gate.answer" changes nothing
+
+  Scenario: a land judgment goes straight to the implementation with no seam gate or refactor
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"land","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "implement.building"
+    And the last commit body contains "Gtd-Judge:"
+    And the commit subjects end with:
+      """
+      chore: initial commit
+      feat: add calculator
+      gtd(human): idle → unwind
+      gtd(check): unwind → start-gate.check
+      gtd(check): start-gate.check → design.triage
+      gtd(agent): design.triage → design.gate.answer
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → implement.building
+      """
+
+  Scenario: config skills for the implement scope reach the implement step
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"land","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "implement.building"
+    And the resting step's content contains "my-tdd, my-runbook"
+
+  Scenario: the naive pass lands as a marker commit and its turn stays off the branch
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    When the process is driven
+    Then the process rests at "seam.judge"
+    And the last commit subject is "gtd(agent): seam.naive → seam.judge"
+    And the last commit body contains "Gtd-Kept:"
+    And "src/calc.ts" does not contain "subtract"
+
+  Scenario: the implementation is one build turn, a green check, then the requirements are closed out
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"land","p":0.9}]
+      """
+    And step "implement.building" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      export const SUBTRACT_ENABLED = process.env.GTD_FLAG_SUBTRACT === "1"
+      """
+    And step "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+    When the process is driven
+    Then the process rests at "build.review.reviewing"
+    And the commit subjects end with:
+      """
+      gtd(judge): seam.judge → implement.building
+      gtd(agent): implement.building → implement.health.check
+      gtd(check): implement.health.check → implement.closing
+      gtd(check): implement.closing → build.review.reviewing
+      """
+    And ".gtd/REQUIREMENTS.md" does not exist
+
+  Scenario: a naive pass modifying a test file and adding a new one skips the judge
+    Given step "seam.naive" writes "src/subtract.ts" with:
+      """
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      import { expect, it } from "vitest"
+      it("adds", () => expect(2 + 2).toBe(4))
+      """
+    When the process is driven
+    Then the process rests at "implement.building"
+    And the commit subjects end with:
+      """
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive → implement.building
+      """
+
+  Scenario: a naive pass adding a glob-named file does not hide a modified sibling
+    Given step "seam.naive" writes "src/calc*.ts" with:
+      """
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"reject","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    And the resting step's content contains "src/calc.ts"
+    And the resting step's content does not contain "src/calc*.ts"
+
+  Scenario: a refactor-first judgment rests at the approval gate, then refactors, then implements
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"refactor-first","p":0.9}]
+      """
+    And step "refactor.deriving" writes ".gtd/REFACTOR.md" with:
+      """
+      # Behaviour-neutral refactor
+
+      ## Scope (read-only)
+
+      - `src/calc.ts` # gtd-path-exempt: scenario fixture, not a repo file
+      """
+    And step "refactor.building" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const op = (a: number, b: number, sign: number) => a + sign * b
+      """
+    And step "refactor.health.check" changes nothing
+    And step "refactor.closing" runs its script
+    When the process is driven
+    Then the process rests at "seam.approve"
+    And the resting step's content contains "src/calc.ts"
+    When gtd lands
+    Then the last commit subject is "gtd(human): seam.approve → refactor.deriving"
+    And the last commit body contains "Gtd-Approved:"
+    When the process is driven
+    Then the process rests at "implement.building"
+    And the commit subjects end with:
+      """
+      gtd(judge): seam.judge → seam.approve
+      gtd(human): seam.approve → refactor.deriving
+      gtd(check): refactor.deriving → refactor.building
+      gtd(agent): refactor.building → refactor.health.check
+      gtd(check): refactor.health.check → refactor.closing
+      gtd(check): refactor.closing → implement.building
+      """
+
+  Scenario: three rejects retry the naive pass twice, then rest at the steer gate
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => b + a
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"reject","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    And the resting step's content contains "Overrule"
+    And the resting step's content contains "src/calc.ts"
+    And the commit subjects end with:
+      """
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → seam.steer
+      """
+
+  Scenario: an edit at the steer gate runs the naive pass again with a fresh retry budget
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => b + a
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"reject","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    Given a file ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Subtract
+
+      - `subtract(a, b)` returns `a - b`, in a new module.
+      """
+    When gtd lands
+    Then the process rests at "seam.naive"
+    And the resting step's content does not contain "was rejected"
+    When the process is driven
+    Then the process rests at "seam.steer"
+    And the commit subjects end with:
+      """
+      gtd(human): seam.steer → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → seam.steer
+      """
+
+  Scenario: a clean landing at the steer gate overrules, with no seam gate and no refactor
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => b + a
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"reject","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "seam.steer"
+    When gtd lands
+    Then the process rests at "implement.building"
+    And the commit subjects end with:
+      """
+      gtd(judge): seam.judge → seam.steer
+      gtd(human): seam.steer → implement.building
+      """
+
+  Scenario: review feedback re-runs design and the whole seam phase
+    Given step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => b + a
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"land","p":0.9}]
+      """
+    And step "implement.building" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const SUBTRACT = process.env.GTD_FLAG_SUBTRACT === "1"
+      """
+    And step "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        new add function
+      """
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        new add function[^why]
+
+      [^why]:
+          - H: also export multiply
+      """
+    And step "build.review.collecting" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Concerns
+
+      ### Multiply
+
+      - Export `multiply()`.
+      """
+    And step "build.review.collecting" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        new add function[^why]
+
+      [^why]:
+          - H: also export multiply
+          - A: noted in the requirements.
+      """
+    When gtd lands
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        new add function
+      """
+    And step "build.review.closing" runs its script
+    And step "re-unwind" runs its script
+    When gtd lands
+    And the process is driven
+    Then the process rests at "implement.building"
+    And the commit subjects end with:
+      """
+      gtd(check): re-unwind → design.triage
+      gtd(agent): design.triage → design.gate.answer
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive → seam.judge
+      gtd(judge): seam.judge → implement.building
+      gtd(agent): implement.building
+      """

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

@@ -0,0 +1,88 @@
+import { afterEach, describe, expect, it } from "vitest"
+import {
+  installContext,
+  type Change,
+  type FlowContext,
+  type KeptTip,
+  type StepRequest,
+} from "../../flows/index.js"
+import { globMatches } from "../../wire/index.js"
+import { fixtureContext } from "../shared/text.fixture.js"
+import { judgeSeam, naivePass } from "./seam.js"
+import { captureStep } from "../shared/text.fixture.js"
+
+afterEach(() => installContext(undefined))
+
+const change = (path: string, status: Change["status"]): Change => ({
+  path,
+  status,
+  before: status === "added" ? undefined : "a",
+  after: status === "deleted" ? undefined : "b",
+})
+
+const tip = (...changes: Change[]): KeptTip =>
+  ({
+    hash: "abc",
+    changes: Object.assign([...changes], { paths: [], get: () => undefined }),
+  }) as KeptTip
+
+describe("judgeSeam", () => {
+  const judgeRequests = (kept: KeptTip, vars: Record<string, string> = {}) => {
+    const requests: StepRequest[] = []
+    installContext({
+      ...fixtureContext({ vars }),
+      matches: globMatches,
+      step: async (request: StepRequest) => {
+        requests.push(request)
+        return { answers: { shape: { answer: "land", p: 0.9 } }, truncated: [] }
+      },
+    } as unknown as FlowContext)
+    return judgeSeam(kept).then(() => requests)
+  }
+
+  it.each([
+    ["src/foo*bar.ts", "src/foobar.ts"],
+    ["src/**", "src/deep/foobar.ts"],
+  ])("added %s does not cover modified %s", async (added, sibling) => {
+    const requests = await judgeRequests(tip(change(added, "added"), change(sibling, "modified")))
+    const request = requests[0]
+    if (request?.kind !== "judge") throw new Error("expected a judge step")
+    expect(JSON.parse(request.evidence.strays as string)).toEqual([sibling])
+    expect(JSON.parse(request.evidence.inAllowlist as string)).toContain(added)
+  })
+
+  it("splits seamAllow on commas, trims entries and drops blanks", async () => {
+    const requests = await judgeRequests(tip(change("src/x.ts", "modified")), {
+      seamAllow: " a/** , ,b.ts,, ",
+    })
+    const request = requests[0]
+    if (request?.kind !== "judge") throw new Error("expected a judge step")
+    expect(JSON.parse(request.evidence.allow as string)).toEqual(["a/**", "b.ts"])
+  })
+
+  it("exempts only added paths: a deleted path stays a stray", async () => {
+    const requests = await judgeRequests(tip(change("src/gone.ts", "deleted")))
+    const request = requests[0]
+    if (request?.kind !== "judge") throw new Error("expected a judge step")
+    expect(JSON.parse(request.evidence.strays as string)).toEqual(["src/gone.ts"])
+  })
+})
+
+describe("naivePass", () => {
+  const capture = (rejection?: { strays: string[]; p: number }) =>
+    captureStep(() => naivePass(rejection), { scope: "seam" })
+
+  it("keeps its turn under the step name seam.naive", async () => {
+    const request = await capture()
+    if (request.kind !== "agent") throw new Error("unreachable")
+    expect(request.name).toBe("naive")
+    expect(request.options).toMatchObject({ keep: true })
+  })
+
+  it("carries the rejection into the retry prompt", async () => {
+    const request = await capture({ strays: ["src/core.ts"], p: 0.8 })
+    if (request.kind !== "agent") throw new Error("unreachable")
+    expect(request.prompt).toContain("src/core.ts")
+    expect(request.prompt).toContain("0.8")
+  })
+})

package/src/workflows/feature/seam.ts

@@ -0,0 +1,110 @@
+import {
+  changes,
+  human,
+  judgeDiffShape,
+  kept,
+  removeScript,
+  run,
+  scope,
+  seamGate,
+  vars,
+  type DiffShapeResult,
+  type KeptTip,
+} from "../../flows/index.js"
+import { healthy } from "../shared/health.js"
+import { coder, FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
+import * as t from "../shared/text.js"
+import { defaults } from "../shared/vars.js"
+import { refactorFirst } from "./refactor.js"
+
+/** Naive-pass retries after a `reject`; the next `reject` rests at `seam.steer`. */
+const NAIVE_RETRIES = 2
+
+/** A change to an existing file outside the allowlist is a stray even when the task needs it: the judge decides. */
+export const judgeSeam = (tip: KeptTip): Promise<DiffShapeResult> =>
+  judgeDiffShape("judge", {
+    changes: tip.changes,
+    allow: (vars.seamAllow ?? defaults.seamAllow!)
+      .split(",")
+      .map((glob) => glob.trim())
+      .filter((glob) => glob !== ""),
+    exempt: tip.changes.filter((c) => c.status === "added").map((c) => c.path),
+  })
+
+export const naivePass = (rejection?: t.SeamRejection): Promise<void> =>
+  t.agentWithSkills("naive", t.naivePassPrompt(rejection), {
+    label: rejection === undefined ? "Writing the naive pass" : "Rewriting the naive pass",
+    keep: true,
+    model: coder(),
+    system: t.builderSystem(),
+  })
+
+export const implement = (reference: string): Promise<void> =>
+  scope("implement", async () => {
+    await t.agentWithSkills("building", t.implementBuildingPrompt(reference), {
+      label: "Implementing",
+      model: coder(),
+      system: t.builderSystem(),
+    })
+    await healthy(() =>
+      t.agentWithSkills("fix.suite.fixing", t.implementFixPrompt(), {
+        label: "Fixing the check",
+        file: FEEDBACK,
+        model: coder(),
+        system: t.builderSystem(),
+      }),
+    )
+    await run("closing", removeScript([REQUIREMENTS]), { label: "Closing out the implementation" })
+  })
+
+interface Decision {
+  readonly reference: string
+  /** Present only on `refactor-first`: the refactor runs before the implementation. */
+  readonly shape?: DiffShapeResult
+}
+
+const decide = (): Promise<Decision> =>
+  scope("seam", async () => {
+    let rejection: t.SeamRejection | undefined
+    let retries = 0
+    for (;;) {
+      await naivePass(rejection)
+      const tip = kept("naive")!
+      const shape = await judgeSeam(tip)
+      if (shape.choice === "land") return { reference: tip.hash }
+      if (shape.choice === "refactor-first") {
+        await seamGate("approve", shape)
+        return { reference: tip.hash, shape }
+      }
+      rejection = { strays: shape.strays, p: shape.judgment?.answers.shape?.p ?? 0 }
+      if (retries < NAIVE_RETRIES) {
+        retries++
+        continue
+      }
+      await human("steer", {
+        message: t.seamSteerMessage(rejection),
+        label: "Steer or overrule the rejected naive pass",
+        file: REQUIREMENTS,
+        acceptClean: true,
+      })
+      // Any edit steers, with a fresh budget and no stale rejection; clean overrules.
+      if (changes().length === 0) return { reference: tip.hash }
+      rejection = undefined
+      retries = 0
+    }
+  })
+
+export const seamBuild = async (): Promise<void> => {
+  const { reference, shape } = await decide()
+  if (shape !== undefined && !(await refactorFirst(shape, { reference }))) {
+    // Unreadable strays were never judged, and no refactor runs: a person reads the diff.
+    await scope("seam", () =>
+      human("by-hand", {
+        message: t.seamByHandMessage(shape.strays, shape.unreadable, reference),
+        label: "Reviewing unreadable files by hand",
+        acceptClean: true,
+      }),
+    )
+  }
+  await implement(reference)
+}

package/src/workflows/index.ts

@@ -23,6 +23,7 @@ export * from "./feature/steps.js"
 export * from "./feature/planning.js"
 export * from "./feature/packages.js"
 export * from "./feature/refactor.js"
+export * from "./feature/seam.js"
 export { buildTail, type ReviewOutcome } from "./feature/review.js"
 export * from "./feature/feature.js"
 export { base, review, reviewFlow } from "./review/review.js"

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

@@ -9,10 +9,21 @@ const { flagShipped } = options
 describe("the shipped workflow factories", () => {
   it("take exactly the settings the shipped workflows declare as options", () => {
     expect(Object.keys(ShippedOptions.fields).sort()).toEqual(
-      [...Object.keys(defaults), ...Object.keys(envDefaults)].sort(),
+      [...Object.keys(defaults), ...Object.keys(envDefaults)]
+        .filter((name) => name !== "flag_naive_pass")
+        .sort(),
     )
   })
 
+  it("declare seamAllow and flag_naive_pass defaults; flag_naive_pass is no option", () => {
+    expect(defaults.flag_naive_pass).toBe("0")
+    expect(Object.keys(ShippedOptions.fields)).not.toContain("flag_naive_pass")
+    expect(configure(feature({ seamAllow: "docs/**" }))).toMatchObject({
+      ok: true,
+      build: { defaults: { seamAllow: "docs/**", flag_naive_pass: "0" } },
+    })
+  })
+
   it("lay each option over the shipped setting of its own kind", () => {
     const result = configure(feature({ qualityReviews: "correctness", testCommand: "npm run ci" }))
     expect(result).toMatchObject({

package/src/workflows/shared/options.ts

@@ -17,6 +17,7 @@ export const ShippedOptions = Schema.Struct({
   reviewNoteActionable: setting,
   reviewSeverityMinP: setting,
   refactorFlagPattern: setting,
+  seamAllow: setting,
   qualityReviews: setting,
   testCommand: setting,
   plannerModel: setting,

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

@@ -29,6 +29,10 @@ describe("the bundled workflow's skills export", () => {
         "refactor",
         "refactor.fix.suite",
         "refactor.health",
+        "seam",
+        "implement",
+        "implement.fix.suite",
+        "implement.health",
         "build.quality.correctness",
         "build.quality.owasp-security",
         "build.quality.ponytail-review",
@@ -39,8 +43,18 @@ describe("the bundled workflow's skills export", () => {
     )
   })
 
-  it("keys no group scope", () => {
-    for (const group of ["packages.item.fix", "build.fix", "build.review.fix", "build.quality"]) {
+  it("keys no group scope or non-agent step", () => {
+    for (const group of [
+      "packages.item.fix",
+      "build.fix",
+      "build.review.fix",
+      "build.quality",
+      "implement.fix",
+      "seam.judge",
+      "seam.approve",
+      "seam.steer",
+      "seam.by-hand",
+    ]) {
       expect(bundled).not.toHaveProperty(group)
     }
   })
@@ -63,6 +77,10 @@ describe("the bundled workflow's skills export", () => {
       refactor: ["ponytail"],
       "refactor.fix.suite": ["ponytail", "debugging-and-error-recovery"],
       "refactor.health": ["ponytail", "debugging-and-error-recovery"],
+      seam: ["incremental-implementation"],
+      implement: ["test-driven-development", "incremental-implementation"],
+      "implement.fix.suite": ["debugging-and-error-recovery"],
+      "implement.health": ["debugging-and-error-recovery"],
     })
   })
 

package/src/workflows/shared/skills.ts

@@ -29,6 +29,12 @@ export const skills = (
   refactor: ["ponytail"],
   "refactor.fix.suite": ["ponytail", "debugging-and-error-recovery"],
   "refactor.health": ["ponytail", "debugging-and-error-recovery"],
+  // Declared whether or not `naive_pass` is on, so a config keyed on them keeps
+  // loading when the flag flips off.
+  seam: ["incremental-implementation"],
+  implement: ["test-driven-development", "incremental-implementation"],
+  "implement.fix.suite": ["debugging-and-error-recovery"],
+  "implement.health": ["debugging-and-error-recovery"],
   ...lensScopes(
     "build.quality",
     lensesOf(vars.qualityReviews ?? ""),