@pmelab/gtd 58.2.0 → 59.0.0

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

@@ -1,338 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { runsItsScript, testRepo } from "../../testkit/index.js"
-import { CONFIG_SCAFFOLD } from "../../install/index.js"
-import { reviewDoc } from "../shared/config.fixture.js"
-import type * as featureEntry from "./index.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"])
-  })
-})
-
-const review = (text?: string): string =>
-  [
-    "# Review: abc1234",
-    "",
-    "<!-- base: 0000000 -->",
-    "",
-    "## calc",
-    "",
-    "- [ ] ./src/calc.ts#1-1",
-    text === undefined ? "  add" : "  add[^why]",
-    ...(text === undefined ? [] : ["", "[^why]:", `    - H: ${text}`]),
-    "",
-  ].join("\n")
-
-const CALC = "export const add = (a: number, b: number) => a + b\n"
-
-const ACCEPTANCE = 'it("[AC-1] done", () => {})\n'
-
-const naivePlanned = () => {
-  const repo = testRepo({
-    workflow: CONFIG_SCAFFOLD,
-    env: {
-      GTD_QUALITYREVIEWS: "",
-      GTD_REFACTORQUALITYREVIEWS: "",
-      GTD_FLAG_RISK_TIER: "0",
-    },
-  })
-  repo.write("src/calc.ts", CALC)
-  repo.commit("feat: add calculator")
-  repo.write("TODO.md", "# Add subtract\n")
-  return repo
-}
-
-describe("afterTail feedback lap", () => {
-  const TAIL = [
-    `import { start } from "@pmelab/gtd/flows"`,
-    `import { afterTail, buildTail, gate } from "@pmelab/gtd/workflows"`,
-    `export { feature as default, defaults, envDefaults, summary, base, steering, skills, access } from "@pmelab/gtd/workflows"`,
-    `export async function tail() {`,
-    `  await gate("review-gate", "The baseline is red.")`,
-    `  return afterTail(await buildTail(start()))`,
-    `}`,
-  ].join("\n")
-
-  const feedbackLap = async () => {
-    const repo = testRepo({
-      workflow: TAIL,
-      env: {
-        GTD_QUALITYREVIEWS: "",
-        GTD_REFACTORQUALITYREVIEWS: "",
-        GTD_FLAG_RISK_TIER: "0",
-      },
-    })
-    repo.write("src/calc.ts", CALC)
-    repo.commit("feat: add calculator")
-    await repo.start("tail", "--var", `reviewBase=${repo.hashes()[0]}`)
-    await repo.drive({
-      "review-gate.check": () => undefined,
-      "build.health.check": () => undefined,
-      "build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", review()),
-    })
-    repo.write(".gtd/REVIEW.md", review("also export multiply"))
-    await repo.land()
-    await repo.drive({
-      "build.review.collecting": (_, r) => {
-        r.write(
-          ".gtd/REQUIREMENTS.md",
-          "# Requirements\n\n- multiply\n\n## Impact\n\n- the module\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-        )
-        r.write(".gtd/REVIEW.md", `${review("also export multiply")}    - A: noted.\n`)
-      },
-    })
-    repo.write(".gtd/REVIEW.md", review())
-    await repo.land()
-    return repo
-  }
-
-  const afterFeedback = {
-    "build.review.closing": runsItsScript,
-    "re-unwind": runsItsScript,
-    "design.triage": (_: unknown, r: ReturnType<typeof testRepo>) =>
-      r.write(
-        ".gtd/REQUIREMENTS.md",
-        "# Requirements\n\n- multiply, designed\n\n## Impact\n\n- the module\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-      ),
-    "design.gate.answer": () => undefined,
-  }
-
-  it("rests at design.triage, then implement.building, reaching no seam step", async () => {
-    const repo = await feedbackLap()
-    expect(
-      (await repo.drive({ "build.review.closing": runsItsScript, "re-unwind": runsItsScript }))
-        .state,
-    ).toBe("design.triage")
-    const rest = await repo.drive(afterFeedback)
-    expect(rest.state).toBe("implement.building")
-    expect(rest.content).toContain("already exists")
-    expect(rest.content).not.toContain("write the change fresh")
-    expect(repo.subjects().some((subject) => subject.includes("seam."))).toBe(false)
-  })
-})
-
-describe("an in-flight 28.0.0 naive-pass process", () => {
-  type Edge = readonly [actor: string, from: string, to: string, trailer?: string]
-  const verdict = (answer: string) => `Gtd-Judge: {"id":"shape","answer":"${answer}","p":0.9}`
-  const approved = 'Gtd-Approved: {"step":"seam.approve#1","name":"Test","email":"test@test.com"}'
-  const building: readonly Edge[] = [
-    ["agent", "implement.building", "implement.health.check"],
-    ["check", "implement.health.check", "implement.closing"],
-    ["check", "implement.closing", "build.review.reviewing"],
-    ["agent", "build.review.reviewing", "build.review.await-review"],
-  ]
-  const feedback: readonly Edge[] = [
-    ["human", "build.review.await-review", "build.review.collecting"],
-    ["agent", "build.review.collecting", "build.review.await-review"],
-    ["human", "build.review.await-review", "build.review.closing"],
-    ["check", "build.review.closing", "re-unwind"],
-    ["check", "re-unwind", "design.triage"],
-    ["agent", "design.triage", "design.gate.answer"],
-    ["human", "design.gate.answer", "implement.building"],
-  ]
-  const trails: Record<string, readonly Edge[]> = {
-    land: [["judge", "seam.judge", "implement.building", verdict("land")], ...building],
-    "land, then a feature feedback lap": [
-      ["judge", "seam.judge", "implement.building", verdict("land")],
-      ...building,
-      ...feedback,
-    ],
-    "rejected twice, steered, then landed": [
-      ["judge", "seam.judge", "seam.naive", verdict("reject")],
-      ["agent", "seam.naive", "seam.judge"],
-      ["judge", "seam.judge", "seam.naive", verdict("reject")],
-      ["agent", "seam.naive", "seam.judge"],
-      ["judge", "seam.judge", "seam.steer", verdict("reject")],
-      ["human", "seam.steer", "seam.naive"],
-      ["agent", "seam.naive", "seam.judge"],
-      ["judge", "seam.judge", "implement.building", verdict("land")],
-      ...building,
-    ],
-    "refactor-first": [
-      ["judge", "seam.judge", "seam.approve", verdict("refactor-first")],
-      ["human", "seam.approve", "refactor.deriving", approved],
-      ["check", "refactor.deriving", "refactor.building"],
-      ["agent", "refactor.building", "refactor.health.check"],
-      ["check", "refactor.health.check", "refactor.closing"],
-      ["check", "refactor.closing", "implement.building"],
-      ...building,
-    ],
-  }
-
-  const writeEdgeFiles = (
-    repo: { write: (path: string, content: string) => void },
-    from: string,
-    to: string,
-  ) => {
-    if (from === "seam.steer")
-      repo.write(
-        ".gtd/REQUIREMENTS.md",
-        "# Requirements\n\n- steered\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-      )
-    if (from === "build.review.reviewing") repo.write(".gtd/REVIEW.md", review())
-    if (to === "build.review.collecting")
-      repo.write(".gtd/REVIEW.md", review("also export multiply"))
-    if (from === "build.review.collecting") {
-      repo.write(".gtd/REVIEW.md", `${review("also export multiply")}    - A: noted.\n`)
-      repo.write(
-        ".gtd/REQUIREMENTS.md",
-        "# Requirements\n\n- multiply\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-      )
-    }
-    if (to === "build.review.closing") repo.write(".gtd/REVIEW.md", review())
-  }
-
-  /** The repo at the judge's rest, then `trail` forged edge by edge as `Gtd-Step:` commits. */
-  const forged = async (trail: readonly Edge[], upTo: number) => {
-    const repo = naivePlanned()
-    await repo.drive({
-      unwind: () => undefined,
-      "start-gate.check": () => undefined,
-      "design.triage": (_, r) =>
-        r.write(
-          ".gtd/REQUIREMENTS.md",
-          "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n\n## Impact\n\n- the module\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-        ),
-      "design.gate.answer": () => undefined,
-      "seam.naive": (_, r) => {
-        r.write("src/calc.ts", `${CALC}// naive\n`)
-        r.write("src/calc.test.ts", ACCEPTANCE)
-      },
-    })
-    const kept = /Gtd-Kept: (\w+)/.exec(repo.messages().at(-1)!)![1]!
-    const seen: Record<string, number> = {
-      "seam.naive": 1,
-      "design.triage": 1,
-      "design.gate.answer": 1,
-    }
-    for (const [actor, from, to, trailer] of trail.slice(0, upTo)) {
-      seen[from] = (seen[from] ?? 0) + 1
-      writeEdgeFiles(repo, from, to)
-      repo.commit(
-        [
-          `gtd(${actor}): ${from} → ${to}`,
-          "",
-          `Gtd-Step: ${from}#${seen[from]}`,
-          ...(trailer === undefined ? [] : [trailer]),
-          ...(actor === "agent" && from === "seam.naive" ? [`Gtd-Kept: ${kept}`] : []),
-          "Gtd-Format: 1",
-        ].join("\n"),
-      )
-    }
-    return repo
-  }
-
-  // seam.check now follows every naive pass, so no rest past the first naive pass replays.
-  for (const [name, trail] of Object.entries(trails)) {
-    it(`${name}: every rest past the naive pass fails replay`, async () => {
-      for (let upTo = 1; upTo <= trail.length; upTo++) {
-        const rest = trail[upTo - 1]![2]
-        const repo = await forged(trail, upTo)
-        await expect(repo.next(), rest).rejects.toThrow("the workflow changed under this process")
-      }
-    })
-  }
-})
-
-describe("an in-flight process from before the architecture path was removed", () => {
-  // No `## Impact`: no version before it wrote one, and replaying its triage must not refuse.
-  const REQUIREMENTS =
-    "# Requirements\n\n## Concerns\n\n### Subtract\n\n- `subtract`\n\n## Acceptance Criteria\n\n- AC-1: done\n"
-
-  /** Its history up to the design gate, forged with the old opening commit's `flag_naive_pass=0`. */
-  const atDesignGate = async () => {
-    const live = naivePlanned()
-    await live.drive({ unwind: () => undefined, "start-gate.check": () => undefined })
-    const opening = live.messages().find((m) => m.startsWith("gtd(human): idle → unwind"))!
-    const repo = naivePlanned()
-    repo.commit(
-      opening.replace(
-        "Gtd-Var: flag_risk_tier=0",
-        "Gtd-Var: flag_naive_pass=0\nGtd-Var: flag_risk_tier=0",
-      ),
-    )
-    repo.remove("TODO.md")
-    repo.commit("gtd(check): unwind → start-gate.check\n\nGtd-Step: unwind#1\nGtd-Format: 1")
-    repo.commit(
-      "gtd(check): start-gate.check → design.triage\n\nGtd-Step: start-gate.check#1\nGtd-Format: 1",
-    )
-    repo.write(".gtd/REQUIREMENTS.md", REQUIREMENTS)
-    repo.commit(
-      "gtd(agent): design.triage → design.gate.answer\n\nGtd-Step: design.triage#1\nGtd-Format: 1",
-    )
-    return repo
-  }
-
-  it("resting at the design gate, replays onto the naive pass", async () => {
-    const repo = await atDesignGate()
-    expect((await repo.next()).state).toBe("design.gate.answer")
-    await repo.land()
-    expect((await repo.next()).state).toBe("seam.naive")
-  })
-
-  it("past the design gate on the architecture path, fails replay", async () => {
-    const repo = await atDesignGate()
-    repo.commit(
-      "gtd(human): design.gate.answer → architecture.author\n\nGtd-Step: design.gate.answer#1\nGtd-Format: 1",
-    )
-    await expect(repo.next()).rejects.toThrow("the workflow changed under this process")
-  })
-})
-
-describe("release flag", () => {
-  it("with no Release Flag section, lands the naive pass with no seam judge", async () => {
-    const repo = testRepo({ workflow: CONFIG_SCAFFOLD })
-    repo.write("src/calc.ts", CALC)
-    repo.commit("feat: add calculator")
-    repo.write("TODO.md", "# Add subtract\n")
-    const rest = await repo.drive({
-      unwind: () => undefined,
-      "start-gate.check": () => undefined,
-      "design.triage": (_, r) =>
-        r.write(
-          ".gtd/REQUIREMENTS.md",
-          "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n\n## Impact\n\n- the module\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-        ),
-      "design.gate.answer": () => undefined,
-      "seam.naive": (_, r) => {
-        r.write("src/calc.ts", `${CALC}// naive\n`)
-        r.write("src/calc.test.ts", ACCEPTANCE)
-      },
-      "seam.check": () => undefined,
-      "implement.applying": runsItsScript,
-    })
-    expect(rest.state).toBe("implement.health.check")
-    expect(repo.read("src/calc.ts")).toBe(`${CALC}// naive\n`)
-    expect(repo.subjects().some((subject) => subject.includes("seam.judge"))).toBe(false)
-  })
-})
-
-// pins the public re-exports from the feature entry point
-export type _PublicBuildTailOptions = [
-  featureEntry.BuildTailOptions,
-  featureEntry.FeedbackTarget,
-  featureEntry.ReviewRange,
-]

package/src/workflows/feature/feature.ts

@@ -1,156 +0,0 @@
-import {
-  changes,
-  changesSince,
-  head,
-  human,
-  read,
-  revertScript,
-  run,
-  start,
-} from "../../flows/index.js"
-import { gate } from "../shared/health.js"
-import { naiveTestOn, shipped } from "../shared/options.js"
-import { FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
-import { refusePendingHandOff } from "../shared/tail.js"
-import * as t from "../shared/text.js"
-import {
-  criterionIds,
-  requireStableIds,
-  type StableIds,
-  skipDesign,
-  statedCriteria,
-  type StatedCriteria,
-} from "./criteria.js"
-import { design } from "./planning.js"
-import { buildTail, isCode, reUnwind, type ReviewOutcome } from "../shared/review.js"
-import { implement, implementing, seamBuild } from "./seam.js"
-import { recordRisk, riskTierOn } from "./tier.js"
-
-// 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 → a naive pass, tried by a person with
-// `naiveTest` on and judged when the requirements ask for a release flag: it
-// lands as the implementation, or (refactoring first when the judge asks) is
-// built fresh from → the health loop → the triaged quality lap and its finding gate → a
-// reviewer's walkthrough of the whole change for the human, which signs off
-// (the episode ends back at `idle`) or sends a design → implement lap.
-
-/** Revert the sketch that started the process out of the working tree; its intent survives in history. */
-export const unwind = (): Promise<void> => {
-  const commit = head()
-  return run("unwind", revertScript(commit, FEEDBACK, t.unwindFailure(commit)), {
-    label: "Unwinding your input",
-  })
-}
-
-export { reUnwind }
-
-/**
- * A naive pass (judged only when a release flag is asked for), then implement and the
- * quality lap, then the review; design must have run since `firstBase`.
- */
-export const buildFeature = async (firstBase: string): Promise<void> => {
-  const tier = riskTierOn() ? recordRisk() : undefined
-  // Every ID handed out, gathered before a later edit can drop one: none is ever reused.
-  const handedOut = new Set(listedIds())
-  const seam = await seamBuild(firstBase)
-  const used = gather(handedOut)
-  // Read before the implementation closes the file: the quality lap's coverage lens checks them.
-  const requirements = read(REQUIREMENTS)
-  const closed = await implementing({
-    reference: seam.reference,
-    tier,
-    afterRefactor: seam.refactored,
-    naive: seam.land === true ? seam.reference : undefined,
-    rebuild: seam.rebuild,
-  })
-  // A feature with no code beyond the carried-over tests: the refactor carried
-  // it, so the lap covers the whole change.
-  const carried = seam.rebuild?.acceptance?.tests ?? []
-  const base =
-    seam.refactored === true &&
-    !changesSince(seam.base).some((c) => isCode(c.path) && !carried.includes(c.path))
-      ? firstBase
-      : seam.base
-  const outcome = await buildTail(base, { green: true, lensBase: base, requirements })
-  await featureFeedback(outcome, base, { closed, used })
-}
-
-const listedIds = (): readonly string[] => criterionIds(read(REQUIREMENTS) ?? "")
-
-const gather = (handedOut: Set<string>): readonly string[] => {
-  for (const id of listedIds()) handedOut.add(id)
-  return [...handedOut]
-}
-
-// seam.naive / seam.judge never run on a feedback lap: its design → implement is built unjudged
-// and unrefactored.
-const featureFeedback = async (
-  first: ReviewOutcome,
-  lensBase: string,
-  ids: StableIds,
-): Promise<void> => {
-  let outcome = first
-  let closed = ids.closed
-  const handedOut = new Set([...ids.used, ...ids.closed])
-  while (outcome.verdict === "feedback") {
-    await reUnwind(outcome)
-    const lap = { closed, used: [...handedOut] }
-    // Gathered every round, so an ID one round adds and the next drops is never reused.
-    await design(outcome.base, () => {
-      requireStableIds(REQUIREMENTS, lap)
-      gather(handedOut)
-    })
-    const tier = riskTierOn() ? recordRisk() : undefined
-    const requirements = read(REQUIREMENTS)
-    closed = await implementing({ tier, amend: true })
-    outcome = await buildTail(outcome.base, {
-      green: true,
-      lensBase,
-      requirements,
-      lap: "feedback",
-    })
-  }
-}
-
-/** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
-export const planAndBuild = async (firstBase: string, stated?: StatedCriteria): Promise<void> => {
-  // GTD_FLAG_RISK_TIER: the tier is proposed at triage and set at the design gate, so no skip.
-  if (!(await skipDesign(riskTierOn() ? undefined : stated))) await design(firstBase)
-  await buildFeature(firstBase)
-}
-
-// seam.naive / seam.judge never run here: a re-plan's seam is built unjudged and unrefactored.
-/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. */
-export const afterTail = async (first: ReviewOutcome): Promise<void> => {
-  let outcome = first
-  while (outcome.verdict === "feedback") {
-    await reUnwind(outcome)
-    await design(outcome.base)
-    const tier = riskTierOn() ? recordRisk() : undefined
-    const requirements = read(REQUIREMENTS)
-    await implement({ tier, amend: true })
-    outcome = await buildTail(outcome.base, { green: true, requirements })
-  }
-}
-
-/** 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()
-  // Read right after idle, so a bad value refuses the landing that would pin it.
-  naiveTestOn()
-  const stated = statedCriteria(changes(), head())
-  await unwind()
-  if (changes(FEEDBACK).some((c) => c.status !== "deleted")) {
-    await human("unwind-failed", {
-      message: t.unwindFailedMessage(),
-      label: "Could not unwind your input",
-      file: FEEDBACK,
-    })
-  }
-  await gate("start-gate", t.startGateBlockedMessage())
-  await planAndBuild(start(), stated)
-}
-
-export const feature = shipped(ordinaryStart)

package/src/workflows/feature/green.ts

@@ -1,19 +0,0 @@
-import { healthy } from "../shared/health.js"
-import { coder, FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
-import * as t from "../shared/text.js"
-import { requireCriteriaFrozen } from "./criteria.js"
-
-export const green = (): Promise<void> =>
-  healthy(
-    () =>
-      t.agentWithSkills("fix.suite.fixing", t.implementFixPrompt(), {
-        label: "Fixing the check",
-        file: FEEDBACK,
-        model: coder(),
-        system: t.builderSystem(),
-      }),
-    {
-      guard: () => requireCriteriaFrozen(REQUIREMENTS),
-      guardRests: false,
-    },
-  )

package/src/workflows/feature/index.ts

@@ -1,18 +0,0 @@
-import { feature } from "./feature.js"
-
-export * from "./steps.js"
-export * from "./criteria.js"
-export * from "./planning.js"
-export * from "./refactor.js"
-export * from "./seam.js"
-export {
-  buildTail,
-  type BuildTailOptions,
-  type FeedbackTarget,
-  type ReviewOutcome,
-} from "../shared/review.js"
-export type { ReviewRange } from "../shared/text.js"
-export * from "./feature.js"
-export * from "../shared/reserved.js"
-
-export default feature

package/src/workflows/feature/lens-models.feature

@@ -1,69 +0,0 @@
-@inmem
-Feature: each quality lens runs on its own model hint
-
-  A `qualityReviews` entry may carry a model hint, `<lens>=<model>`. A lens
-  without one runs on the planner model (`smart`), except `conventions`,
-  `ponytail-review` and `test-audit`, which run on the coder model (`base`).
-
-  Background:
-    Given a gtd config with:
-      """
-      import { feature } from "@pmelab/gtd/workflows/feature"
-      export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
-      export default feature({
-        qualityReviews: "correctness, conventions, test-audit=opus",
-      })
-      """
-    And a file "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      """
-    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
-
-      ## Impact
-
-      - the greeting module
-
-      ## Acceptance Criteria
-
-      - AC-1: `subtract(a, b)` returns `a - b`.
-      """
-    And step "design.gate.answer" changes nothing
-    And step "seam.naive" writes "src/calc.test.ts" with:
-      """
-      it("[AC-1] subtracts", () => {})
-      """
-    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 step "seam.check" changes nothing
-    And step "implement.applying" runs its script
-    And step "implement.health.check" changes nothing
-    And step "implement.closing" runs its script
-
-  Scenario: a hinted lens runs on its hint, every other lens on its default
-    When the process is driven
-    Then the process rests at "build.quality.correctness.reviewing"
-    And the output of gtd "next --json" contains "\"model\":\"smart\""
-    Given step "build.quality.correctness.reviewing" changes nothing
-    When the process is driven
-    Then the process rests at "build.quality.conventions.reviewing"
-    And the output of gtd "next --json" contains "\"model\":\"base\""
-    Given step "build.quality.conventions.reviewing" changes nothing
-    When the process is driven
-    Then the process rests at "build.quality.test-audit.reviewing"
-    And the output of gtd "next --json" contains "\"model\":\"opus\""
-    And the resting step's content contains "test-audit"