@pmelab/gtd 64.3.0 → 66.0.0

package/src/step/planStart.test.ts

@@ -108,7 +108,7 @@ describe("planStart", () => {
       repo.seedCommit("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")
+      const write = plan.steps.find((s) => s.kind === "gitWrite" && s.write.kind === "commitAll")
       if (write?.kind !== "gitWrite" || write.write.kind !== "commitAll")
         throw new Error("expected a gitWrite step")
       expect(write.write.message).toContain(`Gtd-Review-Base: ${fork}`)
@@ -125,7 +125,7 @@ describe("planStart", () => {
       repo.seedCommit("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")
+      const write = plan.steps.find((s) => s.kind === "gitWrite" && s.write.kind === "commitAll")
       if (write?.kind !== "gitWrite" || write.write.kind !== "commitAll")
         throw new Error("expected a gitWrite step")
       expect(write.write.message).toContain(`Gtd-Review-Base: ${fork}`)
@@ -172,6 +172,7 @@ describe("planStart", () => {
     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: "switchBranch", branch: "gtd/main" } },
       {
         kind: "gitWrite",
         write: {
@@ -191,7 +192,7 @@ describe("planStart", () => {
       vars: { base: "main" },
     })
     if (plan.kind !== "start") throw new Error(`expected start, got ${plan.kind}`)
-    const write = plan.steps.find((s) => s.kind === "gitWrite")
+    const write = plan.steps.find((s) => s.kind === "gitWrite" && s.write.kind === "commitAll")
     if (write?.kind !== "gitWrite" || write.write.kind !== "commitAll")
       throw new Error("expected a gitWrite step")
     expect(write.write.message).toBe(

package/src/step/planStart.ts

@@ -11,6 +11,7 @@ import {
 } from "../workflow/index.js"
 import { formatCommitMessage, formatSubject } from "../replay/index.js"
 import type { LandStep } from "./LandStep.js"
+import { startBranchFor } from "./startBranch.js"
 
 /** Just enough of the current rest for `planStart`'s checks. */
 export interface StartCurrent {
@@ -87,6 +88,7 @@ export const planStart = (
   Error,
   GitService | ConfigService | ConfigDiscovery | Workspace | Host | Narrator
 > =>
+  // fallow-ignore-next-line complexity
   Effect.gen(function* () {
     const { workflow, first, commandLabel, vars: varOverrides } = start
     const name = workflow.name
@@ -134,7 +136,12 @@ export const planStart = (
       ...(base !== undefined ? { reviewBase: base } : {}),
       vars,
     })
+    const onBranch = yield* startBranchFor(commandLabel)
+    if (onBranch.kind === "refusal") return refusal(onBranch.message)
     const steps: readonly LandStep[] = [
+      ...(onBranch.kind === "switch"
+        ? [{ kind: "gitWrite", write: { kind: "switchBranch", branch: onBranch.branch } } as const]
+        : []),
       { kind: "gitWrite", write: { kind: "commitAll", message } },
       { kind: "outcome", outcome: { kind: "commit", subject } },
     ]

package/src/step/planStep.ts

@@ -24,11 +24,11 @@ export type StepOutcome =
     }
 
 /**
- * At the human review gate an unconditional `gtd uncheck '<file>'` runs
- * ahead of the commit, resetting every checkbox before `git add -A` picks it
- * up — a tick is read-progress, never sign-off.
+ * Clear ticks at the human review gate, a tick is read-progress. Keep them when
+ * the next step is an agent turn: the agent reads them.
  */
-const uncheckStep = (snapshot: RepoSnapshot): readonly LandStep[] =>
+const uncheckStep = (snapshot: RepoSnapshot, keepTicks: boolean): readonly LandStep[] =>
+  !keepTicks &&
   snapshot.stepDef.actor === "human" &&
   snapshot.stepDef.mode === "review" &&
   snapshot.file !== undefined
@@ -36,12 +36,16 @@ const uncheckStep = (snapshot: RepoSnapshot): readonly LandStep[] =>
     : []
 
 const gitWriteOf = (landing: Extract<Landing, { kind: "commit" }>, message: string): GitWrite => {
+  if (landing.ship !== undefined) return { kind: "ship", message, ...landing.ship }
   if (landing.only !== undefined) return { kind: "commitPath", path: landing.only, message }
   if (landing.keepTurn !== undefined) return { kind: "keepTurn", ref: landing.keepTurn, message }
   if (landing.spec.approved !== undefined) return { kind: "commitClean", message }
   return { kind: "commitAll", message }
 }
 
+const writeIf = (value: string | undefined, write: (value: string) => GitWrite): LandStep[] =>
+  value === undefined ? [] : [{ kind: "gitWrite", write: write(value) }]
+
 export const planStep = (
   snapshot: RepoSnapshot,
   opts: {
@@ -78,6 +82,7 @@ export const planStep = (
     ...(opts.judge !== undefined && opts.judge.length > 0 ? { judge: opts.judge } : {}),
   })
   const subject = message.split("\n")[0]!
+  const historyRef = landing.keepHistory ?? landing.ship?.historyRef ?? landing.recordedHistory
   const outcome: LandStep =
     landing.to === snapshot.state
       ? { kind: "outcome", outcome: { kind: "commit", subject } }
@@ -88,20 +93,20 @@ export const planStep = (
     to: landing.to,
     subject,
     steps: [
-      ...uncheckStep(snapshot),
-      {
-        kind: "gitWrite",
-        write: gitWriteOf(landing, message),
-      },
-      ...(landing.keepHistory !== undefined
-        ? [
-            {
-              kind: "gitWrite",
-              write: { kind: "updateRef", ref: landing.keepHistory, target: "HEAD" },
-            } as const,
-          ]
-        : []),
+      ...writeIf(landing.startBranch, (branch) => ({ kind: "switchBranch", branch })),
+      ...uncheckStep(snapshot, landing.keepTicks === true),
+      { kind: "gitWrite", write: gitWriteOf(landing, message) },
+      ...writeIf(historyRef, (ref) => ({ kind: "updateRef", ref, target: "HEAD" })),
+      ...writeIf(landing.leaveBranch, (branch) => ({ kind: "switchTo", branch })),
       outcome,
+      ...(landing.note !== undefined
+        ? [{ kind: "outcome", outcome: { kind: "note", text: landing.note } } as const]
+        : []),
+      ...writeIf(historyRef !== undefined ? landing.pushHistory : undefined, (remote) => ({
+        kind: "pushRef",
+        remote,
+        ref: historyRef!,
+      })),
     ],
   }
 }

package/src/step/startBranch.ts

@@ -0,0 +1,54 @@
+import { Effect, Option } from "effect"
+import { GitService } from "../platform/index.js"
+import { PROCESS_HISTORY_PREFIX } from "../platform/index.js"
+
+export const GTD_BRANCH_PREFIX = "gtd/"
+
+/** `<b>` for a `gtd/<b>` branch name; `undefined` for any other. */
+export const userBranchOf = (branch: string): string | undefined =>
+  branch.startsWith(GTD_BRANCH_PREFIX) ? branch.slice(GTD_BRANCH_PREFIX.length) : undefined
+
+/** A branch already named `gtd/…` and a detached HEAD start in place. */
+export type StartBranch =
+  | { readonly kind: "inPlace" }
+  | { readonly kind: "switch"; readonly branch: string }
+  | { readonly kind: "refusal"; readonly message: string }
+
+/**
+ * Where a new process starts: on `gtd/<b>`, so `<b>` never carries its commits.
+ * An existing `gtd/<b>` is reused only when its tip is contained in `<b>` or in
+ * a kept history ref (a squash onto `<b>` never makes it an ancestor).
+ */
+export const startBranchFor = (
+  commandLabel: string,
+): Effect.Effect<StartBranch, Error, GitService> =>
+  Effect.gen(function* () {
+    const git = yield* GitService
+    const current = yield* git.currentBranch()
+    if (Option.isNone(current) || current.value.startsWith(GTD_BRANCH_PREFIX)) {
+      return { kind: "inPlace" } as const
+    }
+    if (!(yield* git.hasCommits())) return { kind: "inPlace" } as const
+    const branch = `${GTD_BRANCH_PREFIX}${current.value}`
+    const existing = yield* git.readRefOption(`refs/heads/${branch}`)
+    if (Option.isSome(existing)) {
+      const head = yield* git.resolveRef("HEAD")
+      let contained = yield* git.isAncestor(existing.value, head)
+      if (!contained) {
+        const kept = yield* git.listRefs(PROCESS_HISTORY_PREFIX)
+        for (const k of kept) {
+          if (yield* git.isAncestor(existing.value, k.hash)) {
+            contained = true
+            break
+          }
+        }
+      }
+      if (!contained) {
+        return {
+          kind: "refusal",
+          message: `${commandLabel}: branch ${branch} holds commits that are neither on ${current.value} nor in a kept history ref — merge or delete it first`,
+        } as const
+      }
+    }
+    return { kind: "switch", branch } as const
+  })

package/src/twins/EmittedScriptRecognizer.ts

@@ -13,6 +13,12 @@ import {
   hardResetTo,
   keepTurn,
   mixedResetTo,
+  switchBranchTo,
+  switchBack,
+  switchTo,
+  deleteBranch,
+  pushRef,
+  shipCommit,
   shellQuote,
   softResetTo,
   updateRef,
@@ -26,6 +32,7 @@ import {
   modeContradictionSkipNotice,
   OUTCOME_MARKER,
   pinScript,
+  failRestScript,
   repinScript,
   unpinScript,
 } from "../emit/index.js"
@@ -161,6 +168,19 @@ const recognizeKeepTurn = (repo: InMemRepo, block: string): BlockOutcome | undef
   return failure === undefined ? { kind: "applied" } : { kind: "failed", error: failure, status: 1 }
 }
 
+const attempt = (apply: () => void): BlockOutcome => {
+  try {
+    apply()
+    return { kind: "applied" }
+  } catch (e) {
+    return {
+      kind: "failed",
+      error: `fatal: ${e instanceof Error ? e.message : String(e)}`,
+      status: 128,
+    }
+  }
+}
+
 // fallow-ignore-next-line complexity
 const recognizeGitBuilders = (repo: InMemRepo, block: string): BlockOutcome | undefined => {
   if (block === discardPending()) {
@@ -250,6 +270,73 @@ const recognizeGitBuilders = (repo: InMemRepo, block: string): BlockOutcome | un
     return undefined
   }
 
+  if (block.startsWith("git switch -q -C ")) {
+    const [branch, start] = extractQuotedTokens(block)
+    if (branch !== undefined && switchBranchTo(branch, start) === block) {
+      return attempt(() => repo.switchBranchTo(branch, start))
+    }
+    return undefined
+  }
+
+  if (block.startsWith("if ! git switch -q ")) {
+    const [branch, , note] = extractQuotedTokens(block)
+    if (branch !== undefined && switchBack(branch) === block) {
+      try {
+        repo.switchTo(branch)
+        return { kind: "applied" }
+      } catch {
+        return { kind: "noop", output: `${note}\n` }
+      }
+    }
+    return undefined
+  }
+
+  if (block.startsWith("git switch -q ")) {
+    const [branch] = extractQuotedTokens(block)
+    if (branch !== undefined && switchTo(branch) === block) {
+      return attempt(() => repo.switchTo(branch))
+    }
+    return undefined
+  }
+
+  if (block.startsWith("git branch -q -D ")) {
+    const [branch] = extractQuotedTokens(block)
+    if (branch !== undefined && deleteBranch(branch) === block) {
+      return attempt(() => repo.deleteBranch(branch))
+    }
+    return undefined
+  }
+
+  if (block.startsWith("if ! git push --force ")) {
+    const [remote, refspec] = extractQuotedTokens(block)
+    const ref = refspec?.split(":")[0]
+    if (remote !== undefined && ref !== undefined && pushRef(remote, ref) === block) {
+      const failure = repo.pushRef(remote, ref)
+      if (failure === undefined) return { kind: "applied" }
+      const retry = extractQuotedTokens(block)[3]!
+      return { kind: "failed", error: `${failure}\n${retry}`, status: 1 }
+    }
+    return undefined
+  }
+
+  if (block.startsWith("gtd_ship_parent=")) {
+    const [parent, branch, history, shipMessage, message] = extractQuotedTokens(block)
+    if (
+      parent === undefined ||
+      branch === undefined ||
+      history === undefined ||
+      shipMessage === undefined ||
+      message === undefined ||
+      shipCommit(branch, parent, shipMessage, history, message) !== block
+    ) {
+      return undefined
+    }
+    const failure = repo.shipCommit(branch, parent, shipMessage, history, message)
+    return failure === undefined
+      ? { kind: "applied" }
+      : { kind: "failed", error: failure, status: 1 }
+  }
+
   if (block.startsWith("git update-ref -d ")) {
     const [ref] = extractQuotedTokens(block)
     if (ref !== undefined && deleteRef(ref) === block) {
@@ -375,6 +462,35 @@ const recognizeModeCommand = (
   return recognizeScriptedCommand(repo, new Map([[command, bound]]), command)
 }
 
+const FAIL_REST_MIDDLE = '\n} 2>&1 )" || gtd_run_status=$?\n'
+
+/** A `run(…, { onFail: "rest" })` body: the inner script's failure is recorded in the tree and the block itself succeeds. */
+// fallow-ignore-next-line complexity
+const recognizeFailRest = (
+  repo: InMemRepo,
+  commands: CommandTable,
+  block: string,
+): BlockOutcome | undefined => {
+  if (!block.startsWith("rm -f -- '") || !block.includes("gtd_run_out=")) return undefined
+  const [path] = extractQuotedTokens(block)
+  const headerEnd = block.indexOf('gtd_run_out="$( {\n')
+  const bodyEnd = block.indexOf(FAIL_REST_MIDDLE)
+  if (path === undefined || headerEnd === -1 || bodyEnd === -1) return undefined
+  const body = block.slice(headerEnd + 'gtd_run_out="$( {\n'.length, bodyEnd)
+  if (failRestScript(body, path) !== block) return undefined
+  if (repo.readFile(path) !== undefined) repo.deleteFile(path)
+  const result = applyEmittedScript(repo, commands, body)
+  if (!result.ok && result.error?.startsWith(UNRECOGNIZED_PREFIX)) {
+    return { kind: "failed", error: `${result.output}${result.error}` }
+  }
+  if (!result.ok) {
+    // Mirrors `$(…)` (strips trailing newlines) and the script's `tail -n 50`.
+    const lines = result.output.replace(/\n+$/, "").split("\n")
+    repo.writeFile(path, `exit ${result.status}\n${lines.slice(-50).join("\n")}\n`)
+  }
+  return { kind: "noop", output: result.output }
+}
+
 const FAILURE_PROMPT_HEADER = 'gtd_validate_status=0\ngtd_validate_out="$( {\n'
 const FAILURE_PROMPT_MIDDLE =
   '\n} 2>&1 )" || gtd_validate_status=$?\n' +
@@ -565,7 +681,7 @@ const recognizeGtdCheck = (repo: InMemRepo, block: string): BlockOutcome | undef
 
 const GTD_UNCHECK_RE = /^gtd uncheck (.+)$/
 
-/** `gtd uncheck <file>` — the review-gate reset prepended ahead of the human's commit, so no tick ever reaches it. Re-runs the REAL `clearTicks`, writing back only on an actual change. */
+/** `gtd uncheck <file>` — the review-gate reset prepended ahead of the human's commit, absent when the next step is an agent turn. Re-runs the REAL `clearTicks`, writing back only on an actual change. */
 const recognizeGtdUncheck = (repo: InMemRepo, block: string): BlockOutcome | undefined => {
   const match = GTD_UNCHECK_RE.exec(block)
   if (!match) return undefined
@@ -728,6 +844,7 @@ const recognizersFor = (
   (block) => (git ? recognizeGitBuilders(repo, block) : undefined),
   (block) => recognizeWriteLines(repo, block),
   (block) => recognizePinScripts(repo, block),
+  (block) => recognizeFailRest(repo, commands, block),
   (block) => recognizeFailurePromptWrapper(repo, commands, block),
   (block) => recognizePresentationSubshell(repo, commands, block, git),
   (block) => recognizeModeContradictionSkipNotice(block),

package/src/twins/EmittedScripts.test.ts

@@ -5,15 +5,20 @@ import {
   combinedScript,
   commitAll,
   commitAsIs,
+  deleteBranch,
   emitScripts,
+  failRestScript,
   failurePromptWrapper,
   fileExistsGuard,
   modeContradictionSkipNotice,
+  switchBranchTo,
+  switchBack,
+  switchTo,
   transitionOutcome,
   withFileVar,
   type EmitStep,
 } from "../emit/index.js"
-import { Effect } from "effect"
+import { Effect, Option } from "effect"
 import { ScriptSurface } from "../emit/index.js"
 import { GitService } from "../platform/index.js"
 import { listFormat } from "../steering/index.js"
@@ -305,6 +310,147 @@ printf '%s\n' 'a' '' 'it'\''s' '100%' '-x' 'a\b' '.gtd/packages/00-x.md' > '.gtd
       )
     })
 
+    describe("branch scripts", () => {
+      it("switchBranchTo creates the branch at HEAD and moves onto it", () => {
+        const head = t.observe.resolveRef("HEAD")
+        expect(run(switchBranchTo("gtd/x")).ok).toBe(true)
+        expect(t.observe.resolveRef("gtd/x")).toBe(head)
+        t.seed.writeFile("a.txt", "a\n")
+        expect(run(commitAll("gtd(agent): building")).ok).toBe(true)
+        expect(t.observe.resolveRef("gtd/x")).toBe(t.observe.resolveRef("HEAD"))
+        expect(t.observe.resolveRef("gtd/x")).not.toBe(head)
+      })
+
+      it("switchTo moves onto an existing branch and fails for a missing one", () => {
+        expect(run(switchBranchTo("gtd/x")).ok).toBe(true)
+        expect(run(switchTo("nope")).ok).toBe(false)
+        expect(run(switchBranchTo("gtd/y")).ok).toBe(true)
+        expect(run(switchTo("gtd/x")).ok).toBe(true)
+      })
+
+      const branch = () =>
+        t.provide(Effect.flatMap(GitService, (g) => g.currentBranch())).then(Option.getOrUndefined)
+
+      it("switchBack carries a change to a path both branches agree on", async () => {
+        expect(run(switchBranchTo("gtd/x")).ok).toBe(true)
+        t.seed.commit("feat: on gtd/x", { "b.txt": "b\n" })
+        expect(run(switchBranchTo("x", "HEAD~1")).ok).toBe(true)
+        expect(run(switchTo("gtd/x")).ok).toBe(true)
+        t.seed.writeFile("a.txt", "changed\n")
+        const result = run(switchBack("x"))
+        expect(result.ok).toBe(true)
+        expect(result.output).toBe("")
+        expect(await branch()).toBe("x")
+        expect(read("a.txt")).toBe("changed\n")
+        expect(read("b.txt")).toBeUndefined()
+      })
+
+      it("switchBack stays put, saying so, when a change would be overwritten", async () => {
+        expect(run(switchBranchTo("gtd/x")).ok).toBe(true)
+        t.seed.commit("feat: on gtd/x", { "b.txt": "b\n" })
+        expect(run(switchBranchTo("x", "HEAD~1")).ok).toBe(true)
+        expect(run(switchTo("gtd/x")).ok).toBe(true)
+        t.seed.writeFile("b.txt", "changed\n")
+        const result = run(switchBack("x"))
+        expect(result.ok).toBe(true)
+        expect(result.output).toContain("pending changes keep HEAD off x")
+        expect(await branch()).toBe("gtd/x")
+        expect(read("b.txt")).toBe("changed\n")
+      })
+
+      it("deleteBranch removes another branch and refuses the checked-out one", () => {
+        expect(run(switchBranchTo("gtd/x")).ok).toBe(true)
+        expect(run(deleteBranch("gtd/x")).ok).toBe(false)
+        expect(run(switchBranchTo("gtd/y")).ok).toBe(true)
+        expect(run(deleteBranch("gtd/x")).ok).toBe(true)
+        expect(t.observe.refExists("refs/heads/gtd/x")).toBe(false)
+      })
+    })
+
+    describe("shipCommit", () => {
+      const HISTORY = "refs/gtd/history/0123456789012345678901234567890123456789"
+      const LANDING = "gtd(check): shipping → after\n\nGtd-Format: 4"
+      const git = <A>(f: (g: GitService["Service"]) => Effect.Effect<A, Error>) =>
+        t.provide(Effect.flatMap(GitService, f))
+      // As a landing renders it: under `set -eu`.
+      const ship = (branch: string, parent: string, shipMessage: string) =>
+        ScriptSurface.render([
+          {
+            kind: "gitWrite",
+            write: {
+              kind: "ship",
+              branch,
+              parent,
+              shipMessage,
+              historyRef: HISTORY,
+              message: LANDING,
+            },
+          },
+        ])
+
+      it("squashes the staged tree minus .gtd/ onto the branch, then lands naming it", async () => {
+        const branch = await git((g) => g.currentBranch())
+        const user = Option.getOrElse(branch, () => "main")
+        const parent = t.observe.resolveRef("HEAD")
+        expect(run(switchBranchTo(`gtd/${user}`)).ok).toBe(true)
+        t.seed.writeFile("a.txt", "shipped\n")
+        t.seed.writeFile(".gtd/notes.md", "kept back\n")
+        const result = run(ship(user, parent, "feat: it's shipped"))
+        expect(result.ok).toBe(true)
+        const shipped = t.observe.resolveRef(user)
+        expect(shipped).not.toBe(parent)
+        expect(t.observe.resolveRef(`${shipped}~1`)).toBe(parent)
+        expect(await git((g) => g.readFileAtRef(shipped, "a.txt"))).toBe("shipped\n")
+        expect(await git((g) => g.diffPaths(parent, shipped))).toEqual(["a.txt"])
+        const message = await git((g) => g.lastCommitMessage(shipped))
+        expect(message).toContain("feat: it's shipped")
+        expect(message).toContain(`\n\nGtd-History: ${HISTORY}\nGtd-Tip: ${parent}`)
+        expect(await git((g) => g.lastCommitMessage("HEAD"))).toContain(`Gtd-Shipped: ${shipped}`)
+        expect(t.observe.statusPorcelain()).toBe("")
+      })
+
+      it("keeps the .gtd/ files the branch tracks as it has them", async () => {
+        const user = Option.getOrElse(await git((g) => g.currentBranch()), () => "main")
+        t.seed.commit("chore: track", { ".gtd/keep.md": "tracked\n" })
+        const parent = t.observe.resolveRef("HEAD")
+        expect(run(switchBranchTo(`gtd/${user}`)).ok).toBe(true)
+        t.seed.writeFile("a.txt", "shipped\n")
+        t.seed.writeFile(".gtd/keep.md", "process\n")
+        expect(run(ship(user, parent, "feat: x")).ok).toBe(true)
+        const shipped = t.observe.resolveRef(user)
+        expect(await git((g) => g.readFileAtRef(shipped, ".gtd/keep.md"))).toBe("tracked\n")
+        expect(await git((g) => g.diffPaths(parent, shipped))).toEqual(["a.txt"])
+      })
+
+      it("fails before landing when the branch moved since the decision", () => {
+        const head = t.observe.resolveRef("HEAD")
+        expect(run(switchBranchTo("gtd/x")).ok).toBe(true)
+        expect(run(switchBranchTo("x")).ok).toBe(true)
+        t.seed.commit("feat: moved", { "b.txt": "b\n" })
+        expect(run(switchTo("gtd/x")).ok).toBe(true)
+        t.seed.writeFile("a.txt", "a\n")
+        expect(run(ship("x", head, "feat: x")).ok).toBe(false)
+        expect(t.observe.resolveRef("HEAD")).toBe(head)
+      })
+    })
+
+    describe("failRestScript", () => {
+      const FAIL_PATH = ".gtd/run-failed.txt"
+      const wrapped = (body: string) => failRestScript(body, FAIL_PATH)
+
+      it("records the status and output, without the output's trailing newline, and succeeds", () => {
+        expect(run(wrapped(withFileVar(FAILING, FILE))).ok).toBe(true)
+        expect(read(FAIL_PATH)).toBe(`exit 2\nbad: ${FILE}\n`)
+      })
+
+      it("leaves no record when the body passes, and clears an earlier one", () => {
+        t.seed.writeFile(FAIL_PATH, "exit 1\nold\n")
+        t.seed.writeFile(FILE, "a\n")
+        expect(run(wrapped(withFileVar(COPY, FILE))).ok).toBe(true)
+        expect(read(FAIL_PATH)).toBeUndefined()
+      })
+    })
+
     describe("commitAll", () => {
       it("a staging hook's edit lands in the commit", () => {
         t.seed.stagingHook("readme.txt", "hooked")