@pmelab/gtd 63.0.0 → 64.1.0

package/dist/steering.mjs

@@ -1,2 +1,2 @@
-import { A as parseThreads, C as FREE_TEXT_PLACEHOLDER, D as findingEntries, E as NOISE_HEADING, N as formatFinding, O as openThreadFindings, S as unansweredNotes, T as FIX_BOX, _ as reviewChunks, a as sections, b as reviewRisks, c as openThreads, d as freeFormFormat, f as applySteeringEdits, g as REVIEW_SECTIONS, h as ANSWER_WONT_FIX, i as sectionBodies, j as parseThreadsWithFindings, k as parseFootnotes, l as steeringFormatFor, m as ANSWER_LEAD, n as stripCodeThreads, o as threads, p as ANSWER_FIX, r as openQuestions, t as parseCodeThreads, v as reviewDecisions, w as isAnswered, x as reviewSections, y as reviewNotes } from "./chunks/steering-DF_BMadH.mjs";
-export { ANSWER_FIX, ANSWER_LEAD, ANSWER_WONT_FIX, FIX_BOX, FREE_TEXT_PLACEHOLDER, NOISE_HEADING, REVIEW_SECTIONS, applySteeringEdits, findingEntries, formatFinding, freeFormFormat, isAnswered, openQuestions, openThreadFindings, openThreads, parseCodeThreads, parseFootnotes, parseThreads, parseThreadsWithFindings, reviewChunks, reviewDecisions, reviewNotes, reviewRisks, reviewSections, sectionBodies, sections, steeringFormatFor, stripCodeThreads, threads, unansweredNotes };
+import { A as findingEntries, C as reviewRisks, D as isAnswered, E as FREE_TEXT_PLACEHOLDER, I as formatFinding, M as parseFootnotes, N as parseThreads, O as FIX_BOX, P as parseThreadsWithFindings, S as reviewNotes, T as unansweredNotes, _ as ANSWER_LEAD, a as sections, b as reviewChunks, c as openThreads, f as listFormat, g as ANSWER_FIX, h as applySteeringEdits, i as sectionBodies, j as openThreadFindings, k as NOISE_HEADING, l as steeringFormatFor, m as freeFormFormat, n as stripCodeThreads, o as threads, p as sectionFormat, r as openQuestions, t as parseCodeThreads, v as ANSWER_WONT_FIX, w as reviewSections, x as reviewDecisions, y as REVIEW_SECTIONS } from "./chunks/steering-Cem5i6Xl.mjs";
+export { ANSWER_FIX, ANSWER_LEAD, ANSWER_WONT_FIX, FIX_BOX, FREE_TEXT_PLACEHOLDER, NOISE_HEADING, REVIEW_SECTIONS, applySteeringEdits, findingEntries, formatFinding, freeFormFormat, isAnswered, listFormat, openQuestions, openThreadFindings, openThreads, parseCodeThreads, parseFootnotes, parseThreads, parseThreadsWithFindings, reviewChunks, reviewDecisions, reviewNotes, reviewRisks, reviewSections, sectionBodies, sectionFormat, sections, steeringFormatFor, stripCodeThreads, threads, unansweredNotes };

package/dist/testkit/gherkin.mjs

@@ -1,6 +1,6 @@
-import { n as runsItsScript, r as testRepo } from "../chunks/testkit-DwypA7cH.mjs";
-import { resolve } from "node:path";
+import { n as runsItsScript, r as testRepo } from "../chunks/testkit-DfWZQCWQ.mjs";
 import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
 import { After, AfterAll, Given, QuickPickleWorld, Then, When, setWorldConstructor } from "quickpickle";
 import assert from "node:assert";
 //#region src/gherkin/messages.ts

package/dist/testkit.mjs

