@pmelab/gtd 27.3.0 → 27.5.0

package/src/replay/judgeDiffShape.test.ts

@@ -50,6 +50,49 @@ const naive = [
 ]
 
 describe("judgeDiffShape", () => {
+  describe("exempt", () => {
+    const changes = [
+      change("src/foo*bar.ts", "added", undefined, "new"),
+      change("src/foobar.ts", "modified", "a", "b"),
+    ]
+
+    it("never lets an exempt path glob over a modified sibling", async () => {
+      install({ shape: { answer: "land", p: 0.9 } })
+      const result = await judgeDiffShape("shape", {
+        changes,
+        allow: [],
+        exempt: ["src/foo*bar.ts"],
+      })
+      expect(result.strays).toEqual(["src/foobar.ts"])
+    })
+
+    it("lists exempt paths as in-allowlist evidence and keeps allow to the globs", async () => {
+      const requests = install({ shape: { answer: "land", p: 0.9 } })
+      await judgeDiffShape("shape", { changes, allow: ["docs/**"], exempt: ["src/foo*bar.ts"] })
+      const request = requests[0]
+      if (request?.kind !== "judge") throw new Error("expected a judge step")
+      expect(request.evidence.allow).toBe(JSON.stringify(["docs/**"], null, 2))
+      expect(request.evidence.inAllowlist).toBe(JSON.stringify(["src/foo*bar.ts"], null, 2))
+    })
+
+    it("lands with no judge step when every stray is exempt", async () => {
+      const requests = install("none")
+      const result = await judgeDiffShape("shape", {
+        changes: [changes[0]!],
+        allow: [],
+        exempt: ["src/foo*bar.ts"],
+      })
+      expect(result.choice).toBe("land")
+      expect(requests).toEqual([])
+    })
+
+    it("changes nothing when omitted", async () => {
+      install({ shape: { answer: "land", p: 0.9 } })
+      const result = await judgeDiffShape("shape", { changes, allow: [] })
+      expect(result.strays).toEqual(["src/foo*bar.ts", "src/foobar.ts"])
+    })
+  })
+
   it("answers land with no judge step when nothing strays", async () => {
     const requests = install("none")
     const result = await judgeDiffShape("shape", {

package/src/replay/seamGate.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest"
+import { human, seamGate, type DiffShape, type DiffShapeResult, type Flow } from "../flows/index.js"
+import { replay, treeFromRecord } from "./index.js"
+
+// Lives in replay, which drives a flow to its rest (flows tests may not import replay).
+const shape = (
+  choice: DiffShape,
+  strays: string[] = [],
+  unreadable: string[] = [],
+): DiffShapeResult => ({ choice, strays, unreadable, judgment: undefined })
+
+const restOf = async (result: DiffShapeResult) => {
+  const flow: Flow = async () => {
+    await seamGate("seam", result)
+    await human("next")
+  }
+  const outcome = await replay({
+    flow,
+    episode: { base: { hash: "0".repeat(40), tree: treeFromRecord({}) }, commits: [] },
+    vars: {},
+    env: {},
+    start: "0".repeat(40),
+    budgetBytes: 1024,
+  })
+  if (outcome.kind !== "rest") throw new Error(`expected a rest, got ${outcome.kind}`)
+  return outcome.rest
+}
+
+describe("seamGate", () => {
+  for (const choice of ["land", "reject"] as const) {
+    it(`reaches no step on ${choice}: the flow's next step is the rest`, async () => {
+      const rest = await restOf(shape(choice, ["a.ts"]))
+      expect(rest.name).toBe("next")
+    })
+  }
+
+  it("rests at an approve human step named after the caller on refactor-first", async () => {
+    const rest = await restOf(shape("refactor-first", ["a.ts"]))
+    expect(rest.name).toBe("seam")
+    expect(rest.request).toMatchObject({ kind: "human", options: { approve: true } })
+  })
+
+  it("lists every stray in order, marks only the unreadable, names gtd land and gtd abandon", async () => {
+    const rest = await restOf(shape("refactor-first", ["a.ts", "b/c.ts", "z.bin"], ["b/c.ts"]))
+    if (rest.request.kind !== "human") throw new Error("expected a human step")
+    const message = rest.request.options.message ?? ""
+    const lines = message.split("\n")
+    const strays = lines.filter((line) => line.startsWith("- "))
+    expect(strays).toEqual(["- a.ts", "- b/c.ts (unreadable — not judged)", "- z.bin"])
+    expect(message).toMatch(/`gtd land`[^\n]*approve/)
+    expect(message).toContain("`gtd abandon`")
+  })
+
+  it("quotes a stray path with a control character", async () => {
+    const rest = await restOf(shape("refactor-first", ["a\nb", "c\u001b[2K"]))
+    if (rest.request.kind !== "human") throw new Error("expected a human step")
+    const strays = (rest.request.options.message ?? "")
+      .split("\n")
+      .filter((line) => line.startsWith("- "))
+    expect(strays).toEqual(['- "a\\nb"', '- "c\\u001b[2K"'])
+  })
+})

package/src/step/LandStep.ts

@@ -8,6 +8,7 @@ import type { StateName } from "../workflow/index.js"
  */
 export type GitWrite =
   | { readonly kind: "commitAll"; readonly message: string }
+  | { readonly kind: "commitClean"; readonly message: string }
   | { readonly kind: "updateRef"; readonly ref: string; readonly target: "HEAD" }
   | { readonly kind: "keepTurn"; readonly ref: string; readonly message: string }
 

package/src/step/planStart.ts

@@ -4,7 +4,8 @@ import {
   ConfigDiscovery,
   ConfigService,
   multilineSetting,
-  resolveVars,
+  resolveStartVars,
+  StartFlags,
   type ConfigFingerprint,
   type ResolvedWorkflow,
 } from "../workflow/index.js"
@@ -109,7 +110,7 @@ export const planStart = (
     if (overrideRefusal !== undefined) return overrideRefusal
 
     const baseOf = workflow.def.base
-    const vars = resolveVars(workflow.vars, varOverrides, (yield* Host).env)
+    const vars = resolveStartVars(workflow.vars, yield* StartFlags, varOverrides, (yield* Host).env)
     const multiline = multilineSetting(vars)
     if (multiline !== undefined) {
       return refusal(

package/src/step/planStep.test.ts

@@ -131,6 +131,38 @@ describe("planStep — keepHistory", () => {
   })
 })
 
+describe("planStep — approval landing", () => {
+  const approved = { step: { name: "gate", occurrence: 1 }, name: "Ada", email: "ada@x.io" }
+
+  it("commits with commitClean when the landing records an approval", () => {
+    const base = commitTo("gate", "again")
+    const s = snapshot({
+      state: "gate",
+      stepDef: {},
+      landing: { ...base, spec: { ...base.spec, approved } },
+    })
+    const outcome = planStep(s)
+    if (outcome.kind !== "commit") throw new Error(`expected commit, got ${outcome.kind}`)
+    expect(outcome.steps[0]).toMatchObject({ write: { kind: "commitClean" } })
+  })
+
+  it("a finishing approval still points the history ref after the commitClean write", () => {
+    const base = commitTo("gate", "idle")
+    const s = snapshot({
+      state: "gate",
+      stepDef: {},
+      landing: { ...base, spec: { ...base.spec, approved }, keepHistory: "refs/gtd/history/abc" },
+    })
+    const outcome = planStep(s)
+    if (outcome.kind !== "commit") throw new Error(`expected commit, got ${outcome.kind}`)
+    expect(outcome.steps.map((x) => (x.kind === "gitWrite" ? x.write.kind : x.kind))).toEqual([
+      "commitClean",
+      "updateRef",
+      "outcome",
+    ])
+  })
+})
+
 describe("planStep — keepTurn", () => {
   const kept = "refs/gtd/kept/abc/building"
 

package/src/step/planStep.ts

@@ -87,7 +87,9 @@ export const planStep = (
         write:
           landing.keepTurn !== undefined
             ? { kind: "keepTurn", ref: landing.keepTurn, message }
-            : { kind: "commitAll", message },
+            : landing.spec.approved !== undefined
+              ? { kind: "commitClean", message }
+              : { kind: "commitAll", message },
       },
       ...(landing.keepHistory !== undefined
         ? [

package/src/testkit/EmittedScriptRecognizer.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest"
 import {
   commitAll,
   commitAsIs,
+  commitClean,
   deleteRef,
   discardPending,
   hardResetTo,
@@ -664,3 +665,29 @@ describe("applyEmittedScript — keepTurn", () => {
     expect(repo.resolveRef(REF)).toBeNull()
   })
 })
+
+describe("applyEmittedScript — commitClean", () => {
+  const MESSAGE = 'gtd(human): gate → again\n\nGtd-Approved: {"step":"gate#1"}'
+
+  it("applies the rendered block as an empty commit over HEAD", () => {
+    const repo = new InMemRepo()
+    repo.writeFile("base.txt", "0")
+    repo.seedCommit("chore: first")
+    const result = applyEmittedScript(repo, NO_COMMANDS, commitClean(MESSAGE))
+    expect(result).toMatchObject({ ok: true })
+    expect(repo.lastCommitMessage()).toBe(MESSAGE)
+    expect(repo.statusPorcelain()).toBe("")
+  })
+
+  it("fails loudly on a one-character near-miss and applies nothing", () => {
+    const repo = new InMemRepo()
+    repo.writeFile("base.txt", "0")
+    repo.seedCommit("chore: first")
+    const before = snapshot(repo)
+    const nearMiss = commitClean(MESSAGE).replace("update-ref -m", "update-ref -n")
+    const result = applyEmittedScript(repo, NO_COMMANDS, nearMiss)
+    expect(result.ok).toBe(false)
+    expect(result.error).toContain("unrecognized script block")
+    expect(snapshot(repo)).toEqual(before)
+  })
+})

package/src/testkit/EmittedScriptRecognizer.ts

@@ -6,6 +6,7 @@
 import {
   commitAll,
   commitAsIs,
+  commitClean,
   deleteRef,
   discardPending,
   hardResetTo,
@@ -185,6 +186,17 @@ const recognizeGitBuilders = (repo: InMemRepo, block: string): BlockOutcome | un
     return undefined
   }
 
+  if (block.startsWith("gtd_head=$(git rev-parse --verify HEAD) || exit 1\nif [ -n ")) {
+    const [message] = extractQuotedTokens(block.slice(block.indexOf('"$gtd_head" -m ')))
+    if (message !== undefined && commitClean(message) === block) {
+      const failure = repo.commitClean(message)
+      return failure === undefined
+        ? { kind: "applied" }
+        : { kind: "failed", error: failure, status: 1 }
+    }
+    return undefined
+  }
+
   if (block.startsWith("if ! out=$(git commit --allow-empty -m ")) {
     const [message] = extractQuotedTokens(conditionLine)
     if (message !== undefined && commitAsIs(message) === block) {

package/src/testkit/FakeGitOperations.ts

@@ -77,7 +77,12 @@ const makeGitReaderOps = (repo: InMemRepo, root: string): GitReaderOperations =>
 
   changedPaths: (base?: string) => Effect.succeed(repo.changedPathsWorktree(base)),
 
+  stagedPaths: () => Effect.succeed(repo.stagedPaths()),
+
   diffPaths: (base: string, tip: string) => tryCatch(() => repo.diffPaths(base, tip)),
+
+  // The identity `GitTiers`' live tier configures; the fake commits as no one in particular.
+  authorIdent: () => Effect.succeed(Option.some({ name: "Test", email: "test@test.com" })),
 })
 
 const failOn = (output: string | undefined): void => {

package/src/testkit/GitTiers.ts

@@ -23,6 +23,7 @@ import { Narrator, GitService, Host, type GitOperations } from "../platform/inde
 import {
   commitAll,
   commitAsIs,
+  commitClean,
   softResetTo,
   mixedResetTo,
   hardResetTo,
@@ -81,6 +82,8 @@ export interface GitTierSeed {
   readonly stagingHook: (path: string, content: string) => void
   /** Every commit `git commit` signs, or `git commit-tree -S` writes, fails; plain `git commit-tree` is unaffected. */
   readonly failingSigner: () => void
+  /** `commit.gpgSign=true` with a signer that succeeds; `git commit` and `commit-tree -S` both sign. */
+  readonly workingSigner: () => void
 }
 
 export interface GitTierObserve {
@@ -94,6 +97,8 @@ export interface GitTierObserve {
   readonly headSubject: () => string
   /** Paths HEAD's own commit touched, against its parent — not the whole tree. */
   readonly headTouchedPaths: () => ReadonlyArray<string>
+  /** True when HEAD's commit object carries a signature (`gpgsig` header). */
+  readonly headSigned: () => boolean
 }
 
 export interface GitTier {
@@ -233,6 +238,18 @@ const makeLiveTier = (initialCommit = true): GitTier => {
         gitExec("config", "gpg.format", "openpgp")
         gitExec("config", "gpg.program", "false")
       },
+      workingSigner: () => {
+        const signer = join(root, ".git/gtd-test-signer.sh")
+        // git checks `[GNUPG:] SIG_CREATED ` on stderr (--status-fd=2) and takes stdout as the signature.
+        writeFileSync(
+          signer,
+          `#!/bin/sh\ncat >/dev/null\nprintf '%s\\n' '-----BEGIN PGP SIGNATURE-----' '' 'ZHVtbXk=' '-----END PGP SIGNATURE-----'\nprintf '\\n[GNUPG:] SIG_CREATED ' >&2\n`,
+          { mode: 0o755 },
+        )
+        gitExec("config", "commit.gpgsign", "true")
+        gitExec("config", "gpg.format", "openpgp")
+        gitExec("config", "gpg.program", signer)
+      },
     },
     observe: {
       resolveRef: (ref) => gitExec("rev-parse", ref),
@@ -268,6 +285,7 @@ const makeLiveTier = (initialCommit = true): GitTier => {
         gitExec("show", "--name-only", "--pretty=format:", "HEAD")
           .split("\n")
           .filter((line) => line.length > 0),
+      headSigned: () => gitExec("cat-file", "commit", "HEAD").includes("\ngpgsig "),
     },
     runScript: (script) => {
       // One stream, as a driver's terminal shows it.
@@ -345,6 +363,9 @@ const makeInMemTier = (initialCommit = true): GitTier => {
       failingSigner: () => {
         repo.signingFails = true
       },
+      workingSigner: () => {
+        repo.signingEnabled = true
+      },
     },
     observe: {
       resolveRef: (ref) => {
@@ -369,6 +390,7 @@ const makeInMemTier = (initialCommit = true): GitTier => {
           .filter((p) => repo.fileAtRef("HEAD~1", p) !== repo.fileAtRef("HEAD", p))
           .sort()
       },
+      headSigned: () => repo.headSigned(),
     },
     runScript: (script, commands = new Map()) => {
       const { ok, status, output, error } = applyEmittedScript(repo, commands, script)
@@ -409,7 +431,9 @@ export const CONTRACT_COVERED_OPERATIONS: ReadonlySet<keyof GitOperations> = new
   "subjectHistory",
   "readFileAtRef",
   "changedPaths",
+  "stagedPaths",
   "diffPaths",
+  "authorIdent",
   "commitAllWithPrefix",
   "softResetTo",
   "commitAsIs",
@@ -481,7 +505,9 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
         g.readFileAtRef("HEAD", "second.txt"),
         g.changedPaths(),
         g.changedPaths("HEAD~1"),
+        g.stagedPaths(),
         g.diffPaths("HEAD~1", "HEAD"),
+        g.authorIdent(),
       ]),
     )
     expect(await t.observe.snapshot()).toBe(before)
@@ -1071,6 +1097,14 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
       expect(await runGit(t, (g) => g.changedPaths())).toEqual([])
     })
 
+    it("ignores an edit staged and then reverted in the worktree", async () => {
+      t.seed.commit("chore: seed", { "a.txt": "1" })
+      t.seed.writeFile("a.txt", "2")
+      t.seed.stageAll()
+      t.seed.writeFile("a.txt", "1")
+      expect(await runGit(t, (g) => g.changedPaths())).toEqual([])
+    })
+
     for (const { label, path } of PATHOLOGICAL_PATHS) {
       it(`reports an untracked path containing ${label}, verbatim`, async () => {
         t.seed.writeFile(path, "content")
@@ -1172,6 +1206,43 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
     })
   })
 
+  describe("stagedPaths", () => {
+    it("returns [] when the index matches HEAD, whatever the worktree holds", async () => {
+      t.seed.commit("chore: seed", { "a.txt": "1" })
+      t.seed.writeFile("a.txt", "2")
+      t.seed.writeFile("u.txt", "u")
+      expect(await runGit(t, (g) => g.stagedPaths())).toEqual([])
+    })
+
+    it("reports an edit staged and then reverted in the worktree", async () => {
+      t.seed.commit("chore: seed", { "a.txt": "1" })
+      t.seed.writeFile("a.txt", "2")
+      t.seed.stageAll()
+      t.seed.writeFile("a.txt", "1")
+      expect(await runGit(t, (g) => g.stagedPaths())).toEqual([{ path: "a.txt", status: "M" }])
+    })
+
+    it("reports staged additions and deletions", async () => {
+      t.seed.commit("chore: seed", { "gone.txt": "g" })
+      t.seed.deleteFile("gone.txt")
+      t.seed.writeFile("new.txt", "n")
+      t.seed.stageAll()
+      const staged = await runGit(t, (g) => g.stagedPaths())
+      expect([...staged].sort((a, b) => a.path.localeCompare(b.path))).toEqual([
+        { path: "gone.txt", status: "D" },
+        { path: "new.txt", status: "A" },
+      ])
+    })
+  })
+
+  describe("authorIdent", () => {
+    it("is the configured name and email", async () => {
+      expect(await runGit(t, (g) => g.authorIdent())).toEqual(
+        Option.some({ name: "Test", email: "test@test.com" }),
+      )
+    })
+  })
+
   describe("topLevel", () => {
     it("resolves to this tier's own root", async () => {
       expect(await runGit(t, (g) => g.topLevel())).toBe(t.root)
@@ -1286,6 +1357,93 @@ export const runGitScriptContract = (makeTier: () => GitTier): void => {
     })
   })
 
+  describe("commitClean", () => {
+    it("on a clean tree commits an empty commit with the message", () => {
+      const headBefore = t.observe.resolveRef("HEAD")
+      run(t, commitClean("gtd(human): gate → again"))
+      expect(t.observe.resolveRef("HEAD")).not.toBe(headBefore)
+      expect(t.observe.headSubject()).toBe("gtd(human): gate → again")
+      expect(t.observe.headTouchedPaths()).toEqual([])
+    })
+
+    it("a staging hook never runs: nothing touched, nothing staged, file absent", () => {
+      const headBefore = t.observe.resolveRef("HEAD")
+      t.seed.stagingHook("hooked.txt", "hooked")
+      run(t, commitClean("gtd(human): gate → again"))
+      expect(t.observe.headTouchedPaths()).toEqual([])
+      expect(t.observe.resolveRef("HEAD^")).toBe(headBefore)
+      expect(t.observe.statusPorcelain().trim()).toBe("")
+      expect(t.observe.existsPath("hooked.txt")).toBe(false)
+    })
+
+    it("a rejecting hook is never consulted", () => {
+      t.seed.rejectingHook("rejected")
+      run(t, commitClean("gtd(human): gate → again"))
+      expect(t.observe.headSubject()).toBe("gtd(human): gate → again")
+    })
+
+    it("a working signer signs the approval", () => {
+      t.seed.workingSigner()
+      run(t, commitClean("gtd(human): gate → again"))
+      expect(t.observe.headSigned()).toBe(true)
+    })
+
+    it("no signing config: the approval does not try to sign", () => {
+      run(t, commitClean("gtd(human): gate → again"))
+      expect(t.observe.headSigned()).toBe(false)
+    })
+
+    it("a failing signer fails the approval: HEAD and status unchanged", () => {
+      t.seed.failingSigner()
+      const headBefore = t.observe.resolveRef("HEAD")
+      const result = t.runScript(commitClean("gtd(human): gate → again"))
+      expect(result.ok).toBe(false)
+      expect(result.status).toBe(1)
+      expect(result.output).toContain("failed to sign")
+      expect(t.observe.resolveRef("HEAD")).toBe(headBefore)
+      expect(t.observe.statusPorcelain().trim()).toBe("")
+    })
+
+    const refused = (name: string, dirty: () => void, pending: string): void => {
+      it(`${name}: fails, HEAD unchanged, edit still pending`, () => {
+        dirty()
+        const headBefore = t.observe.resolveRef("HEAD")
+        const result = t.runScript(commitClean("gtd(human): gate → again"))
+        expect(result.ok).toBe(false)
+        expect(result.output).toContain("changed since `gtd land`")
+        expect(t.observe.resolveRef("HEAD")).toBe(headBefore)
+        expect(t.observe.statusPorcelain()).toContain(pending)
+      })
+    }
+    refused(
+      "a modified tracked file",
+      () => {
+        t.seed.commit("feat: base", { "a.txt": "1" })
+        t.seed.writeFile("a.txt", "2")
+      },
+      "a.txt",
+    )
+    refused(
+      "a staged change",
+      () => {
+        t.seed.writeFile("s.txt", "s")
+        t.seed.stageAll()
+      },
+      "s.txt",
+    )
+    refused("an untracked file", () => t.seed.writeFile("u.txt", "u"), "u.txt")
+    refused(
+      "an edit staged then reverted in the worktree",
+      () => {
+        t.seed.commit("feat: base", { "a.txt": "1" })
+        t.seed.writeFile("a.txt", "2")
+        t.seed.stageAll()
+        t.seed.writeFile("a.txt", "1")
+      },
+      "a.txt",
+    )
+  })
+
   describe("commitAsIs", () => {
     it("does NOT stage — a worktree write after staging is excluded (the squash mechanic)", () => {
       t.seed.writeFile("a.txt", "a")

package/src/testkit/InMemRepo.ts

@@ -1,5 +1,6 @@
-// Pure TypeScript, no Effect, no real filesystem/git.
+// No real filesystem/git.
 import { createHash } from "node:crypto"
+import { CHANGED_SINCE_LAND } from "../emit/index.js"
 
 /** Embedded in every value this fake reaches (see also `strictGitOperations`'s default message) so `scripts/assert-no-test-doubles.mjs` can catch a leak into the shipped bundle by string search. */
 export const TEST_DOUBLE_SENTINEL = "gtd:test-double:never-ship"
@@ -11,6 +12,7 @@ interface Commit {
   parent: string | null
   /** Creation order — the twin's stand-in for a committer date. */
   seq: number
+  readonly signed: boolean
 }
 
 function sha1(input: string): string {
@@ -270,6 +272,11 @@ export class InMemRepo {
     return diffTrees(baseTree, worktreeTree)
   }
 
+  /** The index vs HEAD — the port's `stagedPaths`. */
+  stagedPaths(): Array<{ path: string; status: string }> {
+    return diffTrees(this.treeAt(undefined), this.index)
+  }
+
   diffPaths(base: string, tip: string): string[] {
     for (const ref of [base, tip]) {
       if (this.resolveRef(ref) === null) throw new Error(`Invalid ref: ${ref}`)
@@ -346,6 +353,7 @@ export class InMemRepo {
   /** Seeded failure modes (see `GitTierSeed`): a pre-commit hook printing this and exiting 1, and a signer that cannot write. */
   hookRejection: string | undefined = undefined
   signingFails = false
+  signingEnabled = false
   /** Seeded: a pre-commit hook writing and staging this file. */
   hookStages: { readonly path: string; readonly content: string } | undefined = undefined
 
@@ -353,7 +361,14 @@ export class InMemRepo {
     const tree = new Map(this.index)
     const parent = this.head
     const hash = makeHash(message, parent, tree)
-    const commit: Commit = { hash, message, files: new Map(tree), parent, seq: this.nextSeq++ }
+    const commit: Commit = {
+      hash,
+      message,
+      files: new Map(tree),
+      parent,
+      seq: this.nextSeq++,
+      signed: this.signingEnabled,
+    }
     this.commits.set(hash, commit)
     this.head = hash
     this.branches.set(this.currentBranch, hash)
@@ -378,6 +393,19 @@ export class InMemRepo {
     return undefined
   }
 
+  /** Twin of `GitScript.commitClean`: no hook runs, HEAD's tree is recorded; `undefined` on success, else the stderr text. */
+  commitClean(message: string): string | undefined {
+    if (this.head === null) return "fatal: Needed a single revision"
+    if (this.statusPorcelain().trim() !== "") return CHANGED_SINCE_LAND
+    if (this.signingFails) return "error: gpg failed to sign the data"
+    this.writeCommit(message)
+    return undefined
+  }
+
+  headSigned(): boolean {
+    return this.headCommit()?.signed === true
+  }
+
   /** Setup commit: stages everything, and throws if a failure is seeded, as the Live tier's hooks and signer would. */
   seedCommit(message: string): void {
     if (this.hookRejection !== undefined || this.hookStages !== undefined || this.signingFails) {
@@ -393,7 +421,14 @@ export class InMemRepo {
     const tree = new Map(this.index)
     const parent = this.head
     const hash = makeHash(message, parent, tree)
-    this.commits.set(hash, { hash, message, files: new Map(tree), parent, seq: this.nextSeq++ })
+    this.commits.set(hash, {
+      hash,
+      message,
+      files: new Map(tree),
+      parent,
+      seq: this.nextSeq++,
+      signed: false,
+    })
     const ref = `${refPrefix}/${hash}`
     this.refs.set(ref, hash)
     this.index = new Map(this.headTree())

package/src/testkit/TestRepo.ts

@@ -70,6 +70,8 @@ export interface TestRepo {
   drive(actors?: Actors, options?: DriveOptions): Promise<BeatDocument>
   /** Oldest first. */
   subjects(): readonly string[]
+  /** Every commit's full message, subject and trailers, oldest first. */
+  messages(): readonly string[]
 }
 
 const REGISTRY = Symbol.for("@pmelab/gtd/testkit:modules")
@@ -272,6 +274,7 @@ export const testRepo = (options: TestRepoOptions): TestRepo => {
       throw new Error(`the process did not rest within ${maxBeats} beats`)
     },
     subjects: () => repo.commitHistory().map(({ message }) => message.split("\n")[0] ?? ""),
+    messages: () => repo.commitHistory().map(({ message }) => message),
   }
   return self
 }

package/src/testkit/steps.ts

@@ -36,6 +36,12 @@ export class TestkitWorld extends QuickPickleWorld {
     this.gtdConfig = config
   }
 
+  extendConfig(tail: string): void {
+    this.assertNotCreated("a gtd config")
+    if (this.gtdConfig === undefined) throw new Error("no gtd config to extend")
+    this.gtdConfig += `\n${tail}`
+  }
+
   setEnv(name: string, value: string): void {
     this.assertNotCreated(`the environment variable ${name}`)
     this.env[name] = value
@@ -79,6 +85,10 @@ Given("a gtd config with:", (world: TestkitWorld, source: string) => {
   world.configure(withNewline(source))
 })
 
+Given("the gtd config ends with:", (world: TestkitWorld, source: string) => {
+  world.extendConfig(withNewline(source))
+})
+
 Given(
   "an environment variable {string} set to {string}",
   (world: TestkitWorld, name: string, value: string) => {
@@ -180,6 +190,14 @@ Then("the resting step's content contains {string}", async (world: TestkitWorld,
   assert.ok(content.includes(text), content)
 })
 
+Then(
+  "the resting step's content does not contain {string}",
+  async (world: TestkitWorld, text: string) => {
+    const { content } = await world.repo().next()
+    assert.ok(!content.includes(text), content)
+  },
+)
+
 Then("the last commit subject is {string}", (world: TestkitWorld, subject: string) => {
   assert.strictEqual(world.repo().subjects().at(-1), subject)
 })