@pmelab/gtd 24.0.0 → 24.1.0

package/src/step/LandStep.ts

@@ -0,0 +1,31 @@
+import type { StateName } from "../workflow/index.js"
+
+/**
+ * The core's git effect, as DATA — never shell text. `src/emit/GitScript.ts` is
+ * the only place a `GitWrite` becomes a command; `src/step/` never imports
+ * that module, which is what makes writing a live git call inside the core
+ * impossible rather than merely discouraged.
+ */
+export type GitWrite = { readonly kind: "commitAll"; readonly message: string }
+
+/** A landed step's trailing report, rendered by `GitScript.ts` into a `printf` line. */
+export type Outcome =
+  | { readonly kind: "transition"; readonly from: StateName; readonly to: StateName }
+  | { readonly kind: "commit"; readonly subject: StateName | string }
+  | { readonly kind: "note"; readonly text: string }
+
+/**
+ * One step of a landing script, as DATA — no step carries a literal shell
+ * string; `GitScript.ts`'s `ScriptSurface` is the only place any of these
+ * becomes shell text (and the only place a bare path becomes a quoted
+ * argument). `"uncheck"` is the human-review-gate's reset command
+ * (`gtd uncheck <file>`, ahead of the commit); `"command"`'s own `command`
+ * is a driver-facing shell fragment `src/step/` never constructs today (no
+ * current emitter produces one) but the shape stays available for a future
+ * step that genuinely needs an arbitrary command.
+ */
+export type LandStep =
+  | { readonly kind: "gitWrite"; readonly write: GitWrite }
+  | { readonly kind: "uncheck"; readonly file: string }
+  | { readonly kind: "command"; readonly command: string; readonly onFailure?: string }
+  | { readonly kind: "outcome"; readonly outcome: Outcome }

package/src/step/RepoSnapshot.ts

@@ -0,0 +1,29 @@
+import type { CommitSpec } from "../replay/index.js"
+import type { PendingChange, StateName, StepDef } from "../workflow/index.js"
+
+/**
+ * What landing the pending turn does, decided at the edge by replaying the
+ * episode with the working tree as the pending turn.
+ */
+export type Landing =
+  | { readonly kind: "refusal"; readonly message: string }
+  /** Nothing to land. `settled` when re-running the rest cannot change that. */
+  | { readonly kind: "noop"; readonly settled: boolean }
+  /** An empty agent turn: recorded, but the process stays at the step. */
+  | { readonly kind: "attempt"; readonly subject: string }
+  | { readonly kind: "commit"; readonly to: StateName; readonly spec: CommitSpec }
+
+/**
+ * Everything `planStep` needs, already resolved
+ * from git/config/workspace ONCE, before any perform — a frozen value cannot
+ * observe a perform.
+ */
+export interface RepoSnapshot {
+  readonly stepDef: StepDef
+  readonly state: StateName
+  readonly actor: string
+  readonly changes: readonly PendingChange[]
+  /** The resting step's steering file, `undefined` when it declares none. */
+  readonly file: string | undefined
+  readonly landing: Landing
+}

package/src/step/accessRefusal.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest"
+import { ACCESS_REFUSAL } from "../wire/index.js"
+import { accessRefusal } from "./accessRefusal.js"
+
+describe("accessRefusal", () => {
+  it("allows changes inside the write globs", () => {
+    expect(
+      accessRefusal(
+        [
+          { status: "M", path: ".gtd/REVIEW.md" },
+          { status: "A", path: "docs/deep/a.md" },
+        ],
+        [".gtd/REVIEW.md", "docs/**"],
+      ),
+    ).toBeUndefined()
+  })
+
+  it("refuses a path outside, naming it and the allowed globs", () => {
+    const message = accessRefusal(
+      [
+        { status: "M", path: "src/foo.ts" },
+        { status: "M", path: ".gtd/REVIEW.md" },
+      ],
+      [".gtd/REVIEW.md"],
+    )
+    expect(message).toBe(`${ACCESS_REFUSAL}\n  - src/foo.ts\nallowed: .gtd/REVIEW.md`)
+  })
+
+  it("refuses a delete outside", () => {
+    expect(accessRefusal([{ status: "D", path: "src/gone.ts" }], ["docs/**"])).toContain(
+      "  - src/gone.ts",
+    )
+  })
+
+  it("refuses only the side of a rename that lands outside the write globs", () => {
+    const message = accessRefusal(
+      [
+        { status: "D", path: "docs/a.md" },
+        { status: "A", path: "src/a.md" },
+      ],
+      ["docs/**"],
+    )
+    expect(message).toContain("  - src/a.md")
+    expect(message).not.toContain("  - docs/a.md")
+  })
+
+  it("never refuses a null write", () => {
+    expect(accessRefusal([{ status: "M", path: "anything" }], null)).toBeUndefined()
+  })
+
+  it("says nothing is allowed for an empty list", () => {
+    expect(accessRefusal([{ status: "A", path: "x" }], [])).toContain("allowed: (nothing)")
+  })
+
+  it("starts with the marker line", () => {
+    expect(accessRefusal([{ status: "A", path: "x" }], ["y"])?.split("\n")[0]).toBe(ACCESS_REFUSAL)
+  })
+})

