@pmelab/gtd 41.0.0 → 43.0.0

package/package.json

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

package/src/cli/Cli.test.ts

@@ -171,7 +171,8 @@ describe("parseArgv — scope", () => {
   it("--var without --workflow is rejected", () => {
     const plan = parseArgv(["node", "gtd.js", "land", "--var", "a=1"])
     expect(plan.kind).toBe("usage")
-    if (plan.kind === "usage") expect(plan.message).toBe("gtd: --var requires --workflow")
+    if (plan.kind === "usage")
+      expect(plan.message).toBe("gtd: --var requires --workflow (or `gtd history judges`)")
   })
 
   it("--cost with --workflow is rejected (landing and starting are different verbs)", () => {
@@ -1027,6 +1028,34 @@ describe("parseArgv — gtd history", () => {
     expect(parse("history", "metrics", "a", "feat/b")).toMatchObject({
       command: { kind: "historyMetrics", refs: ["a", "feat/b"] },
     })
+    expect(parse("history", "judges", "a", "--var", "qualityTriageMinP=0.9")).toMatchObject({
+      command: {
+        kind: "historyJudges",
+        refs: ["a"],
+        vars: { qualityTriageMinP: "0.9" },
+        jsonl: false,
+      },
+    })
+    expect(parse("history", "judges", "--jsonl")).toMatchObject({
+      command: { kind: "historyJudges", refs: [], vars: {}, jsonl: true },
+    })
+  })
+
+  it("judges takes only judge thresholds as --var, and --jsonl alone", () => {
+    expect(usage(parse("history", "judges", "--var", "reviewBase=main"))).toContain(
+      "no judge threshold",
+    )
+    expect(usage(parse("history", "judges", "--var", "toString=0.9"))).toContain(
+      "no judge threshold",
+    )
+    expect(usage(parse("history", "judges", "--var", "qualityTriageMinP=0,9"))).toContain(
+      "must be a number",
+    )
+    expect(usage(parse("history", "judges", "--jsonl", "--json"))).toContain("mutually exclusive")
+    expect(usage(parse("history", "judges", "--jsonl", "--var", "qualityTriageMinP=1"))).toContain(
+      "mutually exclusive",
+    )
+    expect(usage(parse("history", "metrics", "--jsonl"))).toContain("only valid for")
   })
 
   it("bare history and an unknown subcommand are usage errors naming list, show, metrics, fetch", () => {
@@ -1036,6 +1065,7 @@ describe("parseArgv — gtd history", () => {
       expect(message).toContain("show")
       expect(message).toContain("fetch")
       expect(message).toContain("metrics")
+      expect(message).toContain("judges")
     }
   })
 
@@ -1063,6 +1093,7 @@ describe("parseArgv — gtd history", () => {
     expect(help).toContain("history show <ref>")
     expect(help).toContain("history fetch [remote]")
     expect(help).toContain("history metrics [ref...]")
+    expect(help).toContain("history judges [ref...]")
   })
 })
 
@@ -1148,6 +1179,7 @@ describe("standaloneKinds / needsOf", () => {
       "historyList",
       "historyShow",
       "historyMetrics",
+      "historyJudges",
       "historyFetch",
     ] as const) {
       expect(needsOf(kind)).toBe("state")

package/src/cli/Cli.ts

@@ -35,6 +35,7 @@ import {
   type JsonMode,
 } from "./Program.js"
 import type { ToolCommands } from "./ToolCommands.js"
+import { THRESHOLDS } from "./Judges.js"
 import { EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR, parseContextWindow } from "../wire/index.js"
 
 export type { Command, CommandRequirements } from "./Program.js"
@@ -107,6 +108,7 @@ const JSON_KINDS: ReadonlySet<Command["kind"] | undefined> = new Set<Command["ki
   "historyList",
   "historyShow",
   "historyMetrics",
+  "historyJudges",
   "strays",
 ])
 
@@ -118,12 +120,12 @@ const FLAGS: readonly FlagRow[] = [
     scope: (kind) => JSON_KINDS.has(kind),
     decode: ([raw]) => Either.right(raw ?? ""),
     scopeError:
-      "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd slices`/`gtd history list`/`gtd history show`/`gtd history metrics`/`gtd strays` — " +
+      "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd slices`/`gtd history list`/`gtd history show`/`gtd history metrics`/`gtd history judges`/`gtd strays` — " +
       "every other command prints plain text; see `gtd install` for the driver protocol briefing",
     valueHint: "<path>",
     help: [
       "(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd slices/gtd history",
-      "list/gtd history show/gtd history metrics/gtd strays only) output structured JSON. Bare --json prints the whole document;",
+      "list/gtd history show/gtd history metrics/gtd history judges/gtd strays only) output structured JSON. Bare --json prints the whole document;",
       "--json=<path> (a dotted key path into that document, e.g.",
       "kind, content, session.id) prints just that value: a",
       "scalar raw and unquoted, a boolean as true/false, a list",
@@ -325,7 +327,7 @@ const FLAGS: readonly FlagRow[] = [
     name: "--var",
     arity: 1,
     repeatable: true,
-    scope: (kind) => kind === "start",
+    scope: (kind) => kind === "start" || kind === "historyJudges",
     decode: (raws) => {
       const vars: Record<string, string> = {}
       const seen = new Set<string>()
@@ -362,15 +364,28 @@ const FLAGS: readonly FlagRow[] = [
       }
       return Either.right(vars)
     },
-    scopeError: "gtd: --var requires --workflow",
+    scopeError: "gtd: --var requires --workflow (or `gtd history judges`)",
     valueHint: "<name>=<value>",
     help: [
       "(with --workflow; repeatable) pin a process setting for the",
       "new process; the name must already be declared by the",
       "workflow's defaults (environment settings are not",
-      "pinnable)",
+      "pinnable). (gtd history judges) re-decide past verdicts",
+      "under this threshold: judgeIdenticalMinP or",
+      "qualityTriageMinP",
     ],
   },
+  {
+    name: "--jsonl",
+    arity: 0,
+    repeatable: false,
+    scope: (kind) => kind === "historyJudges",
+    decode: () => Either.right(true),
+    scopeError: "gtd: --jsonl is only valid for `gtd history judges`",
+    valueHint: "",
+    help: ["(gtd history judges only) print one JSON line per verdict", "instead of the report"],
+    conflicts: ["--json", "--var"],
+  },
   {
     name: "--open-questions",
     arity: 0,
@@ -847,6 +862,23 @@ const COMMAND_ROWS: readonly CommandRow[] = [
       "} as one document; writes nothing",
     ],
   },
+  {
+    token: "history judges",
+    kind: "historyJudges",
+    arity: { name: "ref", many: true },
+    details: [
+      "Calibrate the judges of the kept processes from their",
+      "recorded Gtd-Judge verdicts: per judge (retry, triage, clear)",
+      "and p bucket, how many verdicts later events overturned.",
+      "--var <name>=<value> re-decides every past verdict under",
+      "another threshold and prints what would have changed;",
+      "--jsonl prints one { process, judge, commit, step, question,",
+      "state, answer, p, outcome } line per verdict instead. <ref>",
+      "is read as by history metrics. Never replays and asks no",
+      "model. --json prints { processes, total, whatIf }; writes",
+      "nothing",
+    ],
+  },
   {
     token: "history fetch",
     kind: "historyFetch",
@@ -1163,7 +1195,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
 
   if (isHistory && row === undefined) {
     return usagePlan(
-      "gtd history: expected a subcommand — list, show <ref>, metrics [ref...] or fetch [remote]",
+      "gtd history: expected a subcommand — list, show <ref>, metrics [ref...], judges [ref...] or fetch [remote]",
       jsonSeen,
     )
   }
@@ -1268,6 +1300,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
     readonly "--soft"?: number
     readonly "--hard"?: number
     readonly "--window"?: number
+    readonly "--jsonl"?: boolean
   }
 
   // `present.has("--json")` alone can't distinguish bare `--json` (no value
@@ -1415,6 +1448,37 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
     }
   }
 
+  if (kind === "historyJudges") {
+    const vars = bag["--var"] ?? {}
+    const unknown = Object.keys(vars).find((name) => !Object.hasOwn(THRESHOLDS, name))
+    if (unknown !== undefined) {
+      return usagePlan(
+        `gtd history judges: --var ${unknown} is no judge threshold — use ${Object.keys(THRESHOLDS).join(" or ")}`,
+        jsonSeen,
+      )
+    }
+    const nan = Object.entries(vars).find(
+      ([, value]) => value.trim() === "" || !Number.isFinite(Number(value)),
+    )
+    if (nan !== undefined) {
+      return usagePlan(
+        `gtd history judges: --var ${nan[0]} must be a number — got "${nan[1]}"`,
+        jsonSeen,
+      )
+    }
+    return {
+      kind: "command",
+      command: {
+        kind: "historyJudges",
+        refs: restPositionals,
+        vars,
+        jsonl: bag["--jsonl"] ?? false,
+      },
+      json,
+      verbose,
+    }
+  }
+
   if (kind === "historyFetch") {
     return {
       kind: "command",

package/src/cli/History.ts

@@ -73,6 +73,21 @@ export const resolveHistoryRef = (
   return Effect.fail(new Error(`gtd history: no history ref matches "${arg}"`))
 }
 
+/** Every kept process, or those `refs` name — a branch name meaning every process kept from it, not just its newest. */
+export const selectHistoryEntries = (
+  refs: readonly string[],
+): Effect.Effect<readonly HistoryEntry[], Error, GitService> =>
+  Effect.gen(function* () {
+    const entries = yield* historyEntries
+    if (refs.length === 0) return entries
+    const chosen = (yield* Effect.forEach(refs, (ref) =>
+      resolveHistoryRef(ref, entries).pipe(
+        Effect.map((hit) => (hit.branch === ref ? entries.filter((e) => e.branch === ref) : [hit])),
+      ),
+    )).flat()
+    return chosen.filter((e, i) => chosen.findIndex((o) => o.ref === e.ref) === i)
+  })
+
 const seven = (hash: string): string => hash.slice(0, 7)
 
 export const runHistoryListCommand = (

package/src/cli/Judges.test.ts

@@ -0,0 +1,373 @@
+import { describe, expect, it } from "vitest"
+import {
+  calibrate,
+  criteriaChanged,
+  findingsOf,
+  processJudgments,
+  whatIf,
+  type JudgeCommit,
+  type Judgment,
+} from "./Judges.js"
+
+let n = 0
+const c = (
+  subject: string,
+  facts: Omit<JudgeCommit, "hash" | "message"> & { verdicts?: readonly object[] } = {},
+): JudgeCommit => {
+  const { verdicts = [], ...rest } = facts
+  const trailers = verdicts.map((v) => `Gtd-Judge: ${JSON.stringify(v)}`).join("\n")
+  return {
+    hash: `c${++n}`,
+    message: trailers === "" ? subject : `${subject}\n\n${trailers}`,
+    ...rest,
+  }
+}
+
+const identical = (p = 0.9) => ({ verdicts: [{ id: "verdict", answer: "identical", p }] })
+
+describe("processJudgments — retry", () => {
+  const red = (subject: string, report: string) => c(subject, { feedback: report })
+
+  it("overturns identical when the next fix turn's check goes green", () => {
+    const [j] = processJudgments([
+      red("gtd(check): build.health.check → build.fix", "1 failing"),
+      c("gtd(agent): build.fix → build.health.check"),
+      red("gtd(check): build.health.check → build.health.judge", "1 failing again"),
+      c("gtd(judge): build.health.judge → build.health.recheck", identical()),
+      red("gtd(check): build.health.recheck → build.health.describe", "still"),
+      c("gtd(agent): build.health.describe → build.health.stop"),
+      c("gtd(human): build.health.stop → build.fix"),
+      c("gtd(agent): build.fix → build.health.check"),
+      c("gtd(check): build.health.check → build.quality"),
+    ])
+    expect(j).toMatchObject({
+      judge: "retry",
+      step: "build.health.judge",
+      question: "verdict",
+      outcome: "overturned",
+      state: { previous: "1 failing", current: "1 failing again" },
+    })
+  })
+
+  it("holds identical when that check stays red", () => {
+    const [j] = processJudgments([
+      red("gtd(check): health.check → fix", "x"),
+      red("gtd(check): health.check → health.judge", "x"),
+      c("gtd(judge): health.judge → health.recheck", identical()),
+      red("gtd(check): health.recheck → health.describe", "x"),
+      c("gtd(agent): fix → health.check"),
+      red("gtd(check): health.check → health.judge", "x"),
+    ])
+    expect(j?.outcome).toBe("held")
+  })
+
+  it("has no outcome when a person edited code before the deciding check", () => {
+    const [j] = processJudgments([
+      c("gtd(judge): build.health.judge → build.health.recheck", identical()),
+      red("gtd(check): build.health.recheck → build.health.describe", "x"),
+      c("gtd(human): build.health.stop → build.fix", { code: true }),
+      c("gtd(agent): build.fix → build.health.check"),
+      c("gtd(check): build.health.check → idle"),
+    ])
+    expect(j?.outcome).toBeNull()
+  })
+
+  it("hands an empty report on as the flow does, and scores none of it", () => {
+    const js = processJudgments([
+      red("gtd(check): health.check → fix", " "),
+      red("gtd(check): health.check → health.judge", "x"),
+      c("gtd(judge): health.judge → fix", identical()),
+      c("gtd(agent): fix → health.check"),
+      c("gtd(check): health.check → idle"),
+    ])
+    expect(js[0]).toMatchObject({ state: { tailsNotComparable: "true" }, outcome: null })
+    const w = whatIf(
+      [{ vars: { judgeIdenticalMinP: "0.99" }, judgments: js }],
+      "judgeIdenticalMinP",
+      "0.5",
+    )
+    expect(w.changes).toEqual([])
+  })
+
+  it("has no outcome when history shows fewer than two reports", () => {
+    const [j] = processJudgments([
+      c("gtd(judge): build.health.judge → build.fix", identical()),
+      c("gtd(agent): build.fix → build.health.check"),
+      c("gtd(check): build.health.check → idle"),
+    ])
+    expect(j?.outcome).toBeNull()
+  })
+
+  it("has no outcome when the re-check passes before any fix, or for another answer", () => {
+    const js = processJudgments([
+      c("gtd(judge): build.health.judge → build.health.recheck", identical()),
+      c("gtd(check): build.health.recheck → build.quality"),
+      c("gtd(judge): build.health.judge → build.fix", {
+        verdicts: [{ id: "verdict", answer: "progress", p: 0.9 }],
+      }),
+      c("gtd(agent): build.fix → build.health.check"),
+      c("gtd(check): build.health.check → idle"),
+    ])
+    expect(js.map((j) => j.outcome)).toEqual([null, null])
+  })
+})
+
+describe("processJudgments — triage", () => {
+  const findings = findingsOf("## a stray export\n\nexport it\n\n## a missing test\n\nadd one\n")
+  const composed = [
+    "# Review: abc",
+    "",
+    "## Fixed automatically",
+    "",
+    "- a stray export (abc1234)",
+    "",
+    "## Dropped as noise",
+    "",
+    "- a missing test (p=0.85)",
+    "",
+  ].join("\n")
+  const triage = c("gtd(judge): build.quality.triage → build.quality.sorting", {
+    findings,
+    verdicts: [
+      { id: "Q1", answer: "mechanical", p: 0.95 },
+      { id: "Q2", answer: "noise", p: 0.85 },
+    ],
+  })
+
+  it("overturns a dropped finding the human wrote back on, holds the untouched fix", () => {
+    const js = processJudgments([
+      triage,
+      c("gtd(check): build.review.composing → build.review.await", {
+        review: { before: "", after: composed },
+      }),
+      c("gtd(human): build.review.await → build.review.triage", {
+        review: {
+          before: composed,
+          after: composed.replace("(p=0.85)", "(p=0.85) — it is not noise"),
+        },
+      }),
+    ])
+    expect(js.map((j) => [j.question, j.outcome])).toEqual([
+      ["Q1", "held"],
+      ["Q2", "overturned"],
+    ])
+    expect(js[1]?.state).toEqual({ Q2: "## a missing test\n\nadd one" })
+  })
+
+  it("credits a written-back line to its own finding only", () => {
+    const listed = [
+      "# Review",
+      "",
+      "## Dropped as noise",
+      "",
+      "- a test (p=0.8)",
+      "- a test for x (p=0.8)",
+      "",
+    ].join("\n")
+    const js = processJudgments([
+      c("gtd(judge): build.quality.triage → build.quality.sorting", {
+        findings: findingsOf("## a test\n\n## a test for x\n"),
+        verdicts: [
+          { id: "Q1", answer: "noise", p: 0.8 },
+          { id: "Q2", answer: "noise", p: 0.8 },
+        ],
+      }),
+      c("gtd(human): build.review.await → build.review.triage", {
+        review: { before: listed, after: listed.replace("x (p=0.8)", "x (p=0.8) — needed") },
+      }),
+    ])
+    expect(js.map((j) => j.outcome)).toEqual(["held", "overturned"])
+  })
+
+  it("overturns a note written under the line, or a rewrite of it", () => {
+    const listed = "# R\n\n## Dropped as noise\n\n- a test (p=0.8)\n- b (p=0.8)\n"
+    const triaged = (after: string) =>
+      processJudgments([
+        c("gtd(judge): build.quality.triage → build.quality.sorting", {
+          findings: findingsOf("## a test\n\n## b\n"),
+          verdicts: [
+            { id: "Q1", answer: "noise", p: 0.8 },
+            { id: "Q2", answer: "noise", p: 0.8 },
+          ],
+        }),
+        c("gtd(human): build.review.await → build.review.triage", {
+          review: { before: listed, after },
+        }),
+      ]).map((j) => j.outcome)
+    expect(triaged(listed.replace("(p=0.8)\n", "(p=0.8)\n  we need it\n"))).toEqual([
+      "overturned",
+      "held",
+    ])
+    expect(triaged(listed.replace("- a test (p=0.8)", "- a test: not noise"))).toEqual([
+      "overturned",
+      "held",
+    ])
+  })
+
+  it("never reads a longer title's edited line as a rewrite of a deleted shorter one", () => {
+    const listed = "# R\n\n## Dropped as noise\n\n- a test (p=0.8)\n- a test for x (p=0.8)\n"
+    const js = processJudgments([
+      c("gtd(judge): build.quality.triage → build.quality.sorting", {
+        findings: findingsOf("## a test\n\n## a test for x\n"),
+        verdicts: [
+          { id: "Q1", answer: "noise", p: 0.8 },
+          { id: "Q2", answer: "noise", p: 0.8 },
+        ],
+      }),
+      c("gtd(human): build.review.await → build.review.triage", {
+        review: {
+          before: listed,
+          after: "# R\n\n## Dropped as noise\n\n- a test for x (p=0.8) — needed\n",
+        },
+      }),
+    ])
+    expect(js.map((j) => j.outcome)).toEqual(["held", "overturned"])
+  })
+
+  it("scores only a finding the review listed as fixed or dropped", () => {
+    const js = processJudgments([
+      c("gtd(judge): build.quality.triage → build.quality.sorting", {
+        findings,
+        verdicts: [
+          { id: "Q1", answer: "mechanical", p: 0.95 },
+          { id: "Q2", answer: "design", p: 0.95 },
+        ],
+      }),
+      c("gtd(human): build.review.await → idle", {
+        review: { before: "# Review\n\n## a stray export\n\nleft\n", after: "# Review\n" },
+      }),
+    ])
+    expect(js.map((j) => j.outcome)).toEqual([null, null])
+  })
+})
+
+describe("processJudgments — clear", () => {
+  const clear = (answer: unknown) =>
+    c("gtd(judge): design.clear → design.normalise", {
+      sketch: "# TODO\n",
+      verdicts: [{ id: "clear", answer, p: 0.9 }],
+    })
+
+  it("overturns a skip a later design gate edited the criteria after", () => {
+    const [j] = processJudgments([
+      clear("yes"),
+      c("gtd(agent): design.triage → design.answer-product-questions", { criteriaChanged: true }),
+      c("gtd(human): design.answer-product-questions → design.triage", { criteriaChanged: true }),
+    ])
+    expect(j).toMatchObject({
+      judge: "clear",
+      outcome: "overturned",
+      state: { sketch: "# TODO\n" },
+    })
+  })
+
+  it("holds a skip no gate edited after, reading a boolean verdict as yes", () => {
+    const [j] = processJudgments([
+      clear(true),
+      c("gtd(agent): design.triage → design.answer-product-questions", { criteriaChanged: true }),
+      c("gtd(human): build.review.await → idle"),
+    ])
+    expect(j?.outcome).toBe("held")
+  })
+
+  it("has no outcome for a no, or a yes below the skip floor", () => {
+    expect(processJudgments([clear("no")])[0]?.outcome).toBeNull()
+    const low = c("gtd(judge): design.clear → design.triage", {
+      verdicts: [{ id: "clear", answer: "yes", p: 0.75 }],
+    })
+    expect(processJudgments([low])[0]?.outcome).toBeNull()
+    // A cut sketch: a confident yes the flow did not act on.
+    const cut = c("gtd(judge): design.clear → design.triage", {
+      verdicts: [{ id: "clear", answer: "yes", p: 0.9 }],
+    })
+    expect(processJudgments([cut])[0]?.outcome).toBeNull()
+  })
+})
+
+describe("findingsOf", () => {
+  it("numbers stray prose first, as the quality lap does", () => {
+    expect(findingsOf("just prose\n\n## one\n\nbody\n").map((f) => [f.id, f.title])).toEqual([
+      ["Q1", "Quality findings"],
+      ["Q2", "one"],
+    ])
+  })
+})
+
+describe("criteriaChanged", () => {
+  const doc = (items: string) => `# R\n\n## Acceptance Criteria\n\n${items}\n\n## Notes\n\nx\n`
+
+  it("ignores rewrapping and edits outside the criteria", () => {
+    expect(criteriaChanged(doc("- AC-1: a b"), doc("- AC-1: a\n  b").replace("x", "y"))).toBe(false)
+    expect(criteriaChanged(doc("- AC-1: a"), doc("- AC-1: a\n- AC-2: b"))).toBe(true)
+    expect(criteriaChanged(undefined, doc("- AC-1: a"))).toBe(true)
+    expect(criteriaChanged(doc("- AC-1: a"), doc("Settled.\n\n- AC-1: a"))).toBe(false)
+  })
+})
+
+const judgment = (over: Partial<Judgment>): Judgment => ({
+  judge: "triage",
+  commit: "c",
+  step: "build.quality.triage",
+  question: "Q1",
+  state: {},
+  answer: "noise",
+  p: 0.8,
+  outcome: null,
+  ...over,
+})
+
+describe("calibrate", () => {
+  it("buckets scored verdicts by tenths of p, 1 in the top bucket", () => {
+    const { triage, retry } = calibrate([
+      judgment({ p: 0.85, outcome: "overturned" }),
+      judgment({ p: 0.8, outcome: "held" }),
+      judgment({ p: 1, outcome: "held" }),
+      judgment({ p: 0.5 }),
+    ])
+    expect(triage).toEqual({
+      verdicts: 4,
+      scored: 3,
+      overturned: 1,
+      buckets: [
+        { p: 0.8, scored: 2, overturned: 1, rate: 0.5 },
+        { p: 0.9, scored: 1, overturned: 0, rate: 0 },
+      ],
+    })
+    expect(retry).toEqual({ verdicts: 0, scored: 0, overturned: 0, buckets: [] })
+  })
+})
+
+describe("whatIf", () => {
+  it("re-decides each verdict under its process's recorded threshold and the new one", () => {
+    const w = whatIf(
+      [
+        {
+          vars: { qualityTriageMinP: "0.7" },
+          judgments: [
+            judgment({ p: 0.85, outcome: "overturned" }),
+            judgment({ p: 0.8 }),
+            judgment({ answer: "mechanical", p: 0.95 }),
+            judgment({ judge: "retry", answer: "identical", p: 0.8 }),
+          ],
+        },
+      ],
+      "qualityTriageMinP",
+      "0.9",
+    )
+    expect(w).toEqual({
+      var: "qualityTriageMinP",
+      value: "0.9",
+      judge: "triage",
+      changes: [{ from: "noise", to: "design", count: 2, overturned: 1 }],
+    })
+  })
+
+  it("leaves out a process that recorded no such threshold", () => {
+    const w = whatIf(
+      [{ vars: {}, judgments: [judgment({ judge: "retry", answer: "identical", p: 0.8 })] }],
+      "judgeIdenticalMinP",
+      "0.7",
+    )
+    expect(w.changes).toEqual([])
+  })
+})