@pmelab/gtd 58.2.0 → 59.0.0

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

@@ -1,90 +0,0 @@
-import { describe, expect, it } from "vitest"
-import {
-  conflictFor,
-  conflictTitle,
-  parseStandards,
-  renderStandards,
-  standardsBlock,
-} from "./standards.js"
-
-const conflict = { text: "Calculators are functions.", olds: ["Calculators are classes."] }
-
-describe("standards file", () => {
-  it("round-trips decided and undecided standards", () => {
-    const standards = { decided: ["Prefer early returns."], undecided: [conflict] }
-    expect(parseStandards(renderStandards(standards))).toEqual(standards)
-  })
-
-  it("reads a hand-edited file: any heading groups decided ones, wrapped lines join", () => {
-    const text = [
-      "# Standards",
-      "",
-      "Some prose.",
-      "",
-      "## Testing",
-      "",
-      "1. Every bug fix",
-      "  gets a test.",
-      "",
-      "## Undecided",
-      "",
-      "- New",
-      "  - contradicts: Old",
-    ].join("\n")
-    expect(parseStandards(text)).toEqual({
-      decided: ["Every bug fix gets a test."],
-      undecided: [{ text: "New", olds: ["Old"] }],
-    })
-  })
-})
-
-describe("a formatter-wrapped file", () => {
-  it("keeps a wrapped contradicts line with its old standard", () => {
-    const text = [
-      "## Undecided",
-      "",
-      "- Calculators are plain functions. (re: subtract has no class)",
-      "  - contradicts: Won't fix: subtract has no class — Calculators read better as",
-      "    classes.",
-    ].join("\n")
-    expect(parseStandards(text).undecided).toEqual([
-      {
-        text: "Calculators are plain functions. (re: subtract has no class)",
-        olds: ["Won't fix: subtract has no class — Calculators read better as classes."],
-      },
-    ])
-  })
-})
-
-describe("conflict notes", () => {
-  it("keep their title when a formatter rewrites the emphasis", () => {
-    const standards = { decided: [], undecided: [{ text: "Use _named_ exports.", olds: [] }] }
-    expect(
-      conflictFor(standards, conflictTitle({ text: "Use *named* exports.", olds: [] })),
-    ).toBeDefined()
-  })
-
-  it("are one per standard, however often the file lists it", () => {
-    const text = "## Undecided\n\n- New\n  - contradicts: Old\n- New\n  - contradicts: Old\n"
-    expect(parseStandards(text).undecided).toHaveLength(1)
-  })
-
-  it("title back to the conflict it asks about", () => {
-    const standards = { decided: [], undecided: [conflict] }
-    expect(conflictFor(standards, conflictTitle(conflict))).toBe(conflict)
-    expect(conflictFor(standards, "Standard conflict 00000000")).toBeUndefined()
-  })
-})
-
-describe("standardsBlock", () => {
-  it("is empty without decided standards", () => {
-    expect(standardsBlock(undefined)).toBe("")
-    expect(standardsBlock(renderStandards({ decided: [], undecided: [conflict] }))).toBe("")
-  })
-
-  it("lists only the decided ones", () => {
-    const block = standardsBlock(renderStandards({ decided: ["A."], undecided: [conflict] }))
-    expect(block).toContain("- A.")
-    expect(block).not.toContain(conflict.text)
-  })
-})

package/src/workflows/shared/standards.ts

