@pmelab/gtd 58.2.0 → 59.0.1

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

@@ -1,148 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { toRequest } from "../../judges/index.js"
-import { testRepo } from "../../testkit/index.js"
-import { retryQuestion } from "./health.js"
-
-describe("retryQuestion", () => {
-  it.each([true, false])("is sendable to jev (comparable=%s)", (comparable) => {
-    const { primitive, ...rest } = retryQuestion(comparable)
-    const { questions } = toRequest([{ ...rest, primitive } as never], {})
-    expect(
-      Object.keys((questions["verdict"] as { criteria: object }).criteria).length,
-    ).toBeGreaterThanOrEqual(2)
-  })
-})
-
-type W = { write(p: string, c: string): void }
-
-describe("gate guard", () => {
-  const config = (guard: string) =>
-    [
-      `import { gate } from "@pmelab/gtd/workflows"`,
-      `import { agent, refuse } from "@pmelab/gtd/flows"`,
-      `export const held = async () => { await agent("first", "go"); ${guard}; await gate("suite", "fix it", guard) }`,
-      `export default held`,
-    ].join("\n")
-
-  const red = {
-    first: (_: unknown, r: W) => r.write("f", "1\n"),
-    "suite.check": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", "red\n"),
-    "suite.recheck": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", "red again\n"),
-  }
-
-  it("runs the guard after a blocked landing and lets its refusal stop it", async () => {
-    const repo = testRepo({
-      workflow: config('const guard = () => { refuse("guarded: nope") }'),
-      env: { GTD_TEST_COMMAND: "true" },
-    })
-    await repo.start("held")
-    await repo.drive(red)
-    await expect(repo.drive({ "suite.blocked": (_, r) => r.write("x", "1\n") })).rejects.toThrow(
-      "guarded: nope",
-    )
-  })
-
-  it("never runs the guard after the check step", async () => {
-    const repo = testRepo({
-      workflow: config('const guard = () => { refuse("guarded: nope") }'),
-      env: { GTD_TEST_COMMAND: "true" },
-    })
-    await repo.start("held")
-    const rest = await repo.drive(red)
-    expect(rest.state).toBe("suite.blocked")
-  })
-})
-
-describe("healthy describeGuard", () => {
-  const config = (options: string) =>
-    [
-      `import { healthy } from "@pmelab/gtd/workflows"`,
-      `import { agent, read, refuse } from "@pmelab/gtd/flows"`,
-      `const describeGuard = () => { refuse("describe-guarded: nope") }`,
-      `const guard = () => { refuse("guarded: nope") }`,
-      `export const held = async () => { await agent("first", "go"); await healthy(() => agent("fix", "go"), ${options}) }`,
-      `export default held`,
-    ].join("\n")
-
-  let runs = 0
-  const handlers = (extra: Record<string, unknown>) => ({
-    "health.check": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", `red ${runs++}\n`),
-    "health.recheck": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", `red ${runs++}\n`),
-    "health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
-    fix: (_: unknown, r: W) => r.write("f", `${runs}\n`),
-    first: (_: unknown, r: W) => r.write("start", "1\n"),
-    ...extra,
-  })
-  const make = (options: string) =>
-    testRepo({ workflow: config(options), env: { GTD_TEST_COMMAND: "true" } })
-
-  it("runs after a describe landing and its refusal stops the turn", async () => {
-    runs = 0
-    const repo = make("{ describeGuard }")
-    await repo.start("held")
-    await expect(repo.drive(handlers({ "health.describe": () => undefined }))).rejects.toThrow(
-      "describe-guarded: nope",
-    )
-  })
-
-  it("never runs after the human stop rest", async () => {
-    runs = 0
-    // Refuses only once a person's edit exists, which only a post-stop run can see.
-    const repo = make(
-      '{ describeGuard: () => { if (read("human.txt") !== undefined) refuse("describe-guarded: late") } }',
-    )
-    await repo.start("held")
-    const rest = await repo.drive(handlers({ "health.describe": () => undefined }))
-    expect(rest.state).toBe("health.stop")
-    const after = await repo.drive(
-      handlers({ "health.stop": (_: unknown, r: W) => r.write("human.txt", "edit\n") }),
-    )
-    expect(after.state).not.toBe("health.stop")
-  })
-
-  it("keeps guard running after describe", async () => {
-    runs = 0
-    // Refuses only once the describe turn has written its analysis.
-    const repo = make(
-      '{ guard: () => { if (read(".gtd/ESCALATION.md") !== undefined) refuse("guarded: nope") } }',
-    )
-    await repo.start("held")
-    await expect(
-      repo.drive(
-        handlers({
-          "health.describe": (_: unknown, r: W) => r.write(".gtd/ESCALATION.md", "why\n"),
-        }),
-      ),
-    ).rejects.toThrow("guarded: nope")
-  })
-})
-
-describe("healthy at the fix cap", () => {
-  // Blank reports are not comparable; at an 8-byte budget the cut trims both.
-  it.each([
-    ["could not compare", "", (n: number) => "\n".repeat(n)],
-    ["saw only cut", `, judgeBudgetBytes: "8"`, (n: number) => `a long failing report ${n}\n`],
-  ])("grants no extra turn on progress the judge %s", async (_, extra, report) => {
-    let runs = 0
-    const repo = testRepo({
-      workflow: [
-        `import { healthy } from "@pmelab/gtd/workflows"`,
-        `import { agent } from "@pmelab/gtd/flows"`,
-        `export const defaults = { judgeIdenticalMinP: "0.7"${extra} }`,
-        `export const held = async () => { await agent("first", "go"); await healthy(() => agent("fix", "go")) }`,
-        `export default held`,
-      ].join("\n"),
-      env: { GTD_TEST_COMMAND: "true" },
-    })
-    await repo.start("held")
-    const rest = await repo.drive({
-      first: (_, r) => r.write("start", "1\n"),
-      "health.check": (_, r) => r.write(".gtd/FEEDBACK.md", report(++runs)),
-      "health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
-      fix: (_, r) => r.write("f", `${runs}\n`),
-      "health.recheck": (_, r) => r.write(".gtd/FEEDBACK.md", "red again\n"),
-    })
-    expect(rest.state).toBe("health.describe")
-    expect(repo.subjects().filter((s) => s.startsWith("gtd(agent): fix")).length).toBe(3)
-  })
-})