package/src/step/accessRefusal.ts

@@ -0,0 +1,26 @@
+import { globMatches } from "../wire/index.js"
+import type { PendingChange } from "../workflow/index.js"
+import { ACCESS_REFUSAL } from "../wire/index.js"
+
+/**
+ * The landing refusal for changes outside `write`, or `undefined` when every
+ * path is allowed. `null` is unrestricted. The message is the fix prompt: gtd
+ * runs no fix turn of its own.
+ */
+export const accessRefusal = (
+  changes: readonly PendingChange[],
+  write: readonly string[] | null,
+): string | undefined => {
+  if (write === null) return undefined
+  const offending = [
+    ...new Set(
+      changes.filter((c) => !write.some((glob) => globMatches(c.path, glob))).map((c) => c.path),
+    ),
+  ]
+  if (offending.length === 0) return undefined
+  return [
+    ACCESS_REFUSAL,
+    ...offending.map((path) => `  - ${path}`),
+    `allowed: ${write.length === 0 ? "(nothing)" : write.join(", ")}`,
+  ].join("\n")
+}

package/src/step/index.ts

@@ -0,0 +1,5 @@
+export { planStep, type JudgeVerdict } from "./planStep.js"
+export { accessRefusal } from "./accessRefusal.js"
+export { planStart } from "./planStart.js"
+export type { GitWrite, LandStep, Outcome } from "./LandStep.js"
+export type { Landing, RepoSnapshot } from "./RepoSnapshot.js"

package/src/step/planStart.test.ts