@@ -1,3 +1,3 @@
-import { H as installContext } from "./chunks/flows-DENt0uWV.mjs";
-import { a as verdictWhen, i as verdict, n as runsItsScript, o as whenPrompted, r as testRepo, t as inTurn } from "./chunks/testkit-DwypA7cH.mjs";
+import { H as installContext } from "./chunks/flows-B7ZRCe-B.mjs";
+import { a as verdictWhen, i as verdict, n as runsItsScript, o as whenPrompted, r as testRepo, t as inTurn } from "./chunks/testkit-DfWZQCWQ.mjs";
 export { inTurn, installContext, runsItsScript, testRepo, verdict, verdictWhen, whenPrompted };

package/dist/workflow-kit.mjs

@@ -1,5 +1,5 @@
-import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-DENt0uWV.mjs";
-import { A as parseThreads, S as unansweredNotes, b as reviewRisks, n as stripCodeThreads, v as reviewDecisions, y as reviewNotes } from "./chunks/steering-DF_BMadH.mjs";
+import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-B7ZRCe-B.mjs";
+import { C as reviewRisks, N as parseThreads, S as reviewNotes, T as unansweredNotes, n as stripCodeThreads, x as reviewDecisions } from "./chunks/steering-Cem5i6Xl.mjs";
 //#region src/workflow-kit/health.ts
 /** Hand a red suite that repeated attempts could not fix to a person, until `limit` rounds are spent. */
 const escalation = async (count, steps) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "63.0.0",
+  "version": "64.1.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