package/src/workflows/shared/health.ts

@@ -1,191 +0,0 @@
-import {
-  answered,
-  check,
-  env,
-  human,
-  judge,
-  mark,
-  numeric,
-  vars,
-  type CheckOptions,
-  type JudgeQuestion,
-} from "../../flows/index.js"
-import * as kit from "../../workflow-kit/index.js"
-import { describeEscalation, escalate, escalationExhausted, ESCALATION, FEEDBACK } from "./steps.js"
-import * as t from "./text.js"
-
-/** Fix turns a run of red checks gets before it escalates. */
-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, env.testCommand ?? "", { report: FEEDBACK, label })
-
-/**
- * Re-run a red check as step `name` before a person sees it. Green records
- * `Gtd-Mark: flaky=<red>` on the re-check's landing and resolves `true`.
- */
-export const recheck = async (
-  name: string,
-  red: string,
-  options: Pick<CheckOptions, "sweepOnGreen"> = {},
-): Promise<boolean> => {
-  const green = await check(name, env.testCommand ?? "", {
-    ...options,
-    report: FEEDBACK,
-    label: "Re-running checks",
-  })
-  if (green) mark("flaky", red)
-  return green
-}
-
-export type { EscalationCount } from "../../workflow-kit/index.js"
-
-const escalationSteps = (rules?: string): kit.EscalationSteps => ({
-  limit: 2,
-  describe: () => describeEscalation(rules),
-  stop: escalate,
-  exhausted: escalationExhausted,
-})
-
-/** Runs after an agent or human turn; refuses it by throwing (`refuse`). */
-export type Guard = () => void
-
-export const guarded =
-  <A extends unknown[]>(turn: (...a: A) => Promise<void>, guard?: Guard) =>
-  async (...a: A): Promise<void> => {
-    await turn(...a)
-    guard?.()
-  }
-
-const guardedSteps = (
-  guard?: Guard,
-  describeGuard?: Guard,
-  rests = true,
-  rules?: string,
-): kit.EscalationSteps => {
-  const steps = escalationSteps(rules)
-  return {
-    limit: steps.limit,
-    describe: guarded(guarded(steps.describe, guard), describeGuard),
-    stop: guarded(steps.stop, rests ? guard : undefined),
-    exhausted: guarded(steps.exhausted, rests ? guard : undefined),
-  }
-}
-
-/**
- * Hand a red suite that repeated attempts could not fix to a person: an
- * agent writes `.gtd/ESCALATION.md`, a human narrows it. From the third round
- * on, the human is told the budget is spent instead.
- */
-export const escalation = (
-  count: kit.EscalationCount,
-  guard?: Guard,
-  guardRests = true,
-  rules?: string,
-): Promise<void> => kit.escalation(count, guardedSteps(guard, undefined, guardRests, rules))
-
-/** "Is this red round the same failure as the last one?" — asked of two reports, or of nothing when one is empty. */
-export const retryQuestion = (comparable: boolean): JudgeQuestion =>
-  comparable
-    ? {
-        id: "verdict",
-        primitive: "choice",
-        instructions:
-          "Compare this round's failing check output (current) against the previous round's (previous), both in state. Classify the change.",
-        criteria:
-          "identical: the same failure restated, byte-for-byte or the same root cause — the trailing `<!-- gtd check <sha> -->` stamp is already stripped from both, but ignore it too if it ever reappears. new-failure: a materially different symptom than previous. progress: still red, but measurably closer to green (fewer failures, a later stage reached).",
-      }
-    : {
-        id: "verdict",
-        primitive: "choice",
-        instructions:
-          "state carries tailsNotComparable: one of the two check reports came back empty. There is nothing to compare here; answer from criteria alone. `identical` is FORBIDDEN here.",
-        criteria:
-          "new-failure: a materially different failure than before. progress: still red, but closer to green — the default if genuinely unsure.",
-      }
-
-const compare = async (
-  previous: string,
-  current: string,
-): Promise<kit.RetryVerdict | undefined> => {
-  const comparable = current.trim() !== "" && previous.trim() !== ""
-  const { answers, truncated } = await judge("health.judge", {
-    questions: [retryQuestion(comparable)],
-    evidence: comparable ? { current, previous } : { tailsNotComparable: "true" },
-    message: t.healthJudgeMessage(),
-    label: "Judging the retry",
-  })
-  // Evidence the budget cut can make two different reports look alike: neither sameness nor progress.
-  if (!comparable || truncated.length > 0) return undefined
-  const minP = numeric(vars.judgeIdenticalMinP, Infinity)
-  if (answered(answers.verdict, "identical", minP)) return "identical"
-  return answered(answers.verdict, "progress", minP) ? "progress" : undefined
-}
-
-export interface HealthOptions {
-  /** Fix turns already spent before this call. */
-  readonly fixesSoFar?: number
-  /** Escalation rounds shared with other callers in the same run of red checks. */
-  readonly escalations?: kit.EscalationCount
-  /** Paths removed on a green run. */
-  readonly sweepOnGreen?: readonly string[]
-  /** Runs after every fix and escalation turn. */
-  readonly guard?: Guard | undefined
-  /** Runs after the escalation's agent turn only; the human rests stay unguarded. */
-  readonly describeGuard?: Guard | undefined
-  /** `false`: `guard` skips the human rests `health.stop` and `health.exhausted`. */
-  readonly guardRests?: boolean | undefined
-  readonly rules?: string | undefined
-}
-
-// Swept only on green: an unresolved analysis survives every retry.
-const healthSweep = (options: HealthOptions): string[] => [
-  ESCALATION,
-  ...(options.sweepOnGreen ?? []),
-]
-
-const runSuite = (options: HealthOptions): Promise<boolean> =>
-  check("health.check", env.testCommand ?? "", {
-    report: FEEDBACK,
-    label: "Running checks",
-    sweepOnGreen: healthSweep(options),
-  })
-
-/**
- * Loop until the suite is green: check, and on red run `fix` — escalating
- * first once `FIX_CAP` fixes are spent, or a judge calls the failure
- * identical to the previous round's. A judge calling it progress at the cap
- * buys one extra fix per run of fixes. An escalation re-runs the suite once
- * first; a green re-run ends the loop.
- */
-export const healthy = (fix: () => Promise<void>, options: HealthOptions = {}): Promise<void> =>
-  kit.healthy(guarded(fix, options.guard), {
-    check: () => runSuite(options),
-    report: FEEDBACK,
-    fixCap: FIX_CAP,
-    fixesSoFar: options.fixesSoFar ?? 0,
-    compare,
-    escalations: options.escalations ?? { rounds: 0 },
-    recheck: () =>
-      recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),
-    escalation: guardedSteps(
-      options.guard,
-      options.describeGuard,
-      options.guardRests,
-      options.rules,
-    ),
-  })
-
-/**
- * Hold the process at `<name>.blocked` until the suite is green, re-running a
- * red check once as `<name>.recheck` before resting. `guard` runs
- * after each `blocked` landing only — never after a check, whose refusal would
- * re-run the same script forever.
- */
-export const gate = (name: string, message: string, guard?: Guard): Promise<void> =>
-  kit.gate(
-    name,
-    async () => (await baseline("check")) || recheck("recheck", `${name}.check`),
-    guarded(() => human("blocked", { message, label: "Baseline is red", file: FEEDBACK }), guard),
-  )

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

