@pmelab/gtd 59.0.1 → 60.0.0

package/src/gherkin/messages.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert"
-import type { TestRepo } from "../testkit/index.js"
+import type { BeatDocument, TestRepo } from "../testkit/index.js"
 
 const CONTENT_LINES = 5
 const SUBJECTS = 5
@@ -22,10 +22,19 @@ const beatLines = async (repo: TestRepo): Promise<string[]> => {
   }
 }
 
+/** A scripted step no drive reached, and whether a Background or the scenario scripted it. */
+export interface Unreached {
+  readonly step: string
+  readonly origin: "Background" | "scenario"
+}
+
+export const unreachedList = (steps: readonly Unreached[]): string =>
+  steps.map(({ step, origin }) => `"${step}" (${origin})`).join(", ")
+
 /** Where the process rests, for a failed outcome to end with. Never throws: it describes a failure. */
 export const restDescription = async (
   repo: () => TestRepo,
-  neverUsed: readonly string[],
+  neverUsed: readonly Unreached[],
 ): Promise<string> => {
   let lines: string[]
   try {
@@ -41,8 +50,7 @@ export const restDescription = async (
   } catch (error) {
     lines = [`unknown — ${reason(error)}`]
   }
-  if (neverUsed.length > 0)
-    lines.push(`actors never used: ${neverUsed.map((step) => `"${step}"`).join(", ")}`)
+  if (neverUsed.length > 0) lines.push(`actors never used: ${unreachedList(neverUsed)}`)
   return ["where the process rests:", ...lines.map((line) => `  ${line}`)].join("\n")
 }
 
@@ -82,3 +90,12 @@ export const assertLacks = (where: string, text: string, content: string | undef
   if (content === undefined || content.includes(text))
     assert.fail(containsFailure(where, text, content, false))
 }
+
+/** A rest at `step`; a stall there is no rest, so it points to the step that asserts one. */
+export const assertRestsAt = (beat: BeatDocument, step: string): void => {
+  if (beat.kind === "stalled")
+    assert.fail(
+      `expected a rest at "${step}", but the process stalls at "${beat.state}" — assert a stall with: the process stalls at "${beat.state}"`,
+    )
+  assert.strictEqual(beat.state, step)
+}

package/src/gherkin/more-steps.feature

@@ -0,0 +1,170 @@
+@inmem
+Feature: steps for checks, stalls, beat fields, commit bodies and the environment
+
+  Background:
+    Given a gtd config with:
+      """
+      import { agent, check, envSettings, human, scope, settings, workflow } from "@pmelab/gtd/flows"
+
+      const defaults = { title: "untitled" }
+      const envDefaults = { greeting: "hi" }
+
+      export const tested = workflow(async () => {
+        await scope({ name: "build", skills: ["tdd", "review"] }, async () => {
+          await agent("plan", "Plan.", { model: "smart" })
+        })
+        const green = await check("test", "npm test", ".gtd/FEEDBACK.md")
+        await agent(green ? "ship" : "repair", `Say ${envSettings.greeting} to ${settings.title}.`)
+        await human("done")
+      }, { defaults, envDefaults })
+
+      export default tested
+      """
+
+  Scenario: the resting step's fields are read by name
+    When gtd starts workflow "tested"
+    Then the process rests at "build.plan"
+    And the resting step's model is "smart"
+    And the resting step's idle is "false"
+    And the resting step's skills includes "review"
+    And the resting step's content includes "Plan"
+
+  Scenario: a quoted argument keeps its spaces
+    Given step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And check step "test" passes
+    When gtd starts workflow "tested" with "--var 'title=a calculator'"
+    And the process is driven
+    Then the resting step's content contains "Say hi to a calculator."
+
+  Scenario: an agent step that changes nothing stalls
+    Given step "build.plan" changes nothing
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process stalls at "build.plan"
+
+  Scenario: a passing check step goes on, and a variable changed mid-process is seen from then on
+    Given step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And check step "test" passes
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process rests at "ship"
+    And the resting step's content contains "Say hi to untitled."
+    Given from now on the environment variable "GTD_GREETING" is "hello"
+    Then the resting step's content contains "Say hello to untitled."
+
+  Scenario: a failing check step writes its report
+    Given the environment variable "GTD_GREETING" is "hey"
+    And step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And check step "test" fails with:
+      """
+      1 test failing
+      """
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process rests at "repair"
+    And ".gtd/FEEDBACK.md" contains "1 test failing"
+    And the resting step's content contains "Say hey to untitled."
+
+  Scenario: a check step scripted at a step that is no check refuses the drive
+    Given check step "build.plan" passes
+    When gtd starts workflow "tested"
+    Then driving the process is refused with 'step "build.plan" is no check step; its actor is agent'
+
+  Scenario: commit bodies are read whole, every commit of a subject at once
+    Given the working tree is committed with the message:
+      """
+      chore: seed
+
+      Seeded by hand.
+
+      Refs: #1
+      """
+    And step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And check step "test" passes
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the last commit body contains "Gtd-Step: test#1"
+    And the commit "gtd(agent): build.plan → test" has a body containing "Gtd-Step: build.plan#1"
+    And the commit "chore: seed" has a body containing "Seeded by hand."
+    And no commit body contains "never written"
+
+  Scenario: a canned command matched by pattern, a branch at a ref, and a file as committed there
+    Given a file "a.txt" with:
+      """
+      one
+      """
+    And the working tree is committed as "chore: one"
+    And a file "a.txt" with:
+      """
+      two
+      """
+    And the working tree is committed as "chore: two"
+    And a branch "old" at "HEAD~1"
+    And the command matching "^npm (test|run)" exits 1 with:
+      """
+      red
+      """
+    And step "build.plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "test" runs its script
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process rests at "repair"
+    And "a.txt" as committed at "old" contains "one"
+    And ".gtd/FEEDBACK.md" contains "red"
+
+  Scenario: text is appended to a file, and a step overwrites one only if it exists
+    Given a file "NOTES.md" with:
+      """
+      first
+      """
+    And text is appended to "NOTES.md":
+      """
+      second
+      """
+    And step "build.plan" overwrites "PLAN.md", if it exists, with:
+      """
+      never written
+      """
+    And step "build.plan" overwrites "NOTES.md", if it exists, with:
+      """
+      rewritten
+      """
+    And step "test" runs its script
+    And the command "npm test" exits 0
+    When gtd starts workflow "tested"
+    And the process is driven
+    Then the process rests at "ship"
+    And "NOTES.md" contains "rewritten"
+    And "PLAN.md" does not exist
+
+  Scenario: a config given as source imports a module the scenario names
+    Given the module "src/gherkin/tiny.fixture.ts" is importable as "#workflow"
+    And a gtd config with:
+      """
+      export { tiny, tiny as default } from "#workflow"
+      """
+    And a file "IDEA.md" with:
+      """
+      a calculator
+      """
+    And step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When the process is driven
+    Then the process rests at "sign-off"

package/src/gherkin/scenario-end.feature

@@ -0,0 +1,101 @@
+@inmem
+Feature: a scenario's scripted steps must be reached by its end, not by every drive
+
+  Background:
+    Given a gtd config with:
+      """
+      import { agent, human, workflow } from "@pmelab/gtd/flows"
+
+      export const shipping = workflow(async () => {
+        await agent("plan", "Write PLAN.md.")
+        await human("sign-off")
+        await agent("ship", "Ship it.")
+        await human("done")
+      })
+
+      export default shipping
+      """
+    And step "ship" writes "SHIPPED.md" with:
+      """
+      shipped
+      """
+
+  Scenario: an actor the Background scripts, reached only by the second drive, passes
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When gtd starts workflow "shipping"
+    And the process is driven
+    Then the process rests at "sign-off"
+    Given step "sign-off" writes "SIGNED.md" with:
+      """
+      signed
+      """
+    When the process is driven
+    Then the process rests at "done"
+    And "SHIPPED.md" contains "shipped"
+
+  Scenario: an actor the Background scripts may go unreached in a scenario another scenario reaches it in
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When gtd starts workflow "shipping"
+    And the process is driven
+    Then the process rests at "sign-off"
+
+  @fails
+  Scenario: an actor the scenario scripts that no drive reaches fails it at its end
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "done" writes "DONE.md" with:
+      """
+      done
+      """
+    When gtd starts workflow "shipping"
+    And the process is driven
+    Then the process rests at "sign-off"
+
+  @fails
+  Scenario: a lenient drive leaves an actor no drive reaches to fail the scenario at its end
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "done" writes "DONE.md" with:
+      """
+      done
+      """
+    When gtd starts workflow "shipping"
+    And the process is driven leniently
+    Then the process rests at "sign-off"
+
+  Scenario: a refused drive excuses the actors it was handed
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "sign-off" changes nothing
+    And step "done" writes "DONE.md" with:
+      """
+      done
+      """
+    When gtd starts workflow "shipping"
+    Then driving the process is refused with 'the actor for human step "sign-off" changed nothing'
+
+  @fails
+  Scenario: an actor scripted after a refused drive, and reached by no later one, fails the scenario
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "sign-off" changes nothing
+    When gtd starts workflow "shipping"
+    Then driving the process is refused with 'the actor for human step "sign-off" changed nothing'
+    Given step "done" writes "DONE.md" with:
+      """
+      done
+      """

package/src/gherkin/testkit.feature

@@ -7,9 +7,9 @@ Feature: testkit drives any workflow against the real engine
   Background:
     Given a gtd config with:
       """
-      import { agent, human, judge, read, refuse, run } from "@pmelab/gtd/flows"
+      import { agent, human, judge, read, refuse, run, workflow } from "@pmelab/gtd/flows"
 
-      export const tiny = async () => {
+      export const tiny = workflow(async () => {
         await agent("plan", "Write PLAN.md.")
         await run("check", "npm test > .gtd/FEEDBACK.md 2>&1 && rm .gtd/FEEDBACK.md")
         if (read(".gtd/FEEDBACK.md") !== undefined) await agent("repair", "Make the suite pass.")
@@ -18,11 +18,11 @@ Feature: testkit drives any workflow against the real engine
           evidence: { plan: read("PLAN.md") ?? "" },
         })
         await human(answers.ready?.answer === "yes" ? "ship" : "rework")
-      }
+      })
 
-      export const picky = async () => {
+      export const picky = workflow(async () => {
         refuse("gtd: picky refuses every start")
-      }
+      })
 
       export default tiny
       """
@@ -83,9 +83,12 @@ Feature: testkit drives any workflow against the real engine
     And "PLAN.md" contains "add two numbers"
 
   Scenario: a judge step with queued actions refuses the drive
-    Given step "plan" changes nothing
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
     And step "check" changes nothing
-    And step "ready" is prompted with "never seen"
+    And step "ready" changes nothing
     And judge step "ready" answers:
       """
       [{ "id": "ready", "answer": true, "p": 0.9 }]
@@ -98,6 +101,79 @@ Feature: testkit drives any workflow against the real engine
     When gtd starts workflow "tiny"
     Then driving the process is refused with 'was not prompted with "Write a poem"'
 
+  Scenario: a step only asserted to be prompted is where the drive rests, and nothing lands there
+    Given step "plan" is prompted with "Write PLAN.md."
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process rests at "plan"
+    And the last commit subject is "gtd(human): plan"
+
+  Scenario: a prompt asserted beside a script is checked at every visit, before the step acts
+    Given step "check" is prompted with "npm test"
+    And step "check" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test failing
+      """
+    And step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process rests at "repair"
+
+  @fails
+  Scenario: a prompt asserted at a step no drive reaches fails the scenario at its end
+    Given step "plan" changes nothing
+    And step "repair" is prompted with "Make the suite pass."
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process stalls at "plan"
+
+  Scenario: a human step scripted to change nothing refuses the drive instead of repeating it
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "check" changes nothing
+    And judge step "ready" answers:
+      """
+      [{ "id": "ready", "answer": true, "p": 0.9 }]
+      """
+    And step "ship" changes nothing
+    When gtd starts workflow "tiny"
+    Then driving the process is refused with 'the actor for human step "ship" changed nothing'
+
+  Scenario: a lenient drive rests at an unscripted check step
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    When gtd starts workflow "tiny"
+    And the process is driven leniently
+    Then the process rests at "check"
+    And the resting step's content contains "npm test"
+
+  Scenario: a step scripted for a later drive counts once any drive reached it
+    Given step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "check" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test failing
+      """
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process rests at "repair"
+    Given step "repair" deletes ".gtd/FEEDBACK.md"
+    And judge step "ready" answers:
+      """
+      [{ "id": "ready", "answer": false, "p": 0.9 }]
+      """
+    When the process is driven
+    Then the process rests at "rework"
+
   Scenario: a start the workflow refuses is reported with its message
     Then starting workflow "picky" with "--var mode=bad" is refused with "picky refuses every start"
 

package/src/install/Install.test.ts

@@ -164,8 +164,8 @@ describe("renderBriefing", () => {
 
   it("contains the door invocation, exec'ing the loop", () => {
     const briefing = renderBriefing()
-    expect(briefing).toContain('gtd door "$@"')
-    expect(briefing).toContain("gtd doors")
+    expect(briefing).toContain('gtd start "$@"')
+    expect(briefing).toMatch(/bare `gtd start` lists/i)
     expect(briefing).toMatch(/exec.{0,20}GTD_BUILD/s)
   })
 
@@ -418,19 +418,19 @@ describe("DOOR_COMMAND", () => {
 
   it("cds to the repository root before any gtd call", () => {
     const cdIndex = DOOR_COMMAND.indexOf('cd "$(git rev-parse --show-toplevel)"')
-    const gtdIndex = DOOR_COMMAND.indexOf("gtd door")
+    const gtdIndex = DOOR_COMMAND.indexOf("gtd start")
     expect(cdIndex).toBeGreaterThan(-1)
     expect(gtdIndex).toBeGreaterThan(cdIndex)
   })
 
-  it("hands every argument to gtd door", () => {
-    expect(DOOR_COMMAND).toContain('gtd door "$@"')
+  it("hands every argument to gtd start", () => {
+    expect(DOOR_COMMAND).toContain('gtd start "$@"')
   })
 
   it("captures the emitted script via command substitution, never a pipe into sh", () => {
-    expect(DOOR_COMMAND).toContain('script="$(gtd door "$@")"')
+    expect(DOOR_COMMAND).toContain('script="$(gtd start "$@")"')
     expect(DOOR_COMMAND).toContain('sh -c "$script"')
-    expect(DOOR_COMMAND).not.toMatch(/gtd door[^\n]*\|\s*sh/)
+    expect(DOOR_COMMAND).not.toMatch(/gtd start[^\n]*\|\s*sh/)
   })
 
   it("prints usage to stderr and exits 2 when no name is given", () => {

package/src/install/Install.ts

@@ -175,7 +175,7 @@ if [ -z "\${1:-}" ]; then
   exit 2
 fi
 cd "$(git rev-parse --show-toplevel)"
-script="$(gtd door "$@")"
+script="$(gtd start "$@")"
 sh -c "$script"
 exec "$GTD_BUILD"`
 
@@ -365,7 +365,7 @@ const DRIVER_OBLIGATIONS = `
     \`--json=judge\`, pipes that rendered \`{ schema, state, questions }\` document to a
     judge model, and pipes ITS verdict (one \`{ id, answer, p }\` per pending
     question, as JSON on stdin) to \`gtd judge answer\` — the FIFTH command
-    that changes anything, alongside \`gtd land\`/\`gtd --workflow\`/\`gtd
+    that changes anything, alongside \`gtd land\`/\`gtd start\`/\`gtd
     abandon\`/\`gtd restore\`. It follows the exact same required-half /
     optional-half script contract as \`gtd land\` in obligation 8 above:
     read \`--json=script\` (and, if you want them, \`--json=settled\`/
@@ -565,9 +565,9 @@ ${EDIT_COMMAND}
 
 ### \`gtd-door <name> [args...]\` — start a process through a door and drive it
 
-Runs \`gtd door <name> [args...]\`, captured by command substitution — never a
+Runs \`gtd start <name> [args...]\`, captured by command substitution — never a
 pipe: a pipeline reports only its LAST command's exit status, so
-\`gtd door ... | sh\` under \`set -e\` would sail past a refusal and \`exec\` a
+\`gtd start ... | sh\` under \`set -e\` would sail past a refusal and \`exec\` a
 loop over a process that was never started. It runs the captured script, then
 \`exec\`s the suite's RESOLVED \`gtd-build\` path — never the literal string
 \`gtd-build\`. This is one invocation that carries the process all the way to
@@ -575,9 +575,9 @@ its next human gate, not just a starter: \`gtd-door review\` on a RED baseline
 hands off to \`gtd-build\`, which halts at the blocked gate and prints it,
 rather than starting the review; \`gtd-door fix\` on a GREEN suite is a no-op
 straight back to \`idle\` — the exec'd \`gtd-build\` exits immediately on it.
-\`gtd doors\` lists the doors a repository offers (those of the workflows its
-config exports — gtd-workflows' \`default\` brings \`fix\` and
-\`review [base]\` — plus any the config declares). Refuses with
+A bare \`gtd start\` lists what a repository can start: its workflows, and
+the doors those workflows bring (gtd-workflows' \`default\` brings \`fix\`
+and \`review [base]\`) plus any the config declares. Refuses with
 \`usage: gtd-door <name> [args...]\` on stderr and exit \`2\` when the name is
 missing — nothing was even attempted. Default path: \`~/.local/bin/gtd-door\`.
 
@@ -682,7 +682,7 @@ const PREREQUISITES = `
 ## Prerequisites and portability
 
 - A POSIX \`sh\` (dash, ash, bash's own POSIX mode, etc.) — gtd's own emitted
-  scripts (\`gtd land --json=script\`, \`gtd --workflow <name>\`, \`gtd abandon\`,
+  scripts (\`gtd land --json=script\`, \`gtd start <name>\`, \`gtd abandon\`,
   \`gtd restore\`, \`gtd judge answer --json=script\`) are POSIX sh; captured,
   then piped into it (see obligation 8 above). Reading
   \`gtd next --json=<path>\`/\`gtd land --json=<path>\`'s own output needs

package/src/replay/Replay.test.ts

@@ -702,7 +702,7 @@ describe("replay: keep", () => {
   it("rejects keep together with allowEmpty", async () => {
     const flow: Flow = async () => {
       await human("idle")
-      await agent("naive", "p", { keep: true, allowEmpty: true })
+      await agent("naive", "p", { keep: true, allowEmpty: true } as never)
     }
     const h = new History().land("human", "idle", 1, "naive", {})
     const outcome = await replayOf(flow, h)
@@ -1166,6 +1166,17 @@ describe("human({ approve })", () => {
     }
   })
 
+  it.each([
+    ["human", async () => human("gate", { mode: "qa" } as never)],
+    ["agent", async () => agent("gate", "p", { mode: "qa" } as never)],
+    ["run", async () => run("gate", "true", { mode: "qa" } as never)],
+  ] as const)("refuses a %s step's mode without a file", async (kind, flow) => {
+    expect(await replayOf(flow, new History())).toEqual({
+      kind: "failed",
+      message: `gtd: step "gate": mode requires file in ${kind}() options — name the steering file the mode checks`,
+    })
+  })
+
   describe("refuses mode and file", () => {
     const tail =
       "in human() options — an approval records exactly the judged tree, and a steering file is rewritten on landing"
@@ -1189,7 +1200,7 @@ describe("human({ approve })", () => {
       for (const options of [
         { approve: true, label: "x" },
         { approve: true, base: "start" },
-        { approve: false, mode: "review" },
+        { approve: false, mode: "review", file: ".gtd/REVIEW.md" },
         { approve: true, mode: undefined },
       ]) {
         expect((await outcomeOf(options)).kind).toBe("rest")

package/src/replay/Replay.ts

@@ -11,14 +11,13 @@ import {
   type StepRequest,
   type Flow,
   type Mark,
-} from "../flows/index.js"
+} from "../flows/internal.js"
 import {
-  headingSectionBodies,
-  headingSections,
-  steeringFormatFor,
+  openQuestions,
   parseCodeThreads,
-  parseThreadsWithFindings,
-  unansweredQuestions,
+  sectionBodies,
+  sections,
+  threads,
 } from "../steering/index.js"
 import { accessShapeFault, foldAccess, sameAccess } from "./Access.js"
 import { globMatches } from "../wire/index.js"
@@ -291,6 +290,13 @@ const approveConflict = (step: ReachedStep): string | undefined => {
   return `gtd: step "${step.name}": approve cannot be combined with ${keys.join(", ")} in human() options — an approval records exactly the judged tree, and a steering file is rewritten on landing`
 }
 
+// A mode names how a steering file is checked; with no file there is nothing to check.
+const modeWithoutFile = (step: ReachedStep): string | undefined => {
+  const options = step.request.options
+  if (options.mode === undefined || options.file !== undefined) return undefined
+  return `gtd: step "${step.name}": mode requires file in ${step.kind}() options — name the steering file the mode checks`
+}
+
 export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
   const commits: readonly ParsedCommit[] = input.episode.commits.map((c) => ({
     ...c,
@@ -524,7 +530,8 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
         message: `gtd: commit ${short(expected.hash)} names "${expected.name}" as the next step, but replay reached "${step.name}" — ${DIVERGED}`,
       }
     }
-    const error = unknownOptions(step) ?? approveConflict(step) ?? checkIdentity(step)
+    const error =
+      unknownOptions(step) ?? approveConflict(step) ?? modeWithoutFile(step) ?? checkIdentity(step)
     return error === undefined ? undefined : { kind: "failed", message: error }
   }
 
@@ -604,7 +611,7 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
     const name = scoped(request.name)
     if (request.options.keep === true) {
       // A clean allowEmpty keep would land an ordinary commit with no Gtd-Kept: a silent skip.
-      if (request.options.allowEmpty === true) {
+      if ((request.options as { readonly allowEmpty?: unknown }).allowEmpty === true) {
         return `gtd: step "${name}": keep: true cannot be combined with allowEmpty — a turn that changes nothing has nothing to keep`
       }
       // "/" would let one step's ref directory collide with another step's ref (git refuses `a` and `a/b` together).
@@ -667,28 +674,10 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
     changes: () => changesBetween(previousPosition.tree, position.tree),
     changesSince,
     matches: globMatches,
-    sections: (text) => headingSections(text),
-    sectionBodies: (text) => headingSectionBodies(text),
-    openQuestions: (text) => {
-      const qa = steeringFormatFor("qa")
-      return qa === undefined
-        ? []
-        : unansweredQuestions(qa, text).map((q) => ({
-            question: q.question,
-            line: q.headingLine + 1,
-          }))
-    },
-    threads: (text) => {
-      const { threads, findings } = parseThreadsWithFindings(text)
-      return threads.map((t) => ({
-        name: t.name,
-        line: t.line + 1,
-        waitingOn: t.waitingOn,
-        faults: findings
-          .filter((f) => f.message.startsWith(`Footnote thread "[^${t.name}]": `))
-          .map((f) => f.message),
-      }))
-    },
+    sections,
+    sectionBodies,
+    openQuestions,
+    threads,
     codeThreads: () =>
       changesBetween(
         treeAt(input.start) ?? input.startTree ?? input.episode.base.tree,

package/src/replay/judgeDiffShape.test.ts

@@ -6,7 +6,7 @@ import {
   type FlowContext,
   type JudgeAnswer,
   type StepRequest,
-} from "../flows/index.js"
+} from "../flows/internal.js"
 import { toRequest } from "../judges/index.js"
 import { globMatches } from "../wire/index.js"
 

package/src/steering/Footnotes.test.ts

@@ -697,7 +697,7 @@ describe("case-insensitive definition matching", () => {
   })
 })
 
-import { freeFormFormat, getParseCount, steeringFormatFor } from "./index.js"
+import { freeFormFormat, getParseCount, steeringFormatFor } from "./internal.js"
 
 const qaDescriptor = steeringFormatFor("qa")!
 const reviewDescriptor = steeringFormatFor("review")!