@@ -25,7 +25,7 @@ import {
 import { EXIT_CODES, EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR } from "../wire/index.js"
 import { Host } from "../platform/index.js"
 import { type CommandRequirements } from "./Cli.js"
-import { InMemRepo, makeCapturingCliIo, testLayers } from "../twins/index.js"
+import { InMemRepo, inMemoryHost, makeCapturingCliIo, testLayers } from "../twins/index.js"
 
 const FLAG_NAMES = [
   "--json",
@@ -1342,13 +1342,10 @@ describe("runCli — a garbled GTD_FLAG_* value", () => {
   it("exits 1 naming the variable", async () => {
     const { io, captured } = capturingIo(
       () =>
-        Layer.succeed(Host, {
-          root: "/",
-          home: "/",
-          scratchDir: "/",
-          realPath: (p: string) => Effect.succeed(p),
-          env: { GTD_FLAG_BETA: "ture" },
-        }) as unknown as Layer.Layer<CommandRequirements>,
+        Layer.succeed(
+          Host,
+          inMemoryHost("/", "/", { GTD_FLAG_BETA: "ture" }),
+        ) as unknown as Layer.Layer<CommandRequirements>,
     )
     await Effect.runPromise(
       runCli(["node", "gtd.js", "next"], {

package/src/cli/Cli.ts

@@ -9,6 +9,8 @@ import {
   Workspace,
   CommandRunner,
   NodeServices,
+  nodeStdio,
+  type Stdio,
 } from "../platform/index.js"
 import {
   flagSettings,
@@ -323,6 +325,16 @@ const FLAGS: readonly FlagRow[] = [
     valueHint: "",
     help: "Instead of <mode>'s findings, list the open threads in <file>; exits 1 when any are open. Alone, lists the open code-comment threads in the files the current process changed",
   },
+  {
+    name: "--spec",
+    arity: 1,
+    repeatable: false,
+    scope: (kind) => kind === "check",
+    decode: ([raw]) => Result.succeed(raw ?? ""),
+    scopeError: "gtd: --spec is only valid for `gtd check`",
+    valueHint: "<json>",
+    help: "Check against the declared format this spec describes, named <mode>, instead of a built-in one; validation scripts pass it for a step whose mode is a declared format",
+  },
   {
     name: "--verbose",
     arity: 0,
@@ -585,7 +597,7 @@ The fixed answerer reads --answers and leaves out the questions it does not cove
     arity: { names: ["mode", "file"] },
     group: "Driver plumbing",
     summary: "Check a steering file's format",
-    details: `Run the steering format <mode> (qa, review or findings) over <file> and print each finding on a line of its own; exits 1 when there are any, or when <file> does not exist. An unknown <mode> is a usage error (exit 2). Reads no workflow and runs from any directory — emitted validation scripts call it.`,
+    details: `Run the steering format <mode> (qa, review or findings, or the declared format --spec describes) over <file> and print each finding on a line of its own; exits 1 when there are any, or when <file> does not exist. An unknown <mode> is a usage error (exit 2). Reads no workflow and runs from any directory — emitted validation scripts call it.`,
   },
   {
     token: "uncheck",
@@ -1122,6 +1134,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
     readonly "--threshold"?: Readonly<Record<string, string>>
     readonly "--open-questions"?: boolean
     readonly "--open-threads"?: boolean
+    readonly "--spec"?: string
     readonly "--host"?: string
     readonly "--self-signed"?: boolean
     readonly "--dev"?: boolean
@@ -1197,6 +1210,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
           ? { openQuestions: bag["--open-questions"] }
           : {}),
         ...(bag["--open-threads"] !== undefined ? { openThreads: bag["--open-threads"] } : {}),
+        ...(bag["--spec"] !== undefined ? { spec: bag["--spec"] } : {}),
       },
       json,
       verbose,
@@ -1334,10 +1348,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
 // runCli
 // ---------------------------------------------------------------------------
 
-export interface CliIo {
-  readonly stdout: (chunk: string | Uint8Array) => void
-  readonly stderr: (chunk: string) => void
-  readonly exit: (code: number) => void
+export interface CliIo extends Stdio {
   /**
    * Deferred thunk — a layer is built only for a resolved `Command`, never
    * for `--version`/`--help`/a usage error. `verbose` (`--verbose`/`-v`,
@@ -1349,13 +1360,10 @@ export interface CliIo {
   readonly flags?: readonly FlagDeclaration[]
 }
 
-// The one write-to-stderr primitive nodeCliIo uses for both `stderr` (errors)
-// and `layers`'s `Narrator` (narration) — same sink, so a real invocation's
-// narration and its remediation interleave on the same fd exactly as
-// written.
-const writeStderr = (chunk: string): void => {
-  process.stderr.write(chunk)
-}
+// `nodeCliIo` hands this one sink to both `stderr` (errors) and `layers`'s
+// `Narrator` (narration), so a real invocation's narration and its
+// remediation interleave on the same fd exactly as written.
+const stdio = nodeStdio()
 
 export type LiveToolCommands = Layer.Layer<
   ToolCommands,
@@ -1364,21 +1372,7 @@ export type LiveToolCommands = Layer.Layer<
 >
 
 export const nodeCliIo = (tools: LiveToolCommands): CliIo => ({
-  // `process.stdout.write` is asynchronous whenever stdout is a pipe or
-  // socket — passing a completion callback (and never force-closing, see
-  // `exit` below) keeps a queued remainder from being discarded, so a large
-  // artifact still reaches a slow reader even after a non-zero exit.
-  stdout: (chunk) => {
-    process.stdout.write(chunk, () => {})
-  },
-  stderr: writeStderr,
-  exit: (code) => {
-    // Never `process.exit(code)`: that tears the process down out from under
-    // an undrained `stdout.write` above and truncates the artifact mid-pipe.
-    // Setting `exitCode` lets the event loop run to completion — draining
-    // any queued write — before Node exits gracefully with this code.
-    process.exitCode = code
-  },
+  ...stdio,
   // A Layer is a lazy description, not a running service — building this
   // object touches no filesystem/git; only `Effect.provide` running the
   // result does. `runCli` calls this thunk exactly when `plan.kind ===
@@ -1394,7 +1388,7 @@ export const nodeCliIo = (tools: LiveToolCommands): CliIo => ({
           ConfigDiscovery.Live,
           EngineCore.Live,
           Workspace.Live,
-          Narrator.layer(writeStderr, verbose),
+          Narrator.layer(stdio.stderr, verbose),
           CommandRunner.Live,
         ).pipe(
           Layer.provideMerge(GitService.Live),

package/src/cli/Output.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import { Effect, type Path } from "effect"
 import { CommandRunner, GitService, Host, Narrator, Workspace } from "../platform/index.js"
 import {
   renderScriptJson,
@@ -70,6 +70,7 @@ export type CommandRequirements =
   | EngineCore
   | Workspace
   | Host
+  | Path.Path
   | Narrator
   | CommandRunner
   | ToolCommands

package/src/cli/Program.test.ts

@@ -5,8 +5,7 @@
  */
 
 import { Cause, Context, Effect, Exit } from "effect"
-import { PassThrough } from "node:stream"
-import { afterEach, describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
 // `gtd ui`'s bind-host lookup reads the real `os.networkInterfaces()` — a host
 // on a tailnet would make the "no Tailscale interface" refusal below fail.
@@ -24,6 +23,8 @@ import {
   testLayers,
   applyEmittedScript,
   takePinBeat,
+  IN_MEMORY_PID,
+  IN_MEMORY_SCRATCH,
 } from "../twins/index.js"
 import {
   commitAll,
@@ -110,7 +111,7 @@ export const hotfix = workflow(
     expect(exitCode).toBe(0)
     expect(stdout).toContain(
       commitAll(
-        `gtd(human): working\n\nGtd-Workflow: hotfix\nGtd-Var: greeting=hello\nGtd-Format: 3`,
+        `gtd(human): working\n\nGtd-Workflow: hotfix\nGtd-Var: greeting=hello\nGtd-Format: 4`,
       ),
     )
     expect(repo.commitHistory()).toHaveLength(before)
@@ -197,7 +198,7 @@ export const hotfix = workflow(
     expect(applyEmittedScript(repo, new Map(), stdout).ok).toBe(true)
     expect(repo.lastCommitSubject()).toBe("gtd(human): working")
     const pin = JSON.parse((await run(repo, "next", "--json")).stdout) as Record<string, unknown>
-    expect(pin).toMatchObject({ kind: "script", state: "pin", actor: "check", pin: "add" })
+    expect(pin).toMatchObject({ kind: "script", state: "gtd:pin", actor: "check", pin: "add" })
     expect(await takePinBeat(repo, "add")).toBe(true)
     const next = JSON.parse((await run(repo, "next", "--json")).stdout) as Record<string, unknown>
     expect(next.kind).toBe("prompt")
@@ -673,7 +674,7 @@ describe("gtd validate — the mode-contradiction round-trip", () => {
     const { stdout, exitCode } = await runEnv(repo, { TMPDIR: "/fixture-scratch" }, "validate")
     expect(exitCode).toBe(0)
 
-    const samplePath = `/fixture-scratch/gtd-mode-sample-qa-${process.pid}.md`
+    const samplePath = `/fixture-scratch/gtd-mode-sample-qa-${IN_MEMORY_PID}.md`
     const roundTripIndex = stdout.indexOf(`printf '%s' `)
     const guardIndex = stdout.indexOf(`[ -f '.gtd/PLAN.md' ] || exit 0`)
     // The real format command, distinct from the round-trip's own copy
@@ -724,11 +725,11 @@ describe("gtd validate — the mode-contradiction round-trip", () => {
     expect(stdout).not.toContain("skipping")
   })
 
-  it("resolves the scratch dir from node:os's tmpdir() when TMPDIR is unset or empty", async () => {
+  it("falls back to the host's own scratch dir when TMPDIR is unset", async () => {
     const repo = await atWorking(`{ qa: { format: "my-formatter $GTD_FILE" } }`)
     const { stdout, exitCode } = await runEnv(repo, {}, "validate")
     expect(exitCode).toBe(0)
-    expect(stdout).toContain(`gtd-mode-sample-qa-${process.pid}.md`)
+    expect(stdout).toContain(`${IN_MEMORY_SCRATCH}/gtd-mode-sample-qa-${IN_MEMORY_PID}.md`)
   })
 
   it("gtd validate the COMMAND exits 0 even when the emitted SCRIPT would fail if run — gtd only prints it", async () => {
@@ -791,14 +792,14 @@ describe("gtd next — refuses when history diverges from what replay reaches",
 
 describe("a history written in a format this gtd does not read", () => {
   // The exact wording is pinned in Format.test.ts; this is the part that proves the format gate fired.
-  const FOREIGN = "is written in history format 4, but this gtd reads formats 1 to 3"
+  const FOREIGN = "is written in history format 5, but this gtd reads formats 1 to 4"
 
   /** A step commit that would also diverge, so only the format gate can explain the refusal. */
   const foreignStep = async (): Promise<InMemRepo> => {
     const repo = seed(IDLE_THEN_WORKING)
     await landTurn(repo, { "NOTE.md": "a note\n" })
     repo.writeFile("WORK.md", "done\n")
-    repo.seedCommit("gtd(agent): elsewhere → review\n\nGtd-Step: elsewhere#1\nGtd-Format: 4")
+    repo.seedCommit("gtd(agent): elsewhere → review\n\nGtd-Step: elsewhere#1\nGtd-Format: 5")
     return repo
   }
 
@@ -823,7 +824,7 @@ describe("a history written in a format this gtd does not read", () => {
   it("refuses even when a foreign subject hides the commit from the episode", async () => {
     const repo = seed(IDLE_THEN_WORKING)
     repo.writeFile("NOTE.md", "a note\n")
-    repo.seedCommit("gtd2[human] idle -> working\n\nGtd-Format: 4")
+    repo.seedCommit("gtd2[human] idle -> working\n\nGtd-Format: 5")
     for (const command of ["next", "abandon"]) {
       const { exitCode, stderr } = await run(repo, command)
       expect(exitCode).toBe(1)
@@ -834,7 +835,7 @@ describe("a history written in a format this gtd does not read", () => {
   it("a commit gtd never wrote is not read for a format, even quoting the trailer", async () => {
     const repo = seed(IDLE_THEN_WORKING)
     repo.writeFile("NOTE.md", "a note\n")
-    repo.seedCommit("feat: x\n\nGtd-Format: 4")
+    repo.seedCommit("feat: x\n\nGtd-Format: 5")
     expect((await run(repo, "next")).exitCode).toBe(0)
   })
 
@@ -842,7 +843,7 @@ describe("a history written in a format this gtd does not read", () => {
     const repo = seed(IDLE_THEN_WORKING)
     const base = repo.resolveRef("HEAD")!
     repo.writeFile("NOTE.md", "a note\n")
-    repo.seedCommit("gtd(human): idle → working\n\nGtd-Step: idle#1\nGtd-Format: 4")
+    repo.seedCommit("gtd(human): idle → working\n\nGtd-Step: idle#1\nGtd-Format: 5")
     repo.updateRef(HISTORY_REF, repo.resolveRef("HEAD")!)
     repo.hardResetTo(base)
     const { exitCode, stderr } = await run(repo, "restore")
@@ -1403,7 +1404,7 @@ export default async () => {
   it("a turn that finishes a pinned flow targets the unpin", async () => {
     const repo = await atWorking()
     repo.writeFile("REVIEW.md", "an updated review\n")
-    expect(await nextOf(repo)).toMatchObject({ target: "unpin" })
+    expect(await nextOf(repo)).toMatchObject({ target: "gtd:unpin" })
   })
 
   it("plain gtd next shows the same preview as a `Next:` line", async () => {
@@ -1495,7 +1496,7 @@ export default async () => {
     expect(script).not.toContain("git reset --mixed")
     expect(script).not.toContain("nothing to retain")
     expect(applyEmittedScript(repo, new Map(), script).ok).toBe(true)
-    expect(repo.lastCommitSubject()).toBe("gtd(check): checking → unpin")
+    expect(repo.lastCommitSubject()).toBe("gtd(check): checking → gtd:unpin")
   })
 
   it("the same rest with a pending change lands an ordinary commit too", async () => {
@@ -1544,7 +1545,7 @@ export default async () => {
     }
     expect(parsed.settled).toBe(false)
     expect(parsed.idle).toBe(false)
-    expect(parsed.state).toBe("unpin")
+    expect(parsed.state).toBe("gtd:unpin")
   })
 
   it("gtd land --json an ordinary commit reports settled:false", async () => {
@@ -1693,7 +1694,7 @@ export default async () => {
     const { exitCode, script } = await landAndApply(repo)
     expect(exitCode).toBe(0)
     expect(script).not.toContain("fmt-notes")
-    expect(repo.lastCommitSubject("HEAD~1")).toBe("gtd(agent): drafting → unpin")
+    expect(repo.lastCommitSubject("HEAD~1")).toBe("gtd(agent): drafting → gtd:unpin")
   })
 
   it("`gtd next --json`'s `validate` field carries the mode's format command", async () => {
@@ -1973,7 +1974,7 @@ export default async () => {
   it("refuses once the process has closed and HEAD rests at the initial step again", async () => {
     const repo = await atDeciding()
     await landTurn(repo)
-    expect(repo.lastCommitSubject()).toBe("gtd(check): unpin → idle")
+    expect(repo.lastCommitSubject()).toBe("gtd(check): gtd:unpin → idle")
 
     const { exitCode, stdout, stderr } = await run(repo, "base")
     expect(exitCode).toBe(1)
@@ -2186,41 +2187,32 @@ export default workflow(
     expect(first.stdout).toBe(second.stdout)
   })
 
-  let savedStdin: PropertyDescriptor | undefined
-  afterEach(() => {
-    if (savedStdin) {
-      Object.defineProperty(process, "stdin", savedStdin)
-      savedStdin = undefined
-    }
-  })
-
-  const withStdin = async <T>(content: string, fn: () => Promise<T>): Promise<T> => {
-    savedStdin = Object.getOwnPropertyDescriptor(process, "stdin")
-    const stdin = new PassThrough()
-    Object.defineProperty(process, "stdin", { value: stdin, configurable: true })
-    stdin.end(content)
-    try {
-      return await fn()
-    } finally {
-      if (savedStdin) Object.defineProperty(process, "stdin", savedStdin)
-      savedStdin = undefined
-    }
+  const runWithStdin = async (
+    stdin: string,
+    repo: InMemRepo,
+    ...args: string[]
+  ): Promise<{ readonly stdout: string; readonly stderr: string; readonly exitCode: number }> => {
+    const { io, result } = makeCapturingCliIo(repo, {}, {}, stdin)
+    await Effect.runPromise(runCli(["node", "gtd.js", ...args], io))
+    return result()
   }
 
   const VERDICT = JSON.stringify([{ id: "q1", answer: true, p: 0.97 }])
 
   it("gtd judge answer decodes a verdict on stdin against the pending question ids and succeeds", async () => {
     const repo = seededRepo()
-    const { exitCode, stdout } = await withStdin(VERDICT, () => run(repo, "judge", "answer"))
+    const { exitCode, stdout } = await runWithStdin(VERDICT, repo, "judge", "answer")
     expect(exitCode).toBe(0)
     expect(stdout.length).toBeGreaterThan(0)
   })
 
   it("gtd judge answer refuses a verdict naming a question id the pending judgment never declared, with the usage-error exit code", async () => {
     const repo = seededRepo()
-    const { exitCode, stderr } = await withStdin(
+    const { exitCode, stderr } = await runWithStdin(
       JSON.stringify([{ id: "not-a-real-question", answer: true, p: 0.97 }]),
-      () => run(repo, "judge", "answer"),
+      repo,
+      "judge",
+      "answer",
     )
     expect(exitCode).toBe(2)
     expect(stderr).toContain("does not match the pending questions")
@@ -2228,16 +2220,18 @@ export default workflow(
 
   it("gtd judge answer refuses when stdin is not valid JSON at all, with the usage-error exit code", async () => {
     const repo = seededRepo()
-    const { exitCode, stderr } = await withStdin("not json", () => run(repo, "judge", "answer"))
+    const { exitCode, stderr } = await runWithStdin("not json", repo, "judge", "answer")
     expect(exitCode).toBe(2)
     expect(stderr).toContain("stdin is not valid JSON")
   })
 
   it("gtd judge answer refuses a verdict whose p is above 1 — an unvalidated p would clear every minP", async () => {
     const repo = seededRepo()
-    const { exitCode, stderr } = await withStdin(
+    const { exitCode, stderr } = await runWithStdin(
       JSON.stringify([{ id: "q1", answer: true, p: 5 }]),
-      () => run(repo, "judge", "answer"),
+      repo,
+      "judge",
+      "answer",
     )
     expect(exitCode).toBe(2)
     expect(stderr).toContain("does not match the pending questions")
@@ -2245,9 +2239,11 @@ export default workflow(
 
   it("gtd judge answer refuses a verdict whose p is negative", async () => {
     const repo = seededRepo()
-    const { exitCode, stderr } = await withStdin(
+    const { exitCode, stderr } = await runWithStdin(
       JSON.stringify([{ id: "q1", answer: true, p: -0.1 }]),
-      () => run(repo, "judge", "answer"),
+      repo,
+      "judge",
+      "answer",
     )
     expect(exitCode).toBe(2)
     expect(stderr).toContain("does not match the pending questions")
@@ -2255,15 +2251,19 @@ export default workflow(
 
   it("gtd judge answer refuses through the ordinary error envelope when the rest is no judge step", async () => {
     const repo = seededRepoWithoutJudge()
-    const { exitCode, stderr } = await withStdin("[]", () => run(repo, "judge", "answer"))
+    const { exitCode, stderr } = await runWithStdin("[]", repo, "judge", "answer")
     expect(exitCode).toBe(1)
     expect(stderr).toContain('declares no "judge:"')
   })
 
   it("gtd judge answer --json=script emits a POSIX sh script carrying a Gtd-Judge: trailer on the step commit", async () => {
     const repo = seededLandingRepo()
-    const { stdout, exitCode } = await withStdin(VERDICT, () =>
-      run(repo, "judge", "answer", "--json=script"),
+    const { stdout, exitCode } = await runWithStdin(
+      VERDICT,
+      repo,
+      "judge",
+      "answer",
+      "--json=script",
     )
     expect(exitCode).toBe(0)
     expect(stdout).toContain(DID_NOT_RUN_COMMENT)
@@ -2276,16 +2276,14 @@ export default workflow(
 
   it("gtd judge answer --json=script opens with the same leading comment as land's script", async () => {
     const repo = seededLandingRepo()
-    const { stdout: script } = await withStdin(VERDICT, () =>
-      run(repo, "judge", "answer", "--json=script"),
-    )
+    const { stdout: script } = await runWithStdin(VERDICT, repo, "judge", "answer", "--json=script")
     const { stdout: landScript } = await run(repo, "land", "--json=script")
     expect(script.split("\n")[0]).toBe(landScript.split("\n")[0])
   })
 
   it("plain gtd judge answer (no --json) names the commit and points at --json=script, never the script itself", async () => {
     const repo = seededLandingRepo()
-    const { stdout, exitCode } = await withStdin(VERDICT, () => run(repo, "judge", "answer"))
+    const { stdout, exitCode } = await runWithStdin(VERDICT, repo, "judge", "answer")
     expect(exitCode).toBe(0)
     expect(stdout).toContain("--json=script")
     expect(stdout).not.toContain(DID_NOT_RUN_COMMENT)
@@ -2305,8 +2303,12 @@ export default workflow(
 
   it("gtd judge answer records no truncation on the landing commit — replay recomputes the cut from the budget", async () => {
     const repo = seededTruncatingLandingRepo("20", "aaaaaaaaaa\nbbbbbbbbbb\ncccccccccc\n")
-    const { stdout, exitCode } = await withStdin(VERDICT, () =>
-      run(repo, "judge", "answer", "--json=script"),
+    const { stdout, exitCode } = await runWithStdin(
+      VERDICT,
+      repo,
+      "judge",
+      "answer",
+      "--json=script",
     )
     expect(exitCode).toBe(0)
     expect(applyEmittedScript(repo, new Map(), stdout).ok).toBe(true)