@@ -0,0 +1,202 @@
+import { Effect } from "effect"
+import { describe, expect, it } from "vitest"
+import { planStart, type StartOutcome } from "./planStart.js"
+import { InMemRepo, testLayers } from "../testkit/index.js"
+import { ConfigService } from "../workflow/index.js"
+
+const WORKFLOW = `import { agent, human } from "@pmelab/gtd/flows"
+
+export default async () => {
+  await human("idle", { message: "hi" })
+  await agent("work", "work-prompt")
+}
+
+export const working = async () => {
+  await agent("work", "work-prompt")
+}
+
+export const reviewcheck = async () => {
+  await agent("work", "work-prompt")
+}
+
+export const defaults = { base: "" }
+
+export const base = (workflow, vars) => (workflow === "reviewcheck" ? (vars.base ?? "") : undefined)
+`
+
+const repoAt = (): InMemRepo => {
+  const repo = new InMemRepo()
+  repo.writeFile("gtd.config.ts", WORKFLOW)
+  repo.commitAllWithPrefix("chore: add custom workflow")
+  return repo
+}
+
+/** Loads the real compiled workflows (via `ConfigService`, same as `Edge.ts`'s `restAt`) so `planStart`'s checks see the loaded workflow, then runs `planStart` against it. */
+const start = (
+  repo: InMemRepo,
+  state: string,
+  actor: string,
+  req: {
+    readonly workflow: string
+    readonly commandLabel: string
+    readonly vars: Record<string, string>
+  },
+  startRefusal?: string,
+): Promise<StartOutcome> =>
+  Effect.runPromise(
+    Effect.gen(function* () {
+      const config = yield* (yield* ConfigService).load
+      const workflow = config.workflowNamed(req.workflow)
+      if (workflow === undefined) throw new Error(`no workflow ${req.workflow}`)
+      return yield* planStart({ state, idle: state === config.workflow.initial }, actor, {
+        workflow,
+        first: startRefusal === undefined ? { firstStep: "work" } : { refusal: startRefusal },
+        commandLabel: req.commandLabel,
+        vars: req.vars,
+        config: {},
+      })
+    }).pipe(Effect.provide(testLayers(repo))),
+  )
+
+describe("planStart", () => {
+  it("refuses when a process is already underway", async () => {
+    const repo = repoAt()
+    const plan = await start(repo, "working", "human", {
+      workflow: "working",
+      commandLabel: "gtd test",
+      vars: {},
+    })
+    expect(plan.kind).toBe("refusal")
+    expect(plan.kind === "refusal" && plan.message).toContain("already underway")
+  })
+
+  it("refuses, under the command's label, a workflow that will not start", async () => {
+    const repo = repoAt()
+    const plan = await start(
+      repo,
+      "idle",
+      "human",
+      { workflow: "working", commandLabel: "gtd test", vars: {} },
+      'workflow "working" cannot start — it reaches no step',
+    )
+    expect(plan).toEqual({
+      kind: "refusal",
+      message: 'gtd test: workflow "working" cannot start — it reaches no step',
+    })
+  })
+
+  it("refuses an undeclared --var name", async () => {
+    const repo = repoAt()
+    const plan = await start(repo, "idle", "human", {
+      workflow: "working",
+      commandLabel: "gtd test",
+      vars: { nope: "x" },
+    })
+    expect(plan.kind).toBe("refusal")
+    expect(plan.kind === "refusal" && plan.message).toContain("not declared by this workflow")
+  })
+
+  describe("a workflow's diff base", () => {
+    const REVIEW = { workflow: "reviewcheck", commandLabel: "gtd test" }
+
+    it("resolves a blank base to the default branch's merge-base with HEAD", async () => {
+      const repo = repoAt()
+      const fork = repo.resolveRef("HEAD")!
+      repo.updateRef("main", fork)
+      repo.writeFile("a.txt", "a")
+      repo.commitAllWithPrefix("feat: ahead of main")
+      const plan = await start(repo, "idle", "human", { ...REVIEW, vars: {} })
+      if (plan.kind !== "start") throw new Error(`expected start, got ${JSON.stringify(plan)}`)
+      const write = plan.steps.find((s) => s.kind === "gitWrite")
+      if (write?.kind !== "gitWrite") throw new Error("expected a gitWrite step")
+      expect(write.write.message).toContain(`Gtd-Review-Base: ${fork}`)
+    })
+
+    it("pins the merge-base, not the named base, when the base has diverged", async () => {
+      const repo = repoAt()
+      const fork = repo.resolveRef("HEAD")!
+      repo.writeFile("other.txt", "o")
+      repo.commitAllWithPrefix("feat: other branch")
+      repo.updateRef("other", repo.resolveRef("HEAD")!)
+      repo.hardResetTo(fork)
+      repo.writeFile("mine.txt", "m")
+      repo.commitAllWithPrefix("feat: my branch")
+      const plan = await start(repo, "idle", "human", { ...REVIEW, vars: { base: "other" } })
+      if (plan.kind !== "start") throw new Error(`expected start, got ${JSON.stringify(plan)}`)
+      const write = plan.steps.find((s) => s.kind === "gitWrite")
+      if (write?.kind !== "gitWrite") throw new Error("expected a gitWrite step")
+      expect(write.write.message).toContain(`Gtd-Review-Base: ${fork}`)
+    })
+
+    it("refuses a base that does not resolve", async () => {
+      const plan = await start(repoAt(), "idle", "human", { ...REVIEW, vars: { base: "nope" } })
+      expect(plan).toEqual({
+        kind: "refusal",
+        message: 'gtd test: "nope" does not resolve to a commit',
+      })
+    })
+
+    it("refuses a base that shares no common ancestor with HEAD", async () => {
+      const repo = repoAt()
+      repo.updateRef("old-root", repo.resolveRef("HEAD")!)
+      repo.mixedResetTo("4b825dc642cb6eb9a060e54bf8d69288fbee4904")
+      repo.writeFile("gtd.config.ts", WORKFLOW)
+      repo.commitAllWithPrefix("chore: a second root")
+      const plan = await start(repo, "idle", "human", { ...REVIEW, vars: { base: "old-root" } })
+      expect(plan).toEqual({
+        kind: "refusal",
+        message: 'gtd test: "old-root" shares no common ancestor with HEAD',
+      })
+    })
+
+    it("refuses when HEAD has no commits beyond the base", async () => {
+      const repo = repoAt()
+      const plan = await start(repo, "idle", "human", { ...REVIEW, vars: {} })
+      expect(plan).toEqual({
+        kind: "refusal",
+        message: "gtd test: nothing to review: HEAD has no commits beyond main",
+      })
+    })
+  })
+
+  it("succeeds and emits a commitAll + commit-outcome LandStep pair, data only", async () => {
+    const repo = repoAt()
+    const plan = await start(repo, "idle", "human", {
+      workflow: "working",
+      commandLabel: "gtd test",
+      vars: {},
+    })
+    if (plan.kind !== "start") throw new Error(`expected start, got ${plan.kind}`)
+    expect(plan.subject).toBe("gtd(human): work")
+    expect(plan.steps).toEqual([
+      {
+        kind: "gitWrite",
+        write: {
+          kind: "commitAll",
+          message: "gtd(human): work\n\nGtd-Workflow: working\nGtd-Var: base=\nGtd-Format: 1",
+        },
+      },
+      { kind: "outcome", outcome: { kind: "commit", subject: "gtd(human): work" } },
+    ])
+  })
+
+  it("folds --var overrides into a Gtd-Var: trailer on the commit message, never the outcome subject", async () => {
+    const repo = repoAt()
+    const plan = await start(repo, "idle", "human", {
+      workflow: "working",
+      commandLabel: "gtd test",
+      vars: { base: "main" },
+    })
+    if (plan.kind !== "start") throw new Error(`expected start, got ${plan.kind}`)
+    const write = plan.steps.find((s) => s.kind === "gitWrite")
+    if (write?.kind !== "gitWrite") throw new Error("expected a gitWrite step")
+    expect(write.write.message).toBe(
+      "gtd(human): work\n\nGtd-Workflow: working\nGtd-Var: base=main\nGtd-Format: 1",
+    )
+    const outcome = plan.steps.find((s) => s.kind === "outcome")
+    expect(outcome).toEqual({
+      kind: "outcome",
+      outcome: { kind: "commit", subject: "gtd(human): work" },
+    })
+  })
+})