@@ -1,156 +0,0 @@
-import { ANSWER_LEAD, FREE_TEXT_PLACEHOLDER } from "../../steering/index.js"
-
-export const STANDARDS = ".gtd/STANDARDS.md"
-
-/** A learned standard that contradicts decided ones, waiting on the human. */
-export interface Conflict {
-  readonly text: string
-  /** The decided standards it contradicts. */
-  readonly olds: readonly string[]
-}
-
-export interface Standards {
-  readonly decided: readonly string[]
-  readonly undecided: readonly Conflict[]
-}
-
-const UNDECIDED = "Undecided"
-
-// The same class as the review's `Gtd-Mark` anchors, so a title reads alike in both.
-export const oneLine = (text: string): string =>
-  // eslint-disable-next-line no-control-regex -- the control range IS the point
-  text.replace(/[\s\x00-\x1f\x7f-\x9f\u2028\u2029]+/g, " ").trim()
-
-const ITEM = /^(?:[-*+]|\d+[.)])\s+(.*)$/
-const CONTRADICTS = /^\s+[-*+]\s+contradicts:\s*(.*)$/i
-
-interface Item {
-  text: string
-  /** Set under `## Undecided`. */
-  olds?: string[]
-}
-
-// A formatter wraps long lines: the tail belongs to the last `contradicts:` once there is one.
-const wrapped = (item: Item, line: string): void => {
-  const olds = item.olds
-  if (olds !== undefined && olds.length > 0) olds[olds.length - 1] += ` ${line.trim()}`
-  else item.text += ` ${line.trim()}`
-}
-
-/** What tells two standards apart: not the emphasis or spacing a formatter may rewrite. */
-export const standardKey = (text: string): string =>
-  oneLine(text.replace(/[*_`\\]/g, "")).toLowerCase()
-
-// Each standard once, so every conflict note gets a title of its own.
-const toStandards = (items: readonly Item[]): Standards => {
-  const seen = new Set<string>()
-  const fresh = (text: string): boolean => {
-    const key = standardKey(text)
-    if (key === "" || seen.has(key)) return false
-    seen.add(key)
-    return true
-  }
-  const decided = items.filter((i) => i.olds === undefined).map((i) => oneLine(i.text))
-  const undecided = items.flatMap((i) =>
-    i.olds === undefined
-      ? []
-      : [{ text: oneLine(i.text), olds: i.olds.map(oneLine).filter((o) => o !== "") }],
-  )
-  return { decided: decided.filter(fresh), undecided: undecided.filter((c) => fresh(c.text)) }
-}
-
-/**
- * Every top-level bullet is one standard, those under `## Undecided` waiting
- * on the human; a hand-edited file may group the rest under any heading.
- */
-export const parseStandards = (text: string): Standards => {
-  const items: Item[] = []
-  let pending = false
-  let last: Item | undefined
-  for (const line of text.split("\n")) {
-    const heading = /^(#{1,6})\s+(.*)$/.exec(line)
-    const item = ITEM.exec(line)
-    const old = CONTRADICTS.exec(line)
-    if (heading !== null) {
-      pending = heading[1]!.length > 1 && heading[2]!.trim() === UNDECIDED
-      last = undefined
-    } else if (item !== null) {
-      last = pending ? { text: item[1]!, olds: [] } : { text: item[1]! }
-      items.push(last)
-    } else if (old !== null && last?.olds !== undefined) last.olds.push(old[1]!)
-    else if (/^\s+\S/.test(line) && last !== undefined) wrapped(last, line)
-    else if (line.trim() !== "") last = undefined
-  }
-  return toStandards(items)
-}
-
-export const renderStandards = ({ decided, undecided }: Standards): string => {
-  const parts = [
-    "# Standards",
-    "Kept from your review answers for every agent turn. One standard per bullet.",
-    ...(decided.length === 0 ? [] : [decided.map((s) => `- ${s}`).join("\n")]),
-    ...(undecided.length === 0
-      ? []
-      : [
-          `## ${UNDECIDED}`,
-          undecided
-            .map((c) => [`- ${c.text}`, ...c.olds.map((o) => `  - contradicts: ${o}`)].join("\n"))
-            .join("\n"),
-        ]),
-  ]
-  return `${parts.join("\n\n")}\n`
-}
-
-// FNV-1a over the key: a conflict's chunk title must survive markdown parsing and a
-// formatter's rewrite of STANDARDS.md, which its text may not.
-const hash = (raw: string): string => {
-  const text = standardKey(raw)
-  let h = 0x811c9dc5
-  for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 0x01000193)
-  return (h >>> 0).toString(16).padStart(8, "0")
-}
-
-const CONFLICT_TITLE = /^Standard conflict ([0-9a-f]{8})$/
-
-export const conflictTitle = (c: Conflict): string => `Standard conflict ${hash(c.text)}`
-
-export const conflictFor = (standards: Standards, title: string): Conflict | undefined => {
-  const id = CONFLICT_TITLE.exec(title)?.[1]
-  return id === undefined ? undefined : standards.undecided.find((c) => hash(c.text) === id)
-}
-
-export const isConflictTitle = (title: string): boolean => CONFLICT_TITLE.test(title)
-
-const KEEP_NEW = "keep the new one (drop the old)"
-const KEEP_OLD = "keep the old one (discard the new)"
-
-/** A conflict's chunk body; its three boxes read as fix / won't fix / own answer by position. */
-export const conflictBody = (c: Conflict): string =>
-  [
-    ...(c.olds.length === 0
-      ? [
-          `A standard learned from your answers contradicted ones another answer since replaced in \`${STANDARDS}\`. Keep it, discard it, or reword it.`,
-          `New: ${c.text}`,
-        ]
-      : [
-          `A standard learned from your answers contradicts ${c.olds.length === 1 ? "one" : "some"} already in \`${STANDARDS}\`. Your own answer replaces both with its wording.`,
-          `New: ${c.text}`,
-          `Old:\n\n${c.olds.map((o) => `- ${o}`).join("\n")}`,
-        ]),
-    `${ANSWER_LEAD}\n\n- [ ] ${KEEP_NEW}\n- [ ] ${KEEP_OLD}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`,
-  ].join("\n\n")
-
-/** What every agent turn is told while `.gtd/STANDARDS.md` holds decided standards. */
-export const standardsBlock = (text: string | undefined): string => {
-  const { decided } = parseStandards(text ?? "")
-  if (decided.length === 0) return ""
-  return `## Standards
-
-\`${STANDARDS}\` holds the standards the human set in earlier reviews.
-Follow every one in what you write. Reviewing, never raise a finding a
-standard rules out — a \`Won't fix:\` standard is a finding the human
-rejected, so never raise it or one like it again — and raise breaking a
-standard as a finding.
-
-${decided.map((s) => `- ${s}`).join("\n")}`
-}

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

@@ -1,219 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { installContext, type ScopeOptions, type StepRequest } from "../../flows/index.js"
-import { captureStep, fixtureContext } from "./text.fixture.js"
-import * as steps from "./steps.js"
-
-const capture = (
-  fn: () => Promise<void>,
-  scope: string,
-  skills?: Readonly<Record<string, readonly string[]>>,
-): Promise<StepRequest> => captureStep(fn, { scope, ...(skills !== undefined ? { skills } : {}) })
-
-const agentPrompt = (request: StepRequest): string => {
-  if (request.kind !== "agent") throw new Error(`expected an agent step, got ${request.kind}`)
-  return request.prompt
-}
-
-describe("the bundled workflow's steps declare skills — a bundled step's rendered prompt carries its bundled skills.ts preamble", () => {
-  it("fix carries build.fix's bundled skills", async () => {
-    const prompt = agentPrompt(await capture(() => steps.fixCheck(), "build"))
-    expect(prompt).toContain("debugging-and-error-recovery")
-  })
-
-  it("describeEscalation carries health.describe's bundled skills", async () => {
-    const prompt = agentPrompt(await capture(() => steps.describeEscalation(), "build"))
-    expect(prompt).toContain("debugging-and-error-recovery")
-  })
-
-  it("reviewQuality names its lens scope, build.quality.<lens>.reviewing", async () => {
-    const request = await capture(() => steps.reviewQuality("owasp-security"), "build")
-    if (request.kind !== "agent") throw new Error("unreachable")
-    expect(request.name).toBe("quality.owasp-security.reviewing")
-  })
-
-  it("an unknown lens's preamble names the lens itself, from the bundled per-lens key", async () => {
-    const prompt = agentPrompt(await capture(() => steps.reviewQuality("owasp-security"), "build"))
-    expect(prompt).toContain("missing one: owasp-security")
-  })
-
-  it("a configured build.quality.<lens> entry replaces the lens's skills in the preamble, every other lens untouched", async () => {
-    const skills = { "build.quality.owasp-security": ["my-org-checklist"] }
-    const prompt = agentPrompt(
-      await capture(() => steps.reviewQuality("owasp-security"), "build", skills),
-    )
-    expect(prompt).toContain("my-org-checklist")
-    expect(prompt).toContain("owasp-security")
-  })
-
-  it("correctness carries all four trace points", async () => {
-    const request = await capture(() => steps.reviewQuality("correctness"), "build")
-    const body = JSON.stringify(request)
-    for (const point of [
-      "partial-failure",
-      "format, not just its presence",
-      "parallel write paths",
-      "contract test",
-    ])
-      expect(body).toContain(point)
-  })
-
-  it.each(["conventions", "spec-challenge", "criteria-coverage"])(
-    "%s carries its brief",
-    async (lens) => {
-      const request = await capture(() => steps.reviewQuality(lens), "build")
-      expect(JSON.stringify(request)).toContain(
-        steps.builtInLenses[lens]!.brief.split("\n")[0]!.slice(0, 40),
-      )
-    },
-  )
-
-  it("an unknown lens has no brief", async () => {
-    const request = await capture(() => steps.reviewQuality("my-lens"), "build")
-    expect(JSON.stringify(request)).not.toContain("This lens's brief")
-  })
-
-  it("fixQuality carries build.fix.quality's bundled skills", async () => {
-    const prompt = agentPrompt(await capture(() => steps.fixQuality(), "build"))
-    expect(prompt).toContain("incremental-implementation, code-simplification")
-  })
-
-  it("reviewing carries build.review.reviewing's bundled skills", async () => {
-    const prompt = agentPrompt(await capture(() => steps.reviewing("base"), "build"))
-    expect(prompt).toContain("code-review-and-quality")
-  })
-
-  it("an empty configured list leaves that step's skills empty, and its rendered prompt bare", async () => {
-    const request = await capture(() => steps.fixCheck(), "build", { build: [] })
-    if (request.kind !== "agent") throw new Error("unreachable")
-    expect(request.prompt).not.toContain("Load whatever's listed here")
-  })
-
-  it("fixRisks fixes every risk, tolerates an empty turn, and leaves .gtd/REVIEW.md alone", async () => {
-    const request = await capture(
-      () => steps.fixRisks([{ id: "risk-1", anchor: "calc ./a.ts#1-1", text: "Risk: drops it" }]),
-      "build",
-    )
-    if (request.kind !== "agent") throw new Error("unreachable")
-    expect(request.name).toBe("review.fix.risks.fixing")
-    expect(request.options).toMatchObject({ allowEmpty: true })
-    expect(request.prompt).toContain("debugging-and-error-recovery, incremental-implementation")
-    expect(request.prompt).toContain("risk-1 — calc ./a.ts#1-1")
-    expect(request.prompt).toContain("Risk: drops it")
-    expect(request.prompt).toContain("Leave `.gtd/REVIEW.md` untouched")
-  })
-
-  it("reviewing names the carry-over commit only when given one", async () => {
-    const bare = await capture(() => steps.reviewing("base"), "build")
-    const carried = await capture(() => steps.reviewing("base", "abc1234"), "build")
-    if (bare.kind !== "agent" || carried.kind !== "agent") throw new Error("unreachable")
-    expect(bare.prompt).not.toContain("Carry-over")
-    expect(carried.prompt).toContain("Carry-over: commit `abc1234`")
-  })
-})
-
-describe("the bundled workflow's model hints", () => {
-  const modelOf = async (
-    fn: () => Promise<void>,
-    context: Parameters<typeof captureStep>[1] = {},
-  ): Promise<string | undefined> => {
-    const request = await captureStep(fn, { scope: "build", ...context })
-    if (request.kind !== "agent") throw new Error(`expected an agent step, got ${request.kind}`)
-    return request.options.model
-  }
-
-  it.each([
-    ["correctness", "smart"],
-    ["owasp-security", "smart"],
-    ["spec-challenge", "smart"],
-    ["conventions", "base"],
-    ["ponytail-review", "base"],
-    ["test-audit", "base"],
-    ["my-lens", "smart"],
-  ])("lens %s defaults to %s", async (lens, model) => {
-    expect(await modelOf(() => steps.reviewQuality(lens))).toBe(model)
-  })
-
-  it("a lens's default follows the planner or coder setting it stands for", async () => {
-    const env = { plannerModel: "opus", coderModel: "sonnet" }
-    expect(await modelOf(() => steps.reviewQuality("correctness"), { env })).toBe("opus")
-    expect(await modelOf(() => steps.reviewQuality("conventions"), { env })).toBe("sonnet")
-  })
-
-  it("a model passed in wins over the lens's default; a blank one is none", async () => {
-    expect(await modelOf(() => steps.reviewQuality("correctness", undefined, "base"))).toBe("base")
-    expect(await modelOf(() => steps.reviewQuality("conventions", undefined, "opus"))).toBe("opus")
-    expect(await modelOf(() => steps.reviewQuality("conventions", undefined, ""))).toBe("base")
-  })
-
-  it("a lens named like an Object member still gets its default", async () => {
-    expect(await modelOf(() => steps.reviewQuality("constructor"))).toBe("smart")
-  })
-
-  it("the fix loop runs on the coder model, base by default", async () => {
-    expect(await modelOf(() => steps.fixCheck())).toBe("base")
-    expect(await modelOf(() => steps.fixQuality())).toBe("base")
-    expect(await modelOf(() => steps.fixCheck(), { env: { coderModel: "sonnet" } })).toBe("sonnet")
-  })
-
-  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?" }]),
-      "build",
-    )
-    if (request.kind !== "agent") throw new Error("unreachable")
-    expect(request.name).toBe("review.answer-review-questions")
-    expect(request.options).toMatchObject({
-      file: ".gtd/REVIEW.md",
-      mode: "review",
-    })
-    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")
-  })
-
-  it("fixNits fixes every nit in one turn and leaves .gtd/REVIEW.md alone", async () => {
-    const request = await capture(
-      () =>
-        steps.fixNits([
-          { id: "note-1", anchor: "calc ./a.ts#1-1", text: "typo" },
-          { id: "note-2", anchor: "calc ./a.ts#2-2", text: "semicolon" },
-        ]),
-      "build",
-    )
-    if (request.kind !== "agent") throw new Error("unreachable")
-    expect(request.name).toBe("review.fix.nits.fixing")
-    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")
-  })
-
-  it("fixNits with access runs in a review.fix.nits scope, the step named fixing inside it", async () => {
-    const scopes: ScopeOptions[] = []
-    const steps_: StepRequest[] = []
-    const access = { write: ["src/a.ts", ".gtd/**"] }
-    installContext(
-      fixtureContext(
-        { scope: "refactor.build" },
-        {
-          step: (request) => {
-            steps_.push(request)
-            return Promise.resolve()
-          },
-          pushScope: (s) => void scopes.push(s),
-          popScope: () => undefined,
-          changesSince: () => [],
-        },
-      ),
-    )
-    try {
-      await steps.fixNits([], access)
-    } finally {
-      installContext(undefined)
-    }
-    expect(scopes).toEqual([{ name: "review.fix.nits", access }])
-    expect(steps_.map((r) => ("name" in r ? r.name : ""))).toEqual(["fixing"])
-  })
-})