@@ -1,140 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest"
-
-const state = vi.hoisted(() => ({
-  files: {} as Record<string, string | undefined>,
-  vars: { standardMinP: "0.8" } as Record<string, string>,
-  answers: {} as Record<string, { answer: string; p: number } | undefined>,
-  judged: [] as string[][],
-  written: {} as Record<string, string>,
-}))
-
-vi.mock("../../flows/index.js", async (original) => ({
-  ...(await original<typeof import("../../flows/index.js")>()),
-  read: (path: string) => state.files[path],
-  vars: state.vars,
-  judge: async (_: string, spec: { questions: { id: string }[] }) => {
-    state.judged.push(spec.questions.map((q) => q.id))
-    return { answers: state.answers, truncated: [] }
-  },
-  run: async (_: string, script: string) => {
-    const path = /> '([^']+)'/.exec(script)?.[1] ?? ""
-    const content = /printf '%s' '((?:[^']|'\\'')*)'/.exec(script)?.[1] ?? ""
-    state.written[path] = content.replaceAll("'\\''", "'")
-  },
-}))
-
-import type { ReviewDecision } from "../../steering/index.js"
-import { learnStandards } from "./learn.js"
-
-const STANDARDS = ".gtd/STANDARDS.md"
-
-const file = (...lines: string[]): string =>
-  [
-    "# Standards",
-    "",
-    "Kept from your review answers for every agent turn. One standard per bullet.",
-    "",
-    ...lines,
-    "",
-  ].join("\n")
-
-const answer = (anchor: string, text: string): ReviewDecision => ({
-  anchor,
-  body: "",
-  choice: "answer",
-  text,
-})
-
-const yes = { answer: "yes", p: 0.9 }
-const no = { answer: "no", p: 0.9 }
-const kept = () => state.written[STANDARDS]
-
-beforeEach(() => {
-  state.files = { ".gtd/REVIEW.md": "# Review\n" }
-  state.vars.standardMinP = "0.8"
-  state.answers = {}
-  state.judged = []
-  state.written = {}
-})
-
-describe("learnStandards", () => {
-  it("asks a later candidate about each earlier one, and holds a contradiction for the human", async () => {
-    state.answers = { "standard-1": yes, "standard-2": yes, "standard-2.contradicts-new-1": yes }
-    await learnStandards([answer("A", "Use classes."), answer("B", "Never use classes.")])
-    expect(state.judged[0]).toContain("standard-2.contradicts-new-1")
-    expect(kept()).toBe(
-      file(
-        "- Use classes. (re: A)",
-        "",
-        "## Undecided",
-        "",
-        "- Never use classes. (re: B)",
-        "  - contradicts: Use classes. (re: A)",
-      ),
-    )
-  })
-
-  it("raises a contradiction ruled out below the threshold", async () => {
-    state.files[STANDARDS] = file("- Old.")
-    state.answers = { "standard-1": yes, "standard-1.contradicts-1": { answer: "no", p: 0.5 } }
-    await learnStandards([answer("A", "New.")])
-    expect(kept()).toBe(
-      file("- Old.", "", "## Undecided", "", "- New. (re: A)", "  - contradicts: Old."),
-    )
-  })
-
-  it("keeps one the judge confidently calls compatible", async () => {
-    state.files[STANDARDS] = file("- Old.")
-    state.answers = { "standard-1": yes, "standard-1.contradicts-1": no }
-    await learnStandards([answer("A", "New.")])
-    expect(kept()).toBe(file("- Old.", "- New. (re: A)"))
-  })
-
-  it("asks no judge when standardMinP is blank", async () => {
-    state.vars.standardMinP = ""
-    await learnStandards([answer("A", "New.")])
-    expect(state.judged).toEqual([])
-    expect(state.written).toEqual({})
-  })
-
-  it("drops a replaced standard from another open conflict", async () => {
-    state.files[STANDARDS] = file(
-      "- O.",
-      "",
-      "## Undecided",
-      "",
-      "- A.",
-      "  - contradicts: O.",
-      "- B.",
-      "  - contradicts: O.",
-    )
-    // The conflict note's title hashes its new standard, "A.".
-    await learnStandards([
-      { anchor: "Standard conflict 01248e26", body: "", choice: "fix", text: "" },
-    ])
-    expect(kept()).toBe(file("- A.", "", "## Undecided", "", "- B."))
-  })
-})
-
-describe("learnStandards, from a won't-fix", () => {
-  it("replaces an old standard hand-edited in case only", async () => {
-    state.files[STANDARDS] = file(
-      "- use classes.",
-      "",
-      "## Undecided",
-      "",
-      "- A.",
-      "  - contradicts: Use classes.",
-    )
-    await learnStandards([
-      { anchor: "Standard conflict 01248e26", body: "", choice: "fix", text: "" },
-    ])
-    expect(kept()).toBe(file("- A."))
-  })
-
-  it("does not learn again what a formatter rewrote", async () => {
-    state.files[STANDARDS] = file("- Prefer _named_ exports. (re: A)")
-    await learnStandards([answer("A", "Prefer *named* exports.")])
-    expect(state.judged).toEqual([])
-  })
-})