package/src/step/planStart.ts

@@ -0,0 +1,167 @@
+import { Effect, Option } from "effect"
+import { GtdUsageError, Narrator, GitService, Host, Workspace } from "../platform/index.js"
+import {
+  ConfigDiscovery,
+  ConfigService,
+  multilineSetting,
+  resolveVars,
+  type ConfigFingerprint,
+  type ResolvedWorkflow,
+} from "../workflow/index.js"
+import { formatCommitMessage, formatSubject } from "../replay/index.js"
+import type { LandStep } from "./LandStep.js"
+
+/** Just enough of the current rest for `planStart`'s checks. */
+export interface StartCurrent {
+  /** The step the process rests at. */
+  readonly state: string
+  /** Whether no process is underway: the default workflow's first step, first visit. */
+  readonly idle: boolean
+}
+
+export type StartOutcome =
+  | { readonly kind: "refusal"; readonly message: string }
+  | {
+      readonly kind: "start"
+      readonly workflow: string
+      readonly subject: string
+      /** The `LandStep`s a driver runs to write the opening commit — data, never shell text. */
+      readonly steps: readonly LandStep[]
+    }
+
+type Refused = Extract<StartOutcome, { kind: "refusal" }>
+
+const refusal = (message: string): Refused => ({ kind: "refusal", message })
+
+const checkOverrides = (
+  commandLabel: string,
+  varOverrides: Record<string, string>,
+  declaredNames: readonly string[],
+  envNames: readonly string[],
+): Effect.Effect<StartOutcome | undefined, Error> =>
+  Effect.gen(function* () {
+    const environmentOnly = Object.keys(varOverrides).filter(
+      (n) => !declaredNames.includes(n) && envNames.includes(n),
+    )
+    if (environmentOnly.length > 0) {
+      return yield* Effect.fail(
+        new GtdUsageError(
+          `${commandLabel}: --var pins process settings only; ${environmentOnly.join(", ")} ${
+            environmentOnly.length === 1 ? "is an environment setting" : "are environment settings"
+          } — set it as a workflow option in gtd.config.ts or with a GTD_<NAME> environment variable`,
+        ),
+      )
+    }
+    const undeclared = Object.keys(varOverrides).filter((n) => !declaredNames.includes(n))
+    if (undeclared.length > 0) {
+      return refusal(
+        `${commandLabel}: --var name(s) not declared by this workflow: ${undeclared.join(
+          ", ",
+        )} — declared: ${declaredNames.length > 0 ? declaredNames.join(", ") : "(none)"}`,
+      )
+    }
+    return undefined
+  })
+
+/**
+ * `gtd --workflow <name>`: start a brand NEW process on a workflow, writing an
+ * opening commit that names the workflow's first step and carries a
+ * `Gtd-Workflow:` trailer, every process setting as a `Gtd-Var:` trailer, plus
+ * a `Gtd-Review-Base:` trailer when the workflow fixes the process's diff base,
+ * and a `Gtd-Config:` trailer per config file.
+ * All validation is a REFUSAL, not an Effect failure.
+ */
+export const planStart = (
+  current: StartCurrent,
+  actor: string,
+  start: {
+    readonly workflow: ResolvedWorkflow
+    /** The workflow's first step, or why it will not start a process. */
+    readonly first: { readonly firstStep: string } | { readonly refusal: string }
+    readonly commandLabel: string
+    readonly vars: Record<string, string>
+    readonly config: ConfigFingerprint
+  },
+): Effect.Effect<
+  StartOutcome,
+  Error,
+  GitService | ConfigService | ConfigDiscovery | Workspace | Host | Narrator
+> =>
+  Effect.gen(function* () {
+    const { workflow, first, commandLabel, vars: varOverrides } = start
+    const name = workflow.name
+
+    if (!current.idle) {
+      return refusal(
+        `${commandLabel}: a process is already underway (resting at "${current.state}") — finish it, or run \`gtd abandon\`, before starting another`,
+      )
+    }
+
+    if ("refusal" in first) return refusal(`${commandLabel}: ${first.refusal}`)
+    const { firstStep } = first
+
+    const overrideRefusal = yield* checkOverrides(
+      commandLabel,
+      varOverrides,
+      Object.keys(workflow.vars),
+      Object.keys(workflow.env),
+    )
+    if (overrideRefusal !== undefined) return overrideRefusal
+
+    const baseOf = workflow.def.base
+    const vars = resolveVars(workflow.vars, varOverrides, (yield* Host).env)
+    const multiline = multilineSetting(vars)
+    if (multiline !== undefined) {
+      return refusal(
+        `${commandLabel}: process setting "${multiline}" spans several lines — a process setting is pinned in a commit trailer and must be a single line`,
+      )
+    }
+    const template = yield* Effect.try({
+      try: () => baseOf?.(name, vars),
+      catch: (e) => new Error(`${commandLabel}: ${e instanceof Error ? e.message : String(e)}`),
+    })
+    const base = template === undefined ? undefined : yield* resolveBase(commandLabel, template)
+    if (typeof base === "object") return base
+
+    const subject = formatSubject(actor, firstStep)
+    const message = formatCommitMessage({
+      actor,
+      to: firstStep,
+      workflow: name,
+      ...(base !== undefined ? { reviewBase: base } : {}),
+      vars,
+      config: start.config,
+    })
+    const steps: readonly LandStep[] = [
+      { kind: "gitWrite", write: { kind: "commitAll", message } },
+      { kind: "outcome", outcome: { kind: "commit", subject } },
+    ]
+    return { kind: "start", workflow: name, subject, steps } as const
+  })
+
+/**
+ * The workflow's diff base: `git merge-base <base> HEAD`, where a blank base
+ * means the default branch. The merge-base is what gets pinned, so a base on
+ * another branch reviews exactly this branch's own commits.
+ */
+const resolveBase = (
+  commandLabel: string,
+  value: string,
+): Effect.Effect<string | Refused, Error, GitService> =>
+  Effect.gen(function* () {
+    const git = yield* GitService
+    const rendered = value.trim()
+    const target = rendered === "" ? yield* git.defaultBranch() : rendered
+    const resolvedBase = yield* Effect.either(git.resolveRef(target))
+    if (resolvedBase._tag === "Left") {
+      return refusal(`${commandLabel}: "${target}" does not resolve to a commit`)
+    }
+    const mergeBase = yield* git.mergeBase(resolvedBase.right, "HEAD")
+    if (Option.isNone(mergeBase)) {
+      return refusal(`${commandLabel}: "${target}" shares no common ancestor with HEAD`)
+    }
+    if (mergeBase.value === (yield* git.resolveRef("HEAD"))) {
+      return refusal(`${commandLabel}: nothing to review: HEAD has no commits beyond ${target}`)
+    }
+    return mergeBase.value
+  })

