@pmelab/gtd 63.0.0 → 64.0.0

package/src/platform/WorktreeState.test.ts

@@ -11,14 +11,14 @@ import { join } from "node:path"
 import { mkdtempSync, realpathSync } from "node:fs"
 import { execSync } from "node:child_process"
 import { tmpdir } from "node:os"
-import { Effect, Layer } from "effect"
+import { Effect, Layer, type Path } from "effect"
 import { describe, expect, it } from "vitest"
 import { loopLogPath, worktreeGitDir } from "./WorktreeState.js"
 import { GitService, Host, Workspace, NodeServices } from "./index.js"
 import { InMemRepo, testLayers } from "../twins/index.js"
 
 const provide = <A>(
-  eff: Effect.Effect<A, never, Host | Workspace>,
+  eff: Effect.Effect<A, never, Host | Path.Path | Workspace>,
   repo: InMemRepo,
   opts: {
     readonly root?: string
@@ -112,9 +112,13 @@ describe("worktreeGitDir [real git]", () => {
   const runIn = (root: string) => {
     const hostLayer = Host.layer({ root, home: root, env: {} })
     const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeServices.layer)))
-    const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
+    const workspaceLayer = Workspace.Live.pipe(
+      Layer.provide(Layer.mergeAll(hostLayer, gitLayer, NodeServices.layer)),
+    )
     return Effect.runPromise(
-      worktreeGitDir.pipe(Effect.provide(Layer.mergeAll(hostLayer, workspaceLayer))),
+      worktreeGitDir.pipe(
+        Effect.provide(Layer.mergeAll(hostLayer, workspaceLayer, NodeServices.layer)),
+      ),
     )
   }
 

package/src/platform/WorktreeState.ts

@@ -1,5 +1,4 @@
-import { isAbsolute, join } from "node:path"
-import { Effect } from "effect"
+import { Effect, Path } from "effect"
 import { Host } from "./Host.js"
 import { Workspace } from "./Workspace.js"
 
@@ -11,9 +10,10 @@ const GITDIR_POINTER = /^gitdir:\s*(.+)$/m
  * read failure or a `.git` file with no `gitdir:` line both fall back to
  * `".git"`, which is also correct for the in-memory test tier.
  */
-export const worktreeGitDir: Effect.Effect<string, never, Host | Workspace> = Effect.gen(
-  function* () {
+export const worktreeGitDir: Effect.Effect<string, never, Host | Path.Path | Workspace> =
+  Effect.gen(function* () {
     const { root } = yield* Host
+    const path = yield* Path.Path
     const workspace = yield* Workspace
     const content = yield* workspace
       .read(".git")
@@ -21,9 +21,8 @@ export const worktreeGitDir: Effect.Effect<string, never, Host | Workspace> = Ef
     const pointer = content === undefined ? null : GITDIR_POINTER.exec(content)
     if (pointer === null) return ".git"
     const gitdir = pointer[1]!.trim()
-    return isAbsolute(gitdir) ? gitdir : join(root, gitdir)
-  },
-)
+    return path.isAbsolute(gitdir) ? gitdir : path.join(root, gitdir)
+  })
 
 /**
  * The per-worktree loop log path `gtd next --json` reports as `log`.
@@ -34,17 +33,20 @@ export const worktreeGitDir: Effect.Effect<string, never, Host | Workspace> = Ef
  * doesn't want that (e.g. the e2e suite) must scrub it before invoking gtd.
  * Advisory only — gtd neither creates nor truncates the file.
  */
-export const loopLogPath: Effect.Effect<string, never, Host | Workspace> = Effect.gen(function* () {
-  const { root, env } = yield* Host
-  const override = env.GTD_LOOP_LOG
-  if (override !== undefined && override !== "") return override
+export const loopLogPath: Effect.Effect<string, never, Host | Path.Path | Workspace> = Effect.gen(
+  function* () {
+    const { root, env } = yield* Host
+    const path = yield* Path.Path
+    const override = env.GTD_LOOP_LOG
+    if (override !== undefined && override !== "") return override
 
-  const gitDirEnv = env.GIT_DIR
-  if (gitDirEnv !== undefined && gitDirEnv !== "") {
-    const gitDir = isAbsolute(gitDirEnv) ? gitDirEnv : join(root, gitDirEnv)
-    return join(gitDir, "gtd-loop.log")
-  }
+    const gitDirEnv = env.GIT_DIR
+    if (gitDirEnv !== undefined && gitDirEnv !== "") {
+      const gitDir = path.isAbsolute(gitDirEnv) ? gitDirEnv : path.join(root, gitDirEnv)
+      return path.join(gitDir, "gtd-loop.log")
+    }
 
-  const gitDir = yield* worktreeGitDir
-  return join(gitDir, "gtd-loop.log")
-})
+    const gitDir = yield* worktreeGitDir
+    return path.join(gitDir, "gtd-loop.log")
+  },
+)

package/src/platform/index.ts

@@ -1,7 +1,8 @@
 /**
- * gtd's two ports onto its environment: `Workspace` (repo file content —
- * working-tree reads/writes plus the read-at-ref path) and `Host` (root,
- * home, env, scratch). `GitService` moved in alongside `Workspace` since
+ * gtd's ports onto its environment: `Workspace` (repo file content —
+ * working-tree reads/writes plus the read-at-ref path), `Host` (root,
+ * home, env, scratch, process identity, stdio) and `SyncIo`, the reads that
+ * must stay synchronous, which only `Node*.ts` implements against Node. `GitService` moved in alongside `Workspace` since
  * `committed` IS `git.readFileAtRef` — one module owns every read.
  *
  * Seam rule, stated once: a seam is a `Context.Service` unless the consuming
@@ -9,7 +10,14 @@
  * reads are that exception, and use the `*Sync` members.
  */
 export { Workspace, type WorkspaceOps } from "./Workspace.js"
-export { Host, type HostOps } from "./Host.js"
+export {
+  Host,
+  nodeStdio,
+  scratchDirOf,
+  type HostOps,
+  type NodeProcess,
+  type Stdio,
+} from "./Host.js"
 export {
   GitService,
   type GitOperations,
@@ -29,4 +37,9 @@ export {
   readRetainedHistory,
   restorability,
 } from "./RetainedHistory.js"
-export { livePinFile, runPinModule, type PinFile } from "./PinFile.js"
+export { livePinFile, runPinModule } from "./NodePinFile.js"
+export type { PinFile } from "./PinFile.js"
+export type { FileInfo, SyncIo } from "./SyncIo.js"
+export { nodeSyncIo } from "./NodeSync.js"
+export { pureHash } from "./Sha.js"
+export * as NodeRuntime from "./NodeRuntime.js"

package/src/replay/Format.test.ts

@@ -3,12 +3,13 @@ import { formatCommitMessage, formatFault, parseCommitMessage } from "./index.js
 
 describe("the history format", () => {
   it("accepts a history in the current format and in the one before it", () => {
-    expect(formatFault([{ hash: "a".repeat(40), format: 3 }])).toBeUndefined()
+    expect(formatFault([{ hash: "a".repeat(40), format: 4 }])).toBeUndefined()
     expect(
       formatFault([
         { hash: "a".repeat(40), format: 1 },
         { hash: "b".repeat(40), format: 2 },
         { hash: "c".repeat(40), format: 3 },
+        { hash: "d".repeat(40), format: 4 },
       ]),
     ).toBeUndefined()
     expect(formatFault([])).toBeUndefined()
@@ -17,11 +18,11 @@ describe("the history format", () => {
   it("names the first foreign commit, the found and readable formats, and what to do", () => {
     const fault = formatFault([
       { hash: "a".repeat(40), format: 1 },
-      { hash: "b".repeat(40), format: 4 },
-      { hash: "c".repeat(40), format: 5 },
+      { hash: "b".repeat(40), format: 5 },
+      { hash: "c".repeat(40), format: 6 },
     ])
     expect(fault).toBe(
-      "gtd: commit bbbbbbb is written in history format 4, but this gtd reads formats 1 to 3 — run a gtd release that reads format 4 to continue this process",
+      "gtd: commit bbbbbbb is written in history format 5, but this gtd reads formats 1 to 4 — run a gtd release that reads format 5 to continue this process",
     )
   })
 })
@@ -36,8 +37,8 @@ describe("Gtd-Approved and the history format", () => {
     expect(message).toContain(
       'Gtd-Approved: {"step":"seam#1","name":"Test","email":"test@test.com"}',
     )
-    expect(message).toContain("Gtd-Format: 3")
-    expect(parseCommitMessage(message).format).toBe(3)
+    expect(message).toContain("Gtd-Format: 4")
+    expect(parseCommitMessage(message).format).toBe(4)
   })
 })
 
@@ -45,20 +46,20 @@ describe("Gtd-Pin", () => {
   it("round-trips add and remove, after Gtd-Mark and before Gtd-Branch", () => {
     const message = formatCommitMessage({
       actor: "check",
-      from: "unpin",
+      from: "gtd:unpin",
       to: "idle",
       pin: "remove",
       branch: "main",
     })
     expect(message).toBe(
-      "gtd(check): unpin → idle\n\nGtd-Pin: remove\nGtd-Branch: main\nGtd-Format: 3",
+      "gtd(check): gtd:unpin → idle\n\nGtd-Pin: remove\nGtd-Branch: main\nGtd-Format: 4",
     )
     expect(parseCommitMessage(message).pin).toBe("remove")
-    expect(parseCommitMessage("gtd(check): pin → a\n\nGtd-Pin: add").pin).toBe("add")
+    expect(parseCommitMessage("gtd(check): gtd:pin → a\n\nGtd-Pin: add").pin).toBe("add")
   })
 
   it("reads an unknown value as no pin", () => {
-    expect(parseCommitMessage("gtd(check): pin → a\n\nGtd-Pin: frozen").pin).toBeUndefined()
+    expect(parseCommitMessage("gtd(check): gtd:pin → a\n\nGtd-Pin: frozen").pin).toBeUndefined()
   })
 })
 
@@ -67,15 +68,17 @@ describe("Gtd-Anchor", () => {
     const anchor = "a".repeat(40)
     const message = formatCommitMessage({
       actor: "check",
-      from: "pin",
+      from: "gtd:pin",
       to: "b",
       pin: "add",
       anchor,
     })
     expect(message).toBe(
-      `gtd(check): pin → b\n\nGtd-Pin: add\nGtd-Anchor: ${anchor}\nGtd-Format: 3`,
+      `gtd(check): gtd:pin → b\n\nGtd-Pin: add\nGtd-Anchor: ${anchor}\nGtd-Format: 4`,
     )
     expect(parseCommitMessage(message).anchor).toBe(anchor)
-    expect(parseCommitMessage("gtd(check): pin → b\n\nGtd-Anchor: HEAD~2").anchor).toBeUndefined()
+    expect(
+      parseCommitMessage("gtd(check): gtd:pin → b\n\nGtd-Anchor: HEAD~2").anchor,
+    ).toBeUndefined()
   })
 })

package/src/replay/Format.ts

@@ -1,8 +1,10 @@
 // Bump only when what replay reads back out of git changes incompatibly — the
 // package version must not stand in for it, since most majors leave history
 // untouched. Format 2 adds pin commits, which format 1 would replay as turns;
-// format 3 adds the anchor, whose set-aside commits format 2 would replay.
-export const HISTORY_FORMAT = 3
+// format 3 adds the anchor, whose set-aside commits format 2 would replay;
+// format 4 renames the pin beats `gtd:pin`/`gtd:unpin`, which format 3 would
+// read as steps.
+export const HISTORY_FORMAT = 4
 const OLDEST_READABLE_FORMAT = 1
 
 const short = (hash: string): string => hash.slice(0, 7)

package/src/replay/Replay.test.ts

@@ -1226,7 +1226,7 @@ describe("pin commits", () => {
   const pinned = () =>
     new History()
       .land("human", "idle", 1, "build", { "NOTE.md": "n" })
-      .raw("gtd(check): pin → build\n\nGtd-Pin: add", { [PIN]: "gtdpin 1 gtd 1\n" })
+      .raw("gtd(check): gtd:pin → build\n\nGtd-Pin: add", { [PIN]: "gtdpin 1 gtd 1\n" })
 
   it("are never a turn: the next step answers from the commit after the pin", async () => {
     const flow = async () => {
@@ -1268,15 +1268,15 @@ describe("pin commits", () => {
       await agent("build", "b")
     }
     const h = pinned()
-      .land("agent", "build", 1, "unpin", { "a.ts": "a" })
-      .raw("gtd(check): unpin → idle\n\nGtd-Pin: remove", { [PIN]: null })
+      .land("agent", "build", 1, "gtd:unpin", { "a.ts": "a" })
+      .raw("gtd(check): gtd:unpin → idle\n\nGtd-Pin: remove", { [PIN]: null })
     expect((await replayOf(flow, h)).kind).toBe("ended")
   })
 })
 
 describe("replay: a repin's anchor", () => {
   const anchorTo = (to: string, at: number): string =>
-    formatCommitMessage({ actor: "check", from: "pin", to, pin: "add", anchor: hashOf(at) })
+    formatCommitMessage({ actor: "check", from: "gtd:pin", to, pin: "add", anchor: hashOf(at) })
 
   // The old flow went idle → build → old; this one goes idle → build → check.
   const anchoredHistory = (): History =>
@@ -1345,11 +1345,31 @@ describe("replay: a repin's anchor", () => {
     const h = new History()
       .land("human", "idle", 1, "build", { "a.txt": "a" })
       .land("agent", "build", 1, "old")
-      .raw(anchorTo("unpin", 1))
+      .raw(anchorTo("gtd:unpin", 1))
     const outcome = await replayOf(async () => void (await human("idle")), h)
     expect(outcome.kind).toBe("ended")
   })
 
+  it("closes the process when a format 3 anchor names the unpin by its old name", async () => {
+    const h = new History()
+      .land("human", "idle", 1, "build", { "a.txt": "a" })
+      .land("agent", "build", 1, "old")
+      .raw(`gtd(check): pin → unpin\n\nGtd-Pin: add\nGtd-Anchor: ${hashOf(1)}\nGtd-Format: 3`)
+    const outcome = await replayOf(async () => void (await human("idle")), h)
+    expect(outcome.kind).toBe("ended")
+  })
+
+  it("reads a format 4 anchor naming unpin as a step", async () => {
+    const outcome = await replayOf(
+      async () => void (await human("idle")),
+      new History()
+        .land("human", "idle", 1, "build", { "a.txt": "a" })
+        .land("agent", "build", 1, "old")
+        .raw(anchorTo("unpin", 1)),
+    )
+    expect(outcome).toMatchObject({ kind: "divergence", reached: undefined })
+  })
+
   it("fails when it names no commit replay reads", async () => {
     const h = anchoredHistory().raw(anchorTo("build", 2))
     const outcome = await replayOf(async () => void (await human("idle")), h)

package/src/replay/Replay.ts

@@ -29,10 +29,14 @@ import {
   type CommitMessage,
   type JudgeVerdict,
   type StepId,
-  PIN_STATES,
+  ENGINE_PREFIX,
+  pinStateIn,
 } from "./Trailers.js"
 
-const UNPIN_STATE = PIN_STATES.remove
+const namesUnpin = (commit: ParsedCommit): boolean => {
+  const unpin = pinStateIn(commit.parsed.format, "remove")
+  return unpin !== undefined && commit.parsed.parsed?.to === unpin
+}
 
 export interface EpisodeCommit {
   readonly hash: string
@@ -402,7 +406,7 @@ export const replay = async (raw: ReplayInput): Promise<ReplayOutcome> => {
       position = commit
       const to = commit.parsed.parsed?.to
       expectedNext =
-        to === undefined || to === UNPIN_STATE ? undefined : { name: to, hash: commit.hash }
+        to === undefined || namesUnpin(commit) ? undefined : { name: to, hash: commit.hash }
       anchorPending = expectedNext !== undefined
     }
   }
@@ -672,7 +676,7 @@ export const replay = async (raw: ReplayInput): Promise<ReplayOutcome> => {
   // A turn that ends a pinned process names the unpin, which is no step.
   const expectNextOf = (commit: ParsedCommit): void => {
     const to = commit.parsed.parsed?.to
-    if (to !== undefined && to !== UNPIN_STATE) expectedNext = { name: to, hash: commit.hash }
+    if (to !== undefined && !namesUnpin(commit)) expectedNext = { name: to, hash: commit.hash }
   }
 
   const noteKept = (step: ReachedStep, commit: ParsedCommit): void => {
@@ -719,8 +723,8 @@ export const replay = async (raw: ReplayInput): Promise<ReplayOutcome> => {
 
   // gtd.config.ts is loaded without a type check.
   const requestFault = (request: Exclude<StepRequest, { kind: "restart" }>): string | undefined => {
-    if (Object.values(PIN_STATES).includes(scoped(request.name))) {
-      return `gtd: step "${scoped(request.name)}": the name is reserved for the pin and unpin beats — rename the step`
+    if (scoped(request.name).startsWith(ENGINE_PREFIX)) {
+      return `gtd: step "${scoped(request.name)}": the "${ENGINE_PREFIX}" prefix is reserved for gtd's own beats — rename the step`
     }
     if (request.kind === "run" && typeof request.body !== "string") {
       return `gtd: step "${scoped(request.name)}": a run() body is a shell script string — decide in flow code, then render the script (see checkScript and friends)`

package/src/replay/Trailers.test.ts

@@ -46,7 +46,7 @@ describe("the commit-message codec", () => {
       reviewBase: "abc",
     })
     expect(message).toBe(
-      "gtd(human): fix-precheck\n\nGtd-Workflow: fix\nGtd-Review-Base: abc\nGtd-Format: 3",
+      "gtd(human): fix-precheck\n\nGtd-Workflow: fix\nGtd-Review-Base: abc\nGtd-Format: 4",
     )
     expect(parseCommitMessage(message).workflow).toBe("fix")
     expect(parseCommitMessage("gtd(human): fix-precheck").workflow).toBeUndefined()
@@ -56,7 +56,7 @@ describe("the commit-message codec", () => {
     const one = formatCommitMessage({ actor: "human", to: "x", vars: { b: "2", a: "1", c: "" } })
     const two = formatCommitMessage({ actor: "human", to: "x", vars: { c: "", a: "1", b: "2" } })
     expect(one).toBe(two)
-    expect(one).toBe("gtd(human): x\n\nGtd-Var: a=1\nGtd-Var: b=2\nGtd-Var: c=\nGtd-Format: 3")
+    expect(one).toBe("gtd(human): x\n\nGtd-Var: a=1\nGtd-Var: b=2\nGtd-Var: c=\nGtd-Format: 4")
     expect(parseCommitMessage(one).vars).toEqual({ a: "1", b: "2", c: "" })
   })
 
@@ -81,8 +81,8 @@ describe("the commit-message codec", () => {
   it("reads a Gtd-Version carrying control bytes as unknown, and keeps spaces and parens", () => {
     const withVersion = (value: string) =>
       formatCommitMessage({ actor: "a", to: "b" }).replace(
-        "Gtd-Format: 3",
-        `Gtd-Version: ${value}\nGtd-Format: 3`,
+        "Gtd-Format: 4",
+        `Gtd-Version: ${value}\nGtd-Format: 4`,
       )
     expect(parseCommitMessage(withVersion("1.0\u001b]0;x\u0007")).version).toBeUndefined()
     expect(parseCommitMessage(withVersion("1.0\u009b")).version).toBeUndefined()
@@ -100,18 +100,18 @@ describe("the commit-message codec", () => {
 
   it("writes the current Gtd-Format when branch and version are written", () => {
     const message = formatCommitMessage({ actor: "a", to: "b", branch: "m", version: "1" })
-    expect(message.endsWith("Gtd-Format: 3")).toBe(true)
+    expect(message.endsWith("Gtd-Format: 4")).toBe(true)
   })
 
   it("writes Gtd-Format last on every message, even one with no other trailer", () => {
     const message = formatCommitMessage({ actor: "agent", to: "building" })
-    expect(message).toBe("gtd(agent): building\n\nGtd-Format: 3")
-    expect(parseCommitMessage(message).format).toBe(3)
+    expect(message).toBe("gtd(agent): building\n\nGtd-Format: 4")
+    expect(parseCommitMessage(message).format).toBe(4)
   })
 
   it("reads a message without Gtd-Format as format 1, and an explicit one as written", () => {
     expect(parseCommitMessage("gtd(agent): a → b\n\nGtd-Step: a#1").format).toBe(1)
-    expect(parseCommitMessage("gtd(agent): a → b\n\nGtd-Format: 3").format).toBe(3)
+    expect(parseCommitMessage("gtd(agent): a → b\n\nGtd-Format: 4").format).toBe(4)
     expect(parseCommitMessage("gtd(agent): a → b\n\nGtd-Format: two").format).toBe(1)
   })
 
@@ -149,7 +149,7 @@ describe("Gtd-Kept", () => {
   it("reads undefined when absent, and leaves Gtd-Format at the current format", () => {
     const parsed = parseCommitMessage(formatCommitMessage({ actor: "agent", to: "b" }))
     expect(parsed.kept).toBeUndefined()
-    expect(parsed.format).toBe(3)
+    expect(parsed.format).toBe(4)
   })
 })
 
@@ -289,7 +289,7 @@ describe("Gtd-Mark", () => {
     const at = lines.findIndex((l) => l.startsWith("Gtd-Mark:"))
     expect(lines[at - 1]).toMatch(/^Gtd-Judge:/)
     expect(lines[at + 1]).toMatch(/^Gtd-Approved:/)
-    expect(lines).toContain("Gtd-Format: 3")
+    expect(lines).toContain("Gtd-Format: 4")
   })
 
   it("writes nothing without marks", () => {

package/src/replay/Trailers.ts

@@ -70,8 +70,30 @@ export interface Approval {
 
 export type PinChange = PinMark
 
+/** Step names a workflow may not take: gtd's own beats live under it. */
+export const ENGINE_PREFIX = "gtd:"
+
 /** What a pin and an unpin beat rest at, and their commits name — neither is a step of the workflow. */
-export const PIN_STATES: Readonly<Record<PinChange, string>> = { add: "pin", remove: "unpin" }
+export const PIN_STATES: Readonly<Record<PinChange, string>> = {
+  add: `${ENGINE_PREFIX}pin`,
+  remove: `${ENGINE_PREFIX}unpin`,
+}
+
+/** The names formats 2 and 3 gave the pin beats, before `gtd:` reserved them. */
+export const LEGACY_PIN_STATES: Readonly<Record<PinChange, string>> = {
+  add: "pin",
+  remove: "unpin",
+}
+
+const SCOPED_PIN_FORMAT = 4
+
+/** The name a commit in `format` gives a pin beat; format 1 has none. */
+export const pinStateIn = (format: number, change: PinChange): string | undefined =>
+  format >= SCOPED_PIN_FORMAT
+    ? PIN_STATES[change]
+    : format >= 2
+      ? LEGACY_PIN_STATES[change]
+      : undefined
 
 export interface CommitMessage {
   readonly subject: string

package/src/replay/index.ts

@@ -17,6 +17,7 @@ export {
   type CommitSpec,
   type JudgeVerdict,
   type PinChange,
+  LEGACY_PIN_STATES,
   PIN_STATES,
 } from "./Trailers.js"
 export { accessShapeFault } from "./Access.js"

package/src/step/planStart.test.ts

@@ -176,7 +176,7 @@ describe("planStart", () => {
         kind: "gitWrite",
         write: {
           kind: "commitAll",
-          message: "gtd(human): work\n\nGtd-Workflow: working\nGtd-Var: base=\nGtd-Format: 3",
+          message: "gtd(human): work\n\nGtd-Workflow: working\nGtd-Var: base=\nGtd-Format: 4",
         },
       },
       { kind: "outcome", outcome: { kind: "commit", subject: "gtd(human): work" } },
@@ -195,7 +195,7 @@ describe("planStart", () => {
     if (write?.kind !== "gitWrite" || write.write.kind !== "commitAll")
       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: 3",
+      "gtd(human): work\n\nGtd-Workflow: working\nGtd-Var: base=main\nGtd-Format: 4",
     )
     const outcome = plan.steps.find((s) => s.kind === "outcome")
     expect(outcome).toEqual({

package/src/step/planStep.test.ts

@@ -39,7 +39,7 @@ describe("planStep — commit", () => {
     expect(outcome.steps).toEqual([
       {
         kind: "gitWrite",
-        write: { kind: "commitAll", message: "gtd(agent): await-answers\n\nGtd-Format: 3" },
+        write: { kind: "commitAll", message: "gtd(agent): await-answers\n\nGtd-Format: 4" },
       },
       { kind: "outcome", outcome: { kind: "commit", subject: "gtd(agent): await-answers" } },
     ])
@@ -59,7 +59,7 @@ describe("planStep — commit", () => {
       kind: "gitWrite",
       write: {
         kind: "commitAll",
-        message: "gtd(human): building → done\n\nGtd-Step: building#1\nGtd-Format: 3",
+        message: "gtd(human): building → done\n\nGtd-Step: building#1\nGtd-Format: 4",
       },
     })
     expect(outcome.steps.at(-1)).toEqual({
@@ -99,7 +99,7 @@ describe("planStep — commit", () => {
     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: 3")
+    expect(trailers[4]).toBe("Gtd-Format: 4")
     expect(trailers).toHaveLength(5)
   })
 })
@@ -182,7 +182,7 @@ describe("planStep — keepTurn", () => {
       write: {
         kind: "keepTurn",
         ref: kept,
-        message: "gtd(agent): building → checking\n\nGtd-Step: building#1\nGtd-Format: 3",
+        message: "gtd(agent): building → checking\n\nGtd-Step: building#1\nGtd-Format: 4",
       },
     })
   })

package/src/testkit/TestRepo.test.ts

@@ -61,7 +61,7 @@ describe("testRepo", () => {
     expect(repo.subjects()).toEqual([
       "chore: initial commit",
       "gtd(agent): plan → build",
-      "gtd(check): pin → build",
+      "gtd(check): gtd:pin → build",
       "gtd(agent): build → check",
       "gtd(check): check → sign-off",
     ])

package/src/testkit/TestRepo.ts

@@ -1,5 +1,4 @@
 import { Effect } from "effect"
-import { PassThrough } from "node:stream"
 import { runCli } from "../cli/index.js"
 import { EXIT_OK, type BeatDocument } from "../wire/index.js"
 import {
@@ -450,8 +449,8 @@ export const testRepo = (options: TestRepoOptions): TestRepo => {
 
   // The modules are registered only while gtd runs, so nothing outlives the
   // call that loads them and no test can reach another's module.
-  const gtd = async (...args: string[]): Promise<CapturedCliResult> => {
-    const { io, result } = makeCapturingCliIo(repo, seenEnv())
+  const gtdWithStdin = async (stdin: string, ...args: string[]): Promise<CapturedCliResult> => {
+    const { io, result } = makeCapturingCliIo(repo, seenEnv(), {}, stdin)
     if (typeof workflow !== "string") registry().set(id, workflow)
     for (const [specifier, module] of modules) registry().set(moduleKey(specifier), module)
     try {
@@ -462,19 +461,7 @@ export const testRepo = (options: TestRepoOptions): TestRepo => {
     }
     return result()
   }
-
-  // `gtd judge answer` reads its verdict off stdin, so it is swapped for the call.
-  const withStdin = async <T>(stdin: string, fn: () => Promise<T>): Promise<T> => {
-    const saved = Object.getOwnPropertyDescriptor(process, "stdin")
-    const fake = new PassThrough()
-    Object.defineProperty(process, "stdin", { value: fake, configurable: true })
-    fake.end(stdin)
-    try {
-      return await fn()
-    } finally {
-      if (saved) Object.defineProperty(process, "stdin", saved)
-    }
-  }
+  const gtd = (...args: string[]): Promise<CapturedCliResult> => gtdWithStdin("", ...args)
 
   const apply = (what: string, script: string): void => {
     if (script.length === 0) return
@@ -488,8 +475,7 @@ export const testRepo = (options: TestRepoOptions): TestRepo => {
     stdin?: string,
     refused: (error: Error) => Error = (error) => error,
   ): Promise<CapturedCliResult> => {
-    const call = (...extra: string[]) =>
-      stdin === undefined ? gtd(...args, ...extra) : withStdin(stdin, () => gtd(...args, ...extra))
+    const call = (...extra: string[]) => gtdWithStdin(stdin ?? "", ...args, ...extra)
     const reported = await call()
     if (reported.exitCode !== EXIT_OK) throw refused(failed(`gtd ${args.join(" ")}`, reported))
     const script = await call("--json=script")