package/src/workflows/shared/steps.ts

@@ -1,201 +0,0 @@
-import { changesSince, env, human, scope, type ScopeAccess } from "../../flows/index.js"
-import { removedAssertions, type CollectRound } from "../../workflow-kit/index.js"
-import * as t from "./text.js"
-
-// The bundled workflow's single steps. A step's name is relative to the
-// scope its caller runs it in — `triage` inside `scope("design")` is
-// `design.triage` — and the full name is public API: renaming it strands
-// every process resting on it.
-
-export const FEEDBACK = ".gtd/FEEDBACK.md"
-export const ESCALATION = ".gtd/ESCALATION.md"
-export const REQUIREMENTS = ".gtd/REQUIREMENTS.md"
-export const REVIEW = ".gtd/REVIEW.md"
-export const REFACTOR = ".gtd/REFACTOR.md"
-export const REFACTOR_NOTE = ".gtd/REFACTOR-NOTE.md"
-export const QUALITY = ".gtd/QUALITY.md"
-export const NAIVE_TEST = ".gtd/NAIVE-TEST.md"
-
-export const planner = (): string => env.plannerModel ?? ""
-export const coder = (): string => env.coderModel ?? ""
-
-// ── Keeping the suite green ─────────────────────────────────────────────────
-
-export const fixCheck = (rules?: string): Promise<void> =>
-  t.agentWithSkills("fix", t.buildFixPrompt(rules), {
-    label: "Fixing the check",
-    file: FEEDBACK,
-    model: coder(),
-    system: t.finisherSystem(),
-  })
-
-export const describeEscalation = (rules?: string): Promise<void> =>
-  t.agentWithSkills("health.describe", t.healthDescribePrompt(rules), {
-    label: "Describing the escalation",
-    file: FEEDBACK,
-    model: coder(),
-    system: t.escalationSystem(),
-    allowEmpty: true,
-  })
-
-export const escalate = (): Promise<void> =>
-  human("health.stop", {
-    message: t.healthStopMessage(),
-    label: "Escalating to a human",
-    file: ESCALATION,
-    acceptClean: true,
-  })
-
-export const escalationExhausted = (): Promise<void> =>
-  human("health.exhausted", {
-    message: t.healthExhaustedMessage(),
-    label: "Escalation exhausted",
-    file: ESCALATION,
-    acceptClean: true,
-  })
-
-// ── Quality and review ──────────────────────────────────────────────────────
-
-export interface BuiltInLens {
-  readonly skills: readonly string[]
-  readonly brief: string
-}
-
-/** Lenses the workflow defines itself, not bundled skills: `skills/` is not in the npm package, and a missing lens skill burns a turn silently. */
-export const builtInLenses: Readonly<Record<string, BuiltInLens>> = {
-  correctness: { skills: ["code-review-and-quality"], brief: t.correctnessBrief },
-  conventions: { skills: [], brief: t.conventionsBrief },
-  "spec-challenge": { skills: [], brief: t.specChallengeBrief },
-  "criteria-coverage": { skills: [], brief: t.criteriaCoverageBrief },
-}
-
-const coderLenses: ReadonlySet<string> = new Set(["conventions", "ponytail-review", "test-audit"])
-
-/**
- * One quality review through `lens`; each lens is its own scope, so its own
- * conversation and skills. `requirements`, when given, are quoted in the prompt.
- */
-export const reviewQuality = (
-  lens: string,
-  base?: string,
-  model?: string,
-  requirements?: string,
-): Promise<void> =>
-  t.agentWithSkills(
-    `quality.${lens}.reviewing`,
-    t.buildQualityReviewingPrompt(lens, builtInLenses[lens]?.brief, base, requirements),
-    {
-      label: "Reviewing (one quality lens)",
-      file: QUALITY,
-      model: model || (coderLenses.has(lens) ? coder() : planner()),
-      system: t.reviewerSystem(),
-      allowEmpty: true,
-    },
-  )
-
-export const fixQuality = (rules?: string): Promise<void> =>
-  t.agentWithSkills("fix.quality.fixing", t.buildFixQualityPrompt(rules), {
-    label: "Fixing quality findings",
-    file: QUALITY,
-    model: coder(),
-    system: t.finisherSystem(),
-    allowEmpty: true,
-  })
-
-/** Write `.gtd/REVIEW.md` over everything since `base`, carrying the answers of commit `carry` when given; `extra` joins the prompt. */
-export const reviewing = (
-  base: string,
-  carry?: string,
-  lap: t.ReviewRange = "first",
-  extra = "",
-): Promise<void> =>
-  t.agentWithSkills(
-    "review.reviewing",
-    t.buildReviewReviewingPrompt(base, lap, carry, removedAssertions(changesSince(base)), extra),
-    {
-      label: "Reviewing",
-      file: REVIEW,
-      mode: "review",
-      model: planner(),
-      system: t.reviewerSystem(),
-      base,
-    },
-  )
-
-/** Fix the `Risk:`-marked notes the reviewer named; an empty turn means the risk was judged false. */
-export const fixRisks = (
-  notes: readonly t.NoteInput[],
-  access?: ScopeAccess,
-  rules?: string,
-): Promise<void> => {
-  const fixing = (name: string): Promise<void> =>
-    t.agentWithSkills(name, t.buildReviewFixRisksPrompt(notes, rules), {
-      label: "Fixing the reviewer's risks",
-      file: REVIEW,
-      model: planner(),
-      system: t.reviewerSystem(),
-      allowEmpty: true,
-    })
-  return access === undefined
-    ? fixing("review.fix.risks.fixing")
-    : scope({ name: "review.fix.risks", access }, () => fixing("fixing"))
-}
-
-export const awaitReview = (
-  base: string,
-  message = t.buildReviewAwaitReviewMessage(base),
-): Promise<void> =>
-  human("review.await-review", {
-    message,
-    label: "Awaiting your review",
-    file: REVIEW,
-    mode: "review",
-    base,
-    acceptClean: true,
-  })
-
-/** Answer every `question` note inline in `.gtd/REVIEW.md`. */
-export const answerReviewQuestions = (notes: readonly t.NoteInput[]): Promise<void> =>
-  t.agentWithSkills("review.answer-review-questions", t.buildReviewAnswerQuestionsPrompt(notes), {
-    label: "Answering your questions",
-    file: REVIEW,
-    mode: "review",
-    model: planner(),
-    system: t.reviewerSystem(),
-  })
-
-/** Fix every `nit` note in one turn. */
-export const fixNits = (
-  notes: readonly t.NoteInput[],
-  access?: ScopeAccess,
-  rules?: string,
-): Promise<void> => {
-  const fixing = (name: string): Promise<void> =>
-    t.agentWithSkills(name, t.buildReviewFixNitsPrompt(notes, rules), {
-      label: "Fixing your nits",
-      file: REVIEW,
-      model: planner(),
-      system: t.reviewerSystem(),
-    })
-  return access === undefined
-    ? fixing("review.fix.nits.fixing")
-    : scope({ name: "review.fix.nits", access }, () => fixing("fixing"))
-}
-
-/** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
-export const collecting = (capture: string, round?: CollectRound): Promise<void> =>
-  t.agentWithSkills("review.collecting", t.buildReviewCollectingPrompt(capture, undefined, round), {
-    label: "Collecting your feedback",
-    file: REQUIREMENTS,
-    mode: "qa",
-    model: planner(),
-    system: t.reviewerSystem(),
-    allowEmpty: true,
-  })
-
-/** The round at commit `round` left no `.gtd/REVIEW.md`. */
-export const reviewMissing = (round: string): Promise<void> =>
-  human("review.review-missing", {
-    message: t.buildReviewReviewMissingMessage(round),
-    label: "Nothing to review",
-  })