package/src/workflows/shared/learn.ts

@@ -1,201 +0,0 @@
-import {
-  answered,
-  changesSince,
-  judge,
-  numeric,
-  read,
-  run,
-  vars,
-  writeScript,
-  type JudgeQuestion,
-} from "../../flows/index.js"
-import type { ReviewDecision } from "../../steering/index.js"
-import {
-  conflictBody,
-  conflictFor,
-  conflictTitle,
-  isConflictTitle,
-  oneLine,
-  parseStandards,
-  standardKey,
-  renderStandards,
-  STANDARDS,
-  type Conflict,
-  type Standards,
-} from "./standards.js"
-import { REVIEW } from "./steps.js"
-
-interface Candidate {
-  readonly decision: ReviewDecision
-  readonly text: string
-}
-
-const SUMMARY_MAX = 200
-
-const summary = (body: string): string => {
-  const text = oneLine(body)
-  return text.length > SUMMARY_MAX ? `${text.slice(0, SUMMARY_MAX - 1)}…` : text
-}
-
-/** The standard a won't-fix or an own answer would make; a fix states none. */
-const candidateOf = (d: ReviewDecision): Candidate[] => {
-  const anchor = oneLine(d.anchor)
-  if (d.choice === "wontfix") {
-    const why = summary(d.body)
-    return [{ decision: d, text: `Won't fix: ${anchor}${why === "" ? "" : ` — ${why}`}` }]
-  }
-  if (d.choice === "answer") return [{ decision: d, text: `${oneLine(d.text)} (re: ${anchor})` }]
-  return []
-}
-
-// By key, as everywhere else: a hand-edit to case or emphasis still names the same standard.
-const without = (list: readonly string[], drop: readonly string[]): string[] => {
-  const keys = new Set(drop.map(standardKey))
-  return list.filter((s) => !keys.has(standardKey(s)))
-}
-
-const adding = (list: readonly string[], text: string): string[] =>
-  list.some((s) => standardKey(s) === standardKey(text)) ? [...list] : [...list, text]
-
-/**
- * Keep the new one, keep the old one, or replace both with the human's own
- * wording. Another open conflict stops naming a replaced standard: the human
- * never judged it against the replacement, so keeping it must not drop that.
- */
-const resolve = (standards: Standards, d: ReviewDecision): Standards => {
-  const c = conflictFor(standards, d.anchor)
-  if (c === undefined) return standards
-  const others = standards.undecided.filter((u) => u !== c)
-  if (d.choice === "wontfix") return { decided: standards.decided, undecided: others }
-  const kept = d.choice === "fix" ? c.text : oneLine(d.text)
-  const undecided = others.map((u) => ({ text: u.text, olds: without(u.olds, c.olds) }))
-  return { decided: adding(without(standards.decided, c.olds), kept), undecided }
-}
-
-const contradicts = (i: number, id: string, other: string): JudgeQuestion => ({
-  id: `standard-${i}.contradicts-${id}`,
-  primitive: "noul",
-  instructions: `Does the "Standard:" line of evidence "standard-${i}" contradict ${other}?`,
-  criteria:
-    "yes: following one breaks the other. no: both can be followed — they are compatible or unrelated.",
-})
-
-// Each candidate against every kept standard and every candidate before it.
-const questionsFor = (i: number, anchor: string, decided: readonly string[]): JudgeQuestion[] => [
-  {
-    id: `standard-${i}`,
-    primitive: "noul",
-    instructions: `Is the human's answer to review note "${anchor}" (evidence "standard-${i}") a reusable standard for this codebase — a rule later changes and reviews should follow — rather than a call about this one note? Its "Standard:" line is the wording gtd would keep.`,
-    criteria:
-      "yes: it states a rule or preference that applies beyond this note. no: it is specific to this note, a one-off call, or unclear.",
-  },
-  ...decided.map((_, k) =>
-    contradicts(i, `${k + 1}`, `kept standard ${k + 1} (evidence "kept-${k + 1}")`),
-  ),
-  ...Array.from({ length: i - 1 }, (_, j) =>
-    contradicts(i, `new-${j + 1}`, `the "Standard:" line of evidence "standard-${j + 1}"`),
-  ),
-]
-
-const evidenceOf = (c: Candidate): string =>
-  [
-    `Note: ${c.decision.anchor}`,
-    `Reviewer's text: ${c.decision.body}`,
-    `Human's answer: ${c.decision.choice === "wontfix" ? "won't fix" : c.decision.text}`,
-    `Standard: ${c.text}`,
-  ].join("\n")
-
-/**
- * One judge rest over every candidate. Only a confident `yes` on uncut
- * evidence makes a standard; a contradiction the judge does not confidently
- * rule out goes to the human instead of overwriting what they decided before.
- * A cut kept standard leaves the round unlearned: raise `judgeBudgetBytes`.
- */
-const judged = async (
-  candidates: readonly Candidate[],
-  decided: readonly string[],
-  minP: number,
-): Promise<{ added: string[]; raised: Conflict[] }> => {
-  const { answers, truncated } = await judge("review.standards.judge", {
-    questions: candidates.flatMap((c, i) => questionsFor(i + 1, c.decision.anchor, decided)),
-    evidence: Object.fromEntries([
-      ...candidates.map((c, i) => [`standard-${i + 1}`, evidenceOf(c)]),
-      ...decided.map((s, k) => [`kept-${k + 1}`, s]),
-    ]),
-    message:
-      "Judging whether your answers are standards to keep: run `gtd judge run`, or land without a verdict, which keeps none.",
-    label: "Learning your standards",
-  })
-  const ruledOut = (i: number, id: string): boolean =>
-    answered(answers[`standard-${i}.contradicts-${id}`], "no", minP)
-  const added: { i: number; text: string }[] = []
-  const raised: Conflict[] = []
-  candidates.forEach((c, n) => {
-    const i = n + 1
-    if (truncated.includes(`standard-${i}`)) return
-    if (decided.some((_, k) => truncated.includes(`kept-${k + 1}`))) return
-    if (!answered(answers[`standard-${i}`], "yes", minP)) return
-    const olds = [
-      ...decided.filter((_, k) => !ruledOut(i, `${k + 1}`)),
-      ...added.filter((a) => !ruledOut(i, `new-${a.i}`)).map((a) => a.text),
-    ]
-    if (olds.length === 0) added.push({ i, text: c.text })
-    else raised.push({ text: c.text, olds })
-  })
-  return { added: added.map((a) => a.text), raised }
-}
-
-/**
- * Settles every answer to a standard conflict, then learns standards from
- * the won't-fix ticks and own answers: kept in `.gtd/STANDARDS.md`, a
- * contradicting one as a new conflict note in `.gtd/REVIEW.md`.
- */
-export const learnStandards = async (decisions: readonly ReviewDecision[]): Promise<void> => {
-  const before = parseStandards(read(STANDARDS) ?? "")
-  const rest = decisions.filter((d) => !isConflictTitle(d.anchor))
-  const settled = decisions.filter((d) => isConflictTitle(d.anchor)).reduce(resolve, before)
-  const known = new Set(
-    [...settled.decided, ...settled.undecided.map((c) => c.text)].map(standardKey),
-  )
-  const candidates = rest.flatMap(candidateOf).filter((c) => {
-    const key = standardKey(c.text)
-    if (known.has(key)) return false
-    known.add(key)
-    return true
-  })
-  // Blank keeps none, so there is nothing to ask.
-  const minP = numeric(vars.standardMinP, Infinity)
-  const { added, raised } =
-    candidates.length === 0 || !Number.isFinite(minP)
-      ? { added: [], raised: [] }
-      : await judged(candidates, settled.decided, minP)
-  const after: Standards = {
-    decided: [...settled.decided, ...added],
-    undecided: [...settled.undecided, ...raised],
-  }
-  if (renderStandards(after) !== renderStandards(before)) {
-    await run("review.standards.recording", writeScript(STANDARDS, renderStandards(after)), {
-      label: "Recording your standards",
-    })
-  }
-  if (raised.length > 0) {
-    const chunks = raised.map((c) => `## ${conflictTitle(c)}\n\n${conflictBody(c)}`)
-    await run(
-      "review.standards.raising",
-      writeScript(REVIEW, `${(read(REVIEW) ?? "").trimEnd()}\n\n${chunks.join("\n\n")}\n`),
-      { label: "Asking about a contradicting standard", file: REVIEW },
-    )
-  }
-}
-
-export const settlesStandard = (d: ReviewDecision): boolean => isConflictTitle(d.anchor)
-
-export const standardsPending = (): boolean =>
-  parseStandards(read(STANDARDS) ?? "").undecided.length > 0
-
-export const standardsAddedSince = (base: string): readonly string[] => {
-  const change = changesSince(base).get(STANDARDS)
-  if (change === undefined) return []
-  const was = new Set(parseStandards(change.before ?? "").decided)
-  return parseStandards(change.after ?? "").decided.filter((s) => !was.has(s))
-}