@pmelab/gtd 64.2.0 → 65.0.0

package/dist/testkit/gherkin.mjs

@@ -1,4 +1,4 @@
-import { n as runsItsScript, r as testRepo } from "../chunks/testkit-BwCH8ky6.mjs";
+import { n as runsItsScript, r as testRepo } from "../chunks/testkit-CgrLmpdJ.mjs";
 import { pathToFileURL } from "node:url";
 import { resolve } from "node:path";
 import { After, AfterAll, Given, QuickPickleWorld, Then, When, setWorldConstructor } from "quickpickle";

package/dist/testkit.mjs

@@ -1,3 +1,3 @@
-import { H as installContext } from "./chunks/flows-dnIE_qbe.mjs";
-import { a as verdictWhen, i as verdict, n as runsItsScript, o as whenPrompted, r as testRepo, t as inTurn } from "./chunks/testkit-BwCH8ky6.mjs";
+import { H as installContext } from "./chunks/flows-DGs0W3HI.mjs";
+import { a as verdictWhen, i as verdict, n as runsItsScript, o as whenPrompted, r as testRepo, t as inTurn } from "./chunks/testkit-CgrLmpdJ.mjs";
 export { inTurn, installContext, runsItsScript, testRepo, verdict, verdictWhen, whenPrompted };

package/dist/web/main.js

@@ -35949,8 +35949,8 @@ const openable = (step) => step?.status === "ok" && step.file !== void 0;
 * `"qa"` means `Plan`; `"findings"` means `Findings`; anything else (absent, or an unregistered mode name)
 * falls through to `FreeForm`, which reads the file as plain markdown and
 * offers only a note per block, plus a textfield when it's empty. Neither
-* screen offers a way back to a list — `done` is the only
-* thing that ends the turn, and it exits the process.
+* screen offers a way back to a list — `done` hands the turn back (the
+* server keeps running until the outer loop moves on).
 *
 * Never returns `null`: a blank white screen was package 03's own regression
 * (a phone over a tailnet with nothing on-screen to explain why) — every

package/dist/wire.mjs

@@ -1 +1 @@
-export { O as ACCESS_REFUSAL, _ as BEAT_KINDS, f as DEMAND_BRIEFING, x as EXIT_CODES, S as EXIT_OK, C as EXIT_RUNTIME_ERROR, w as EXIT_SIGINT, T as EXIT_SIGTERM, E as EXIT_STRAYS_FOUND, D as EXIT_USAGE_ERROR, k as PIN_PATH, A as UNATTRIBUTED_MODEL, j as WIRE_SCHEMA, m as beatDocument, v as beatKindOf, y as demandOf, t as globMatches, i as judgeJson, s as landFields, c as landProseText, l as noopText, h as renderBeatJson, p as renderBeatPlain, M as renderFormat, u as renderLandJson, d as renderLandPlain, a as renderScriptJson, n as resolveSession, o as scriptFields, r as selectPath, b as stallDiagnosis, g as statusOf } from "./chunks/wire-CaPJ9Tme.mjs";
+export { O as ACCESS_REFUSAL, _ as BEAT_KINDS, f as DEMAND_BRIEFING, x as EXIT_CODES, S as EXIT_OK, C as EXIT_RUNTIME_ERROR, w as EXIT_SIGINT, T as EXIT_SIGTERM, E as EXIT_STRAYS_FOUND, D as EXIT_USAGE_ERROR, k as PIN_PATH, A as RUN_FAILED_PATH, j as UNATTRIBUTED_MODEL, M as WIRE_SCHEMA, m as beatDocument, v as beatKindOf, y as demandOf, t as globMatches, i as judgeJson, s as landFields, c as landProseText, l as noopText, h as renderBeatJson, p as renderBeatPlain, N as renderFormat, u as renderLandJson, d as renderLandPlain, a as renderScriptJson, n as resolveSession, o as scriptFields, r as selectPath, b as stallDiagnosis, g as statusOf } from "./chunks/wire-BNS8ciNu.mjs";