package/src/step/planStep.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest"
+import { planStep } from "./planStep.js"
+import { snapshot } from "./snapshot.fixture.js"
+
+const commitTo = (from: string, to: string, actor = "human") =>
+  ({
+    kind: "commit",
+    to,
+    spec: { actor, from, to, step: { name: from, occurrence: 1 } },
+  }) as const
+
+describe("planStep — refusal and no-op pass through", () => {
+  it("a refused landing becomes a refusal outcome", () => {
+    const s = snapshot({
+      state: "building",
+      stepDef: {},
+      landing: { kind: "refusal", message: "gtd land: nope" },
+    })
+    expect(planStep(s)).toEqual({ kind: "refusal", message: "gtd land: nope" })
+  })
+
+  it("a no-op keeps its settled flag", () => {
+    const s = snapshot({ state: "gate", stepDef: {}, landing: { kind: "noop", settled: true } })
+    expect(planStep(s)).toEqual({ kind: "noop", state: "gate", settled: true })
+  })
+})
+
+describe("planStep — commit", () => {
+  it("an attempt commits the subject with no step trailer and bypasses guards", () => {
+    const s = snapshot({
+      state: "await-answers",
+      stepDef: { actor: "agent", kind: "prompt", mode: "qa" },
+      actor: "agent",
+      landing: { kind: "attempt", subject: "gtd(agent): await-answers" },
+    })
+    const outcome = planStep(s)
+    if (outcome.kind !== "commit") throw new Error(`expected commit, got ${outcome.kind}`)
+    expect(outcome.to).toBe("await-answers")
+    expect(outcome.steps).toEqual([
+      {
+        kind: "gitWrite",
+        write: { kind: "commitAll", message: "gtd(agent): await-answers\n\nGtd-Format: 1" },
+      },
+      { kind: "outcome", outcome: { kind: "commit", subject: "gtd(agent): await-answers" } },
+    ])
+  })
+
+  it("a transition commit carries the step trailer and reports both steps", () => {
+    const s = snapshot({
+      state: "building",
+      stepDef: {},
+      changes: [{ status: "M", path: ".gtd/FILE.md" }],
+      landing: commitTo("building", "done"),
+    })
+    const outcome = planStep(s)
+    if (outcome.kind !== "commit") throw new Error(`expected commit, got ${outcome.kind}`)
+    expect(outcome.subject).toBe("gtd(human): building → done")
+    expect(outcome.steps[0]).toEqual({
+      kind: "gitWrite",
+      write: {
+        kind: "commitAll",
+        message: "gtd(human): building → done\n\nGtd-Step: building#1\nGtd-Format: 1",
+      },
+    })
+    expect(outcome.steps.at(-1)).toEqual({
+      kind: "outcome",
+      outcome: { kind: "transition", from: "building", to: "done" },
+    })
+  })
+
+  it("prepends `gtd uncheck` at the human review gate", () => {
+    const s = snapshot({
+      state: "await-review",
+      stepDef: { mode: "review", file: ".gtd/REVIEW.md" },
+      changes: [{ status: "M", path: "src/a.ts" }],
+      landing: commitTo("await-review", "deciding"),
+    })
+    const outcome = planStep(s)
+    if (outcome.kind !== "commit") throw new Error(`expected commit, got ${outcome.kind}`)
+    expect(outcome.steps[0]).toEqual({ kind: "uncheck", file: ".gtd/REVIEW.md" })
+  })
+
+  it("records Gtd-Cost, then one Gtd-Judge per verdict", () => {
+    const s = snapshot({ state: "a", stepDef: {}, landing: commitTo("a", "b", "judge") })
+    const outcome = planStep(s, {
+      cost: 1.5,
+      model: "m",
+      judge: [
+        { id: "q1", answer: true, p: 0.9 },
+        { id: "q2", answer: "x", p: 0.4 },
+      ],
+    })
+    if (outcome.kind !== "commit") throw new Error(`expected commit, got ${outcome.kind}`)
+    const write = outcome.steps.find((step) => step.kind === "gitWrite")
+    if (write?.kind !== "gitWrite") throw new Error("expected a git write")
+    const trailers = write.write.message.split("\n").slice(2)
+    expect(trailers[0]).toBe("Gtd-Step: a#1")
+    expect(trailers[1]).toBe("Gtd-Cost: 1.5 m")
+    expect(trailers[2]).toBe('Gtd-Judge: {"id":"q1","answer":true,"p":0.9}')
+    expect(trailers[3]).toBe('Gtd-Judge: {"id":"q2","answer":"x","p":0.4}')
+    expect(trailers[4]).toBe("Gtd-Format: 1")
+    expect(trailers).toHaveLength(5)
+  })
+})