package/dist/workflow-kit.mjs

@@ -1,4 +1,4 @@
-import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-dnIE_qbe.mjs";
+import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-DGs0W3HI.mjs";
 import { C as reviewRisks, N as parseThreads, S as reviewNotes, T as unansweredNotes, n as stripCodeThreads, x as reviewDecisions } from "./chunks/steering-DEh_MS40.mjs";
 // src/workflow-kit/health.ts
 /** Hand a red suite that repeated attempts could not fix to a person, until `limit` rounds are spent. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "64.2.0",
+  "version": "65.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/cli/Cli.ts

@@ -445,7 +445,7 @@ gtd writes nothing itself. Plain output names the commit it would make; --json=s
     arity: { name: "name", variadic: "args", bare: true },
     group: "Start and stop",
     summary: "Start a workflow or door; bare, list them",
-    details: `Start a new process: print the script that makes its first commit, which also commits whatever the working tree holds.
+    details: `Start a new process: print the script that makes its first commit, which also commits whatever the working tree holds. The process runs on the branch \`gtd/<b>\` (created, or reused when nothing on it would be lost), never on \`<b>\`; a branch already named \`gtd/…\` and a detached HEAD start in place.
 
 <name> is a door — a named shortcut whose positional args set the workflow's settings — or else a workflow the config exports, which takes no args. A door shadows a workflow of the same name. --var pins a setting either way.
 
@@ -459,7 +459,7 @@ With no <name>, list every workflow and door it can start. An unknown <name>, th
     arity: "none",
     group: "Start and stop",
     summary: "Stop the process, keeping its changes",
-    details: `Stop the process underway without finishing it. The printed script moves HEAD back to the commit the process started from and keeps everything it produced as uncommitted changes; \`gtd restore\` undoes it. With no process underway the script does nothing.
+    details: `Stop the process underway without finishing it. The printed script moves HEAD back to the commit the process started from, or to its last ship, and keeps everything it produced as uncommitted changes, switches back to \`<b>\` and deletes \`gtd/<b>\`; it keeps the abandoned tip at \`refs/gtd/history/<entry>\` (pushed to \`historyRemote\` when set). \`gtd restore\` undoes it. With no process underway the script does nothing.
 
   s=$(gtd abandon --json=script) && sh -c "$s"`,
   },
@@ -469,7 +469,7 @@ With no <name>, list every workflow and door it can start. An unknown <name>, th
     arity: "none",
     group: "Start and stop",
     summary: "Bring back the last abandoned process",
-    details: `Bring back the process the last \`gtd abandon\` stopped: the printed script resets HEAD to that process's last commit. Refuses on a dirty working tree, when nothing was abandoned, or when commits made since would be lost.`,
+    details: `Bring back the process the last \`gtd abandon\` stopped: the printed script puts that process's last commit back, on a recreated \`gtd/<b>\` when the process ran on one. Refuses on a dirty working tree, when nothing was abandoned, or when commits made since would be lost.`,
   },
   {
     token: "repin",
@@ -487,7 +487,7 @@ With no <name>, list every workflow and door it can start. An unknown <name>, th
     arity: "none",
     group: "Inspect",
     summary: "Print the prompt for the closing message",
-    details: `Print the prompt for an agent to write the closing message of the process HEAD closes or sits inside: its first commit, each commit a person made, the diff range to read, and its cost. Writes nothing — what to do with the answer (a squash message, a PR body) is the driver's call.
+    details: `Print the prompt for an agent to write the closing message of the process HEAD closes or sits inside (back on a user branch, the one its gtd/ branch closes): its first commit, each commit a person made, the diff range to read, and its cost. Writes nothing — what to do with the answer (a squash message, a PR body) is the driver's call.
 
 Refuses when the workflow declares no summary template, or when the process has no commits.`,
   },
@@ -557,7 +557,7 @@ Prints a sorted JSON array ([] when clean) and a summary on stderr; --verbose ad
     arity: "none",
     group: "Inspect",
     summary: "Serve the web and phone client",
-    details: `Serve gtd's web and phone client for this worktree. By default it publishes through \`tailscale serve\`, reachable from anywhere on the tailnet, on the first of ports 8443, 10000 and 443 that works; when none does it serves HTTPS locally instead of refusing.`,
+    details: `Serve gtd's web and phone client for this worktree. By default it publishes through \`tailscale serve\`, reachable from anywhere on the tailnet, on the first of ports 8443, 10000 and 443 that works; when none does it serves HTTPS locally instead of refusing. Done saves the steering file and keeps serving; the server exits when the worktree moves on to another step, or on a signal.`,
   },
   {
     token: "guide",

package/src/cli/History.test.ts

@@ -10,6 +10,9 @@ import {
 import { runCli } from "./index.js"
 import { historyEntries, resolveHistoryRef, type HistoryEntry } from "./History.js"
 
+// A process runs on `gtd/<b>`; the recorded branch is the user's `<b>`.
+const USER_BRANCH = "main"
+
 const CONFIG = `import { agent, human } from "@pmelab/gtd/flows"
 
 export default async () => {
@@ -32,8 +35,9 @@ const land = async (repo: InMemRepo, files: Record<string, string>): Promise<str
     (JSON.parse(stdout) as { script: string }).script,
   )
   if (!outcome.ok) throw new Error(outcome.error)
+  const branch = repo.branchName()
   await takePinBeat(repo, "remove")
-  return repo.resolveRef("HEAD")!
+  return repo.resolveRef(`refs/heads/${branch}`)!
 }
 
 const finishedProcess = async (repo: InMemRepo, file: string) => {
@@ -82,7 +86,7 @@ describe("historyEntries", () => {
     expect(list.map((e) => e.entry)).toEqual([second.entry, first.entry])
     expect(list[0]).toMatchObject({
       ref: `refs/gtd/history/${second.entry}`,
-      branch: repo.branchName(),
+      branch: USER_BRANCH,
       tip: second.tip,
       subject: "gtd(human): idle → building",
     })
@@ -169,16 +173,14 @@ describe("gtd history list", () => {
     const text = await gtd(repo, "history", "list")
     const line = text.stdout.trimEnd().split("\n")
     expect(line).toHaveLength(1)
-    expect(
-      line[0]!.startsWith(`${hash.slice(0, 7)} ${repo.branchName()} ${tip.slice(0, 7)} `),
-    ).toBe(true)
+    expect(line[0]!.startsWith(`${hash.slice(0, 7)} ${USER_BRANCH} ${tip.slice(0, 7)} `)).toBe(true)
     expect(line[0]!.endsWith(" gtd(human): idle → building")).toBe(true)
     const json = await gtd(repo, "history", "list", "--json")
     expect(JSON.parse(json.stdout)).toEqual([
       expect.objectContaining({
         ref: `refs/gtd/history/${hash}`,
         entry: hash,
-        branch: repo.branchName(),
+        branch: USER_BRANCH,
         tip,
         subject: "gtd(human): idle → building",
       }),
@@ -195,7 +197,7 @@ describe("gtd history show", () => {
     expect(out.exitCode).toBe(0)
     const lines = out.stdout.trimEnd().split("\n")
     expect(lines[0]).toBe(
-      `refs/gtd/history/${hash} (branch ${repo.branchName()}, tip ${tip.slice(0, 7)})`,
+      `refs/gtd/history/${hash} (branch ${USER_BRANCH}, tip ${tip.slice(0, 7)})`,
     )
     expect(out.stdout).toContain("gtd(human): idle → building")
     expect(lines[lines.length - 1]).toBe("ended (return)")
@@ -206,7 +208,7 @@ describe("gtd history show", () => {
     const { entry: hash, tip } = await finishedProcess(repo, "a.txt")
     const out = await gtd(repo, "history", "show", hash, "--json")
     const doc = JSON.parse(out.stdout)
-    expect(doc).toMatchObject({ entry: hash, tip, ended: "return", branch: repo.branchName() })
+    expect(doc).toMatchObject({ entry: hash, tip, ended: "return", branch: USER_BRANCH })
     expect(doc.steps.length).toBeGreaterThan(0)
     expect(doc.version).toHaveProperty("running")
   })

package/src/cli/Metrics.test.ts

@@ -233,8 +233,9 @@ const land = async (repo: InMemRepo, files: Record<string, string>): Promise<str
     (JSON.parse(stdout) as { script: string }).script,
   )
   if (!outcome.ok) throw new Error(outcome.error)
+  const branch = repo.branchName()
   await takePinBeat(repo, "remove")
-  return repo.resolveRef("HEAD")!
+  return repo.resolveRef(`refs/heads/${branch}`)!
 }
 
 describe("readProcessMetrics", () => {

package/src/cli/Program.test.ts

@@ -1694,7 +1694,9 @@ export default async () => {
     const { exitCode, script } = await landAndApply(repo)
     expect(exitCode).toBe(0)
     expect(script).not.toContain("fmt-notes")
-    expect(repo.lastCommitSubject("HEAD~1")).toBe("gtd(agent): drafting → gtd:unpin")
+    expect(repo.lastCommitSubject(`${repo.resolveRef("gtd/main")}~1`)).toBe(
+      "gtd(agent): drafting → gtd:unpin",
+    )
   })
 
   it("`gtd next --json`'s `validate` field carries the mode's format command", async () => {
@@ -1974,7 +1976,7 @@ export default async () => {
   it("refuses once the process has closed and HEAD rests at the initial step again", async () => {
     const repo = await atDeciding()
     await landTurn(repo)
-    expect(repo.lastCommitSubject()).toBe("gtd(check): gtd:unpin → idle")
+    expect(repo.lastCommitSubject("gtd/main")).toBe("gtd(check): gtd:unpin → idle")
 
     const { exitCode, stdout, stderr } = await run(repo, "base")
     expect(exitCode).toBe(1)

package/src/cli/Program.ts

@@ -9,6 +9,8 @@ import {
   type GitOperations,
   type HostOps,
   HISTORY_REF,
+  RESUME_BRANCH_REF,
+  processHistoryRef,
   readRetainedHistory,
   restorability,
   loopLogPath,
@@ -67,8 +69,14 @@ import {
   summaryRun,
   type RenderedRest,
 } from "../edge/index.js"
-import { formatCommitMessage, PIN_STATES } from "../replay/index.js"
-import { planStart, planStep as planStepPure, type JudgeVerdict } from "../step/index.js"
+import { formatCommitMessage, parseCommitMessage, PIN_STATES } from "../replay/index.js"
+import {
+  GTD_BRANCH_PREFIX,
+  userBranchOf,
+  planStart,
+  planStep as planStepPure,
+  type JudgeVerdict,
+} from "../step/index.js"
 import {
   BUILT_IN_MODE_NAMES,
   formatFromSpec,
@@ -85,6 +93,10 @@ import {
   deleteRef,
   hardResetTo,
   mixedResetTo,
+  switchBranchTo,
+  switchTo,
+  deleteBranch,
+  pushRef,
   unpinScript,
   repinScript,
   commitPath,
@@ -749,6 +761,29 @@ const runStartListCommand = (
     )
   })
 
+/**
+ * Back on `<b>` when the process ran on `gtd/<b>` and `<b>` moved only by its
+ * ships (whose `Gtd-Tip` the tip descends from): the rewind stops at the last
+ * ship, so the uncommitted changes are what it left unshipped.
+ */
+const abandonTarget = (current: Option.Option<string>, tip: string, startParent: string) =>
+  Effect.gen(function* () {
+    const git = yield* GitService
+    const userBranch = Option.isSome(current) ? userBranchOf(current.value) : undefined
+    const userTip =
+      userBranch === undefined
+        ? Option.none<string>()
+        : yield* git.readRefOption(`refs/heads/${userBranch}`)
+    if (userBranch === undefined || Option.isNone(userTip)) {
+      return { leaves: undefined, rewindTo: startParent }
+    }
+    if (userTip.value === startParent) return { leaves: userBranch, rewindTo: startParent }
+    const shipped = parseCommitMessage(yield* git.lastCommitMessage(userTip.value)).tip
+    return shipped !== undefined && (yield* git.isAncestor(shipped, tip))
+      ? { leaves: userBranch, rewindTo: userTip.value }
+      : { leaves: undefined, rewindTo: startParent }
+  })
+
 /**
  * Ends the process underway without completing it. Nothing is discarded: a
  * `git reset --mixed` to the process's start commit leaves every turn
@@ -766,6 +801,7 @@ const runAbandonCommand = (
   json: JsonMode,
   out: ArtifactOut,
 ): Effect.Effect<void, Error, CommandRequirements> =>
+  // fallow-ignore-next-line complexity
   Effect.gen(function* () {
     const git = yield* GitService
     const config = yield* (yield* ConfigService).load
@@ -790,17 +826,58 @@ const runAbandonCommand = (
     }
 
     const tip = yield* git.resolveRef("HEAD")
+    const historyRef = processHistoryRef(run.startHash)
+
+    const current = yield* git.currentBranch()
+    const { leaves, rewindTo } = yield* abandonTarget(current, tip, run.startParentHash)
+    const remote = config.historyRemote
 
     const steps: EmitStep[] = [
       { kind: "gitWrite", command: updateRef(HISTORY_REF, tip) },
-      { kind: "gitWrite", command: mixedResetTo(run.startParentHash) },
+      { kind: "gitWrite", command: updateRef(historyRef, tip) },
+      { kind: "gitWrite", command: mixedResetTo(rewindTo) },
       { kind: "gitWrite", command: unpinScript(PIN_PATH) },
-      { kind: "outcome", command: abandonedOutcome(restState, run.startParentHash, initial) },
+      ...(leaves !== undefined
+        ? [
+            { kind: "gitWrite", command: switchTo(leaves) } as const,
+            {
+              kind: "gitWrite",
+              command: deleteBranch(Option.getOrThrow(current)),
+            } as const,
+            { kind: "gitWrite", command: updateRef(RESUME_BRANCH_REF, tip) } as const,
+          ]
+        : [{ kind: "gitWrite", command: deleteRef(RESUME_BRANCH_REF) } as const]),
+      { kind: "outcome", command: abandonedOutcome(restState, rewindTo, initial) },
+      ...(remote !== undefined
+        ? [{ kind: "gitWrite", command: pushRef(remote, historyRef) } as const]
+        : []),
     ]
     const required = emitScripts(steps).required
     yield* writeScript(json, out, combinedScript(required, ""))
   })
 
+/**
+ * `gtd/<b>` when the abandon left it for `<b>` and HEAD is still on `<b>`. A
+ * `gtd/<b>` made since is reset only when the retained tip contains it — the
+ * `-C` switch would orphan anything else.
+ */
+const resumeBranch = (git: GitOperations, tip: string): Effect.Effect<string | undefined, Error> =>
+  Effect.gen(function* () {
+    if (Option.isNone(yield* git.readRefOption(RESUME_BRANCH_REF))) return undefined
+    const current = yield* git.currentBranch()
+    if (Option.isNone(current) || current.value.startsWith(GTD_BRANCH_PREFIX)) return undefined
+    const branch = `${GTD_BRANCH_PREFIX}${current.value}`
+    const existing = yield* git.readRefOption(`refs/heads/${branch}`)
+    if (Option.isSome(existing) && !(yield* git.isAncestor(existing.value, tip))) {
+      return yield* Effect.fail(
+        new Error(
+          `gtd restore: branch ${branch} holds commits the retained tip ${tip.slice(0, 7)} does not — merge or delete it first`,
+        ),
+      )
+    }
+    return branch
+  })
+
 /**
  * `gtd restore`: hard-reset HEAD back to the tip `gtd abandon` retained.
  *
@@ -847,9 +924,14 @@ const runRestoreCommand = (
     // A preview of the resulting state, resolved at tip directly since no reset has happened yet.
     const after = yield* restAt(tip)
 
+    const resumeOn = yield* resumeBranch(git, tip)
     const steps: EmitStep[] = [
-      { kind: "gitWrite", command: hardResetTo(tip) },
+      {
+        kind: "gitWrite",
+        command: resumeOn === undefined ? hardResetTo(tip) : switchBranchTo(resumeOn, tip),
+      },
       { kind: "gitWrite", command: deleteRef(HISTORY_REF) },
+      { kind: "gitWrite", command: deleteRef(RESUME_BRANCH_REF) },
       { kind: "outcome", command: restoredOutcome(tip, after.state) },
     ]
     const required = emitScripts(steps).required

package/src/edge/Edge.test.ts

@@ -100,7 +100,8 @@ const applied = (repo: InMemRepo, script: string): string => {
 /**
  * Lands the pending turn the way a driver does — `gtd land --json`, then its
  * script, then the pin or unpin beat it leads to — and returns the turn's
- * commit, or the closing commit when the turn led to the unpin.
+ * commit, or the closing commit when the turn led to the unpin (which leaves
+ * HEAD back on the user's branch).
  */
 const land = async (repo: InMemRepo, files: Files = {}): Promise<string> => {
   write(repo, files)
@@ -108,7 +109,8 @@ const land = async (repo: InMemRepo, files: Files = {}): Promise<string> => {
   if (exitCode !== 0) throw new Error(`gtd land exited ${exitCode}: ${stderr}${stdout}`)
   const turn = applied(repo, (JSON.parse(stdout) as { readonly script: string }).script)
   await takePinBeat(repo, "add")
-  return (await takePinBeat(repo, "remove")) ? headOf(repo) : turn
+  const branch = repo.branchName()
+  return (await takePinBeat(repo, "remove")) ? headOf(repo, `refs/heads/${branch}`) : turn
 }
 
 const enter = async (repo: InMemRepo, workflow: string, ...vars: string[]): Promise<string> => {
@@ -206,7 +208,8 @@ describe("currentRun", () => {
     await land(repo, { "a.txt": "a\n" })
     await land(repo, { "b.txt": "b\n" })
     const closing = await land(repo, { "c.txt": "c\n" })
-    expect(repo.lastCommitSubject()).toBe("gtd(check): gtd:unpin → idle")
+    expect(repo.lastCommitSubject(closing)).toBe("gtd(check): gtd:unpin → idle")
+    repo.checkoutBranch("gtd/main")
     const next = await land(repo, { "d.txt": "d\n" })
     const run = await provide(currentRun, repo)
     expect(run.startParentHash).toBe(closing)
@@ -413,7 +416,12 @@ export const again = workflow(async () => {
       await land(repo, { "a.txt": "a\n" })
       await land(repo, { "b.txt": "b\n" })
       const run = await provide(currentRun, repo)
-      expect(run.headTurn).toEqual({ state: "checking", actor: "agent", empty: false, step: true })
+      expect(run.headTurn).toEqual({
+        state: "checking",
+        actor: "agent",
+        empty: false,
+        step: true,
+      })
     })
 
     it("is undefined at a pin commit, which is no turn", async () => {
@@ -429,7 +437,12 @@ export const again = workflow(async () => {
       await land(repo)
       expect(repo.lastCommitMessage()).toBe("gtd(agent): building\n\nGtd-Format: 4")
       const run = await provide(currentRun, repo)
-      expect(run.headTurn).toEqual({ state: "building", actor: "agent", empty: true, step: false })
+      expect(run.headTurn).toEqual({
+        state: "building",
+        actor: "agent",
+        empty: true,
+        step: false,
+      })
     })
 
     it("is undefined at a non-gtd HEAD", async () => {
@@ -560,7 +573,7 @@ describe("summaryRun", () => {
 
     const ordinary = await provide(currentRun, repo)
     expect(ordinary.trace).toEqual([])
-    expect(ordinary.startParentHash).toBe(closing)
+    expect(ordinary.startParentHash).toBe(boundary)
 
     const summary = await provide(summaryRun, repo)
     expect(summary.closingHash).toBe(closing)
@@ -645,14 +658,17 @@ describe("process marks", () => {
   })
 })
 
-const withTipMessage = (repo: InMemRepo, edit: (message: string) => string): GitOperations => {
+const withTipMessage = (
+  repo: InMemRepo,
+  edit: (message: string) => string,
+  edited = repo.resolveRef("HEAD"),
+): GitOperations => {
   const real = fakeGitOperations(repo)
-  const head = repo.resolveRef("HEAD")
   return {
     ...real,
     commitHistory: (base, tip) =>
       Effect.map(real.commitHistory(base, tip), (commits) =>
-        commits.map((c) => (c.hash === head ? { ...c, message: edit(c.message) } : c)),
+        commits.map((c) => (c.hash === edited ? { ...c, message: edit(c.message) } : c)),
       ),
   }
 }
@@ -683,7 +699,8 @@ export default workflow(async () => {
     if (exitCode !== 0) throw new Error(`gtd land exited ${exitCode}: ${stderr}${stdout}`)
     const turn = applied(repo, (JSON.parse(stdout) as { readonly script: string }).script)
     await takePinBeat(repo, "add")
-    return (await takePinBeat(repo, "remove")) ? headOf(repo) : turn
+    const branch = repo.branchName()
+    return (await takePinBeat(repo, "remove")) ? headOf(repo, `refs/heads/${branch}`) : turn
   }
   type Rendered = {
     entryCommit: string
@@ -1366,7 +1383,7 @@ describe("finishing landings keep history", () => {
     expect(landing.spec.pin).toBe("remove")
     expect(landing.keepHistory).toBe(processHistoryRef(building))
     expect(landing.spec.version).toBe(GTD_VERSION)
-    expect(landing.spec.branch).toBe(repo.branchName())
+    expect(landing.spec.branch).toBe("main")
   })
 
   it("restart() is a finish too", async () => {
@@ -1647,8 +1664,10 @@ export default async () => {
 
   it("warns, never refuses, when the recorded version differs", async () => {
     const { repo, tip } = await finished()
-    const git = withTipMessage(repo, (m) =>
-      m.replace(`Gtd-Version: ${GTD_VERSION}`, "Gtd-Version: 0.0.1"),
+    const git = withTipMessage(
+      repo,
+      (m) => m.replace(`Gtd-Version: ${GTD_VERSION}`, "Gtd-Version: 0.0.1"),
+      tip,
     )
     const trail = await Effect.runPromise(
       historyTrail(tip).pipe(
@@ -1663,7 +1682,7 @@ export default async () => {
 
   it("a missing recorded version counts as different", async () => {
     const { repo, tip } = await finished()
-    const git = withTipMessage(repo, (m) => m.replace(/Gtd-Version: .*\n?/, ""))
+    const git = withTipMessage(repo, (m) => m.replace(/Gtd-Version: .*\n?/, ""), tip)
     const trail = await Effect.runPromise(
       historyTrail(tip).pipe(
         Effect.provideService(GitService, git),
@@ -1677,8 +1696,10 @@ export default async () => {
   it("reads a recorded version carrying control bytes as unknown", async () => {
     const { repo, tip } = await finished()
     const raw = "1.0\u001b]0;x\u0007"
-    const git = withTipMessage(repo, (m) =>
-      m.replace(`Gtd-Version: ${GTD_VERSION}`, `Gtd-Version: ${raw}`),
+    const git = withTipMessage(
+      repo,
+      (m) => m.replace(`Gtd-Version: ${GTD_VERSION}`, `Gtd-Version: ${raw}`),
+      tip,
     )
     const trail = await Effect.runPromise(
       historyTrail(tip).pipe(