@pmelab/gtd 24.2.0 → 24.3.0

package/dist/testkit.mjs

@@ -1,12 +1,12 @@
 import { configProblems, configure, installContext, isFactoryWorkflow, protocolMismatch, t as flows_exports } from "./flows.mjs";
 import { O as renderFormat, T as ACCESS_REFUSAL, _ as demandOf, a as landFields, c as renderLandJson, d as renderBeatPlain, f as beatDocument, g as beatKindOf, i as judgeJson, l as renderLandPlain, m as statusOf, n as resolveSession, p as renderBeatJson, r as selectPath, s as noopText, t as globMatches } from "./chunks/wire-DA7q2ikx.mjs";
 import { C as headingSections, S as headingSectionBodies, a as unansweredQuestions, b as parseThreadsWithFindings, n as openThreads, r as steeringFormatFor, s as parseCodeThreads, t as BUILT_IN_MODE_NAMES } from "./chunks/steering-D-PvRC5W.mjs";
-import { $ as makeSemaphore, $i as equals, $n as match$3, $r as get$4, $t as scoped$3, A as catchTag, Ai as omit, An as _await$2, Ar as interruptAsFiber, At as tap, B as flatten$4, Bi as map$8, Bn as modify$1, Br as uninterruptible, Bt as when, C as all$1, Ci as unsafeGet, Cn as map$6, Cr as exitSucceed, Ct as scopeWith, D as async, Di as add, Dn as forEachConcurrentDiscard, Dr as fiberRefLocally, Dt as succeed$6, E as asVoid$1, Ei as Tag, En as ensuring$3, Er as fiberId, Et as serviceOption, F as exit, Fi as flatMap$5, Fn as bind, Fr as scopeClose, Ft as try_, G as forkScoped, Gi as left, Gn as spanTag, Gr as zipRight$1, Gt as zipWith, H as forEach$2, Hi as none, Hn as update$1, Hr as void_$2, Ht as zip$1, I as fail$5, Ii as fromNullable, In as bindTo, Ir as succeed$4, It as uninterruptible$1, J as interrupt$4, Ji as pipeArguments, Jn as fail$4, Jr as combine, Jt as tagged, K as gen, Ki as match$2, Kn as all, Kr as DeferredTypeId$1, Kt as spaced$1, L as failCause$4, Li as getOrElse, Ln as sleep, Lr as suspend$4, Lt as uninterruptibleMask, M as dieMessage, Mi as fromIterable, Mn as interruptAllAs$1, Mr as interruptible$1, Mt as timeout, N as either, Ni as splitAt, Nn as join$3, Nr as map$3, Nt as tryMap, O as catchAll$1, Oi as get$5, On as scopeMake, Or as flatMap$3, Ot as suspend$5, P as ensuring$2, Pi as filter$1, Pn as sequential, Pr as onInterrupt, Pt as tryPromise, Q as logWarning, Qi as toJSON, Qn as mapBoth, Qr as none$1, Qt as provideMerge$1, R as fiberIdWith, Ri as isNone, Rn as get$3, Rr as sync$1, Rt as unsafeMakeLatch, S as addFinalizer$1, Si as unsafeFromArray, Sn as isInterruptedOnly, Sr as exitFailCause, St as scope, T as as, Ti as GenericTag, Tn as squash, Tr as exitZipRight, Tt as scopedWith$1, U as forkDaemon, Ui as some, Un as TypeId$10, Ur as whenEffect, Ut as zipLeft, V as fnUntraced, Vi as match$4, Vn as set$1, Vr as uninterruptibleMask$1, Vt as withFiberRuntime$1, W as forkIn, Wi as isLeft, Wn as Class, Wr as withFiberRuntime, Wt as zipRight$3, X as intoDeferred, Xi as NodeInspectSymbol, Xn as isFailure, Xr as ids, Xt as mergeAll$2, Y as interruptible, Yi as BaseProto, Yn as failCause$3, Yr as combineAll, Yt as fromEffect$5, Z as isEffect, Zi as format, Zn as map$5, Zr as make$19, Zt as provide$1, _ as decodeSync, _i as reduce, _n as flipCauseOption, _r as deferredSucceed, _t as retry, a as Literal, aa as dual, ai as isFinite, an as unsafeMakeSemaphore, ar as asVoid, at as matchCauseEffect, b as acquireRelease, bi as takeRight, bn as isDieType, br as exitAs, bt as runtime, c as String$, ci as drop, cn as addFinalizerExit, cr as currentContext$1, ct as onError, d as Union, di as fromIterable$1, dn as fork, dr as deferredFail, dt as promise, ea as hasProperty, ei as make$17, en as succeed$3, er as succeed$5, et as map$4, f as between, fi as isChunk, fn as make$18, fr as deferredFailCause, ft as provide$2, gi as prepend, gn as failureOrCause, gr as deferredMake, gt as repeat, hi as of, hn as fail$3, hr as deferredIsDone, ht as raceWith, i as Defect, ia as constVoid, ii as decode, in as forkIn$1, ir as as$1, it as matchCause, j as die$2, ji as empty$5, jn as inheritAll$1, jr as interruptFiber, jt as tapErrorCause, k as catchAllCause, ki as getOption, kn as scopeTag, kr as interrupt$2, kt as sync$2, l as Struct, li as empty$4, ln as close, lr as deferredAwait, lt as orDie, m as optional$1, mi as map$7, mn as die$1, mr as deferredInterruptWith, mt as race, n as Boolean$, na as constTrue, ni as has, nn as unsafeRunPromiseExit, nr as zip$2, nt as mapError, o as Never, oa as identity, oi as append$1, on as Scope, or as asyncInterrupt, ot as matchEffect, p as decodeUnknown, pi as isEmpty$2, pn as NoSuchElementException, pr as deferredInterrupt, pt as provideService, q as ignore, qi as right, qn as die, qr as empty$6, qt as TaggedError$1, r as Cause, ra as constUndefined, ri as size$2, rn as updateContext$1, rr as zipRight$2, rt as match$5, s as Number$, sa as pipe, si as appendAll, sn as addFinalizer, sr as catchAll, st as negate, t as Array$, ta as constFalse, ti as set$2, tn as unsafeFork, tr as void_$3, tt as mapBoth$1, u as TaggedError, ui as filter, un as extend, ur as deferredComplete, ut as orElse, v as encodeSync, vi as reverse, vn as interrupt$3, vr as deferredUnsafeDone, vt as runPromise, w as annotateLogs, wi as unsafeHead, wn as reduceWithContext, wr as exitVoid, wt as scoped$4, x as acquireUseRelease$2, xi as toArray, xn as isInterrupted, xr as exitFail, xt as sandbox, y as _void, yi as take$2, yn as interruptors, yr as deferredUnsafeMake, yt as runPromiseExit$1, z as flatMap$4, zi as isSome, zn as make$16, zr as tap$1, zt as unsafeMakeSemaphore$1 } from "./chunks/Schema-Dh-mkwkq.mjs";
+import { $ as makeSemaphore, $i as toJSON, $n as mapBoth, $r as none$1, $t as provideMerge$1, A as catchTag, Ai as getOption, An as scopeTag, Ar as interrupt$2, At as sync$2, B as flatten$4, Bi as isSome, Bn as make$16, Br as tap$1, Bt as unsafeMakeSemaphore$1, C as all$1, Ci as unsafeFromArray, Cn as isInterruptedOnly, Cr as exitFailCause, Ct as scope, D as async, Di as Tag, Dn as ensuring$3, Dr as fiberId, Dt as serviceOption, E as asVoid$1, Ei as GenericTag, En as squash, Er as exitZipRight, Et as scopedWith$1, F as exit, Fi as filter$1, Fn as sequential, Fr as onInterrupt, Ft as tryPromise, G as forkScoped, Gi as isLeft, Gn as Class, Gr as withFiberRuntime, Gt as zipRight$3, H as forEach$2, Hi as match$4, Hn as set$1, Hr as uninterruptibleMask$1, Ht as withFiberRuntime$1, I as fail$5, Ii as flatMap$5, In as bind, Ir as scopeClose, It as try_, J as interrupt$4, Ji as right, Jn as die, Jr as empty$6, Jt as TaggedError$1, K as gen, Ki as left, Kn as spanTag, Kr as zipRight$1, Kt as zipWith, L as failCause$4, Li as fromNullable, Ln as bindTo, Lr as succeed$4, Lt as uninterruptible$1, M as dieMessage, Mi as empty$5, Mn as inheritAll$1, Mr as interruptFiber, Mt as tapErrorCause, N as either, Ni as fromIterable, Nn as interruptAllAs$1, Nr as interruptible$1, Nt as timeout, O as catchAll$1, Oi as add, On as forEachConcurrentDiscard, Or as fiberRefLocally, Ot as succeed$6, P as ensuring$2, Pi as splitAt, Pn as join$3, Pr as map$3, Pt as tryMap, Q as logWarning, Qi as format, Qn as map$5, Qr as make$19, Qt as provide$1, R as fiberIdWith, Ri as getOrElse, Rn as sleep, Rr as suspend$4, Rt as uninterruptibleMask, S as addFinalizer$1, Si as toArray, Sn as isInterrupted, Sr as exitFail, St as sandbox, T as as, Ti as unsafeHead, Tn as reduceWithContext, Tr as exitVoid, Tt as scoped$4, U as forkDaemon, Ui as none, Un as update$1, Ur as void_$2, Ut as zip$1, V as fnUntraced, Vi as map$8, Vn as modify$1, Vr as uninterruptible, Vt as when, W as forkIn, Wi as some, Wn as TypeId$10, Wr as whenEffect, Wt as zipLeft, X as intoDeferred, Xi as BaseProto, Xn as failCause$3, Xr as combineAll, Xt as fromEffect$5, Y as interruptible, Yi as pipeArguments, Yn as fail$4, Yr as combine, Yt as tagged, Z as isEffect, Zi as NodeInspectSymbol, Zn as isFailure, Zr as ids, Zt as mergeAll$2, _ as decodeSync, _i as prepend, _n as failureOrCause, _r as deferredMake, _t as repeat, a as Literal, aa as constVoid, ai as decode, an as forkIn$1, ar as as$1, at as matchCauseEffect, b as acquireRelease, bi as take$2, bn as interruptors, br as deferredUnsafeMake, bt as runPromiseExit$1, c as String$, ca as pipe, ci as appendAll, cn as addFinalizer, cr as catchAll, ct as onError, d as Union, di as filter, dn as extend, dr as deferredComplete, dt as orElseSucceed, ea as equals, ei as get$4, en as scoped$3, er as match$3, et as map$4, f as between, fi as fromIterable$1, fn as fork, fr as deferredFail, ft as promise, gi as of, gn as fail$3, gr as deferredIsDone, gt as raceWith, hi as map$7, hn as die$1, hr as deferredInterruptWith, ht as race, i as Defect, ia as constUndefined, ii as size$2, in as updateContext$1, ir as zipRight$2, it as matchCause, j as die$2, ji as omit, jn as _await$2, jr as interruptAsFiber, jt as tap, k as catchAllCause, ki as get$5, kn as scopeMake, kr as flatMap$3, kt as suspend$5, l as Struct, li as drop, ln as addFinalizerExit, lr as currentContext$1, lt as orDie, m as optional$1, mi as isEmpty$2, mn as NoSuchElementException, mr as deferredInterrupt, mt as provideService, n as Boolean$, na as constFalse, ni as set$2, nn as unsafeFork, nr as void_$3, nt as mapError, o as Never, oa as dual, oi as isFinite, on as unsafeMakeSemaphore, or as asVoid, ot as matchEffect, p as decodeUnknown, pi as isChunk, pn as make$18, pr as deferredFailCause, pt as provide$2, q as ignore, qi as match$2, qn as all, qr as DeferredTypeId$1, qt as spaced$1, r as Cause, ra as constTrue, ri as has, rn as unsafeRunPromiseExit, rr as zip$2, rt as match$5, s as Number$, sa as identity, si as append$1, sn as Scope, sr as asyncInterrupt, st as negate, t as Array$, ta as hasProperty, ti as make$17, tn as succeed$3, tr as succeed$5, tt as mapBoth$1, u as TaggedError, ui as empty$4, un as close, ur as deferredAwait, ut as orElse, v as encodeSync, vi as reduce, vn as flipCauseOption, vr as deferredSucceed, vt as retry, w as annotateLogs, wi as unsafeGet, wn as map$6, wr as exitSucceed, wt as scopeWith, x as acquireUseRelease$2, xi as takeRight, xn as isDieType, xr as exitAs, xt as runtime, y as _void, yi as reverse, yn as interrupt$3, yr as deferredUnsafeDone, yt as runPromise, z as flatMap$4, zi as isNone, zn as get$3, zr as sync$1, zt as unsafeMakeLatch } from "./chunks/Schema-B5yK7QrT.mjs";
 import { createRequire } from "node:module";
 import * as Crypto from "node:crypto";
 import { createHash } from "node:crypto";
 import * as Path from "node:path";
-import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { PassThrough } from "node:stream";
 import * as NFS from "node:fs";
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
@@ -5388,8 +5388,17 @@ const resolvedRefOrCorrupted = (ref, hash) => /^[0-9a-f]{40}$/.test(hash) ? succ
 const makeGitImpl = (executor, root) => {
 	const exec = (...args) => run(root, ...args).pipe(provide$2(succeed$1(CommandExecutor, executor)));
 	return {
-		lastCommitSubject: (ref = "HEAD") => exec("git", "log", "-1", "--pretty=%s", ref).pipe(map$4((s) => s.trim())),
-		lastCommitMessage: () => exec("git", "log", "-1", "--pretty=%B").pipe(map$4((s) => s.trim())),
+		lastCommitSubject: (ref = "HEAD") => exec("git", "log", "-1", "--pretty=%s", "--end-of-options", ref).pipe(map$4((s) => s.trim())),
+		lastCommitMessage: (ref = "HEAD") => exec("git", "log", "-1", "--pretty=%B", "--end-of-options", ref).pipe(map$4((s) => s.trim())),
+		currentBranch: () => exec("git", "symbolic-ref", "--quiet", "--short", "HEAD").pipe(map$4((s) => s.trim()), map$4((name) => some(name)), catchAll$1(() => succeed$6(none()))),
+		listRefs: (prefix) => exec("git", "for-each-ref", "--sort=-committerdate", "--format=%(refname)%09%(objectname)%09%(committerdate:iso-strict)", prefix).pipe(map$4((out) => out.split("\n").filter((line) => line.length > 0).map((line) => {
+			const [ref = "", hash = "", date = ""] = line.split("	");
+			return {
+				ref,
+				hash,
+				date
+			};
+		}))),
 		hasCommits: () => exec("git", "rev-parse", "--verify", "HEAD").pipe(map$4(() => true), catchAll$1(() => succeed$6(false))),
 		readFileAtRef: (ref, path) => exec("git", "show", `${ref}:${path}`),
 		changedPaths: (base) => gen(function* () {
@@ -5409,7 +5418,7 @@ const makeGitImpl = (executor, root) => {
 			}
 			return all;
 		}),
-		resolveRef: (ref) => exec("git", "rev-parse", "--verify", ref).pipe(map$4((s) => s.trim()), flatMap$4((hash) => resolvedRefOrCorrupted(ref, hash))),
+		resolveRef: (ref) => exec("git", "rev-parse", "--verify", "--end-of-options", ref).pipe(map$4((s) => s.trim()), flatMap$4((hash) => resolvedRefOrCorrupted(ref, hash))),
 		readRefOption: (ref) => exec("git", "rev-parse", "--verify", "--quiet", ref).pipe(map$4((s) => some(s.trim())), catchAll$1(() => succeed$6(none()))),
 		isAncestor: (a, b) => run(root, "git", "merge-base", "--is-ancestor", a, b).pipe(provide$2(succeed$1(CommandExecutor, executor)), map$4(() => true), catchAll$1(() => succeed$6(false))),
 		mergeBase: (a, b) => exec("git", "merge-base", a, b).pipe(map$4((s) => some(s.trim())), catchAll$1(() => succeed$6(none()))),
@@ -6059,6 +6068,9 @@ const loopLogPath = gen(function* () {
 //#region src/platform/RetainedHistory.ts
 /** Per-worktree (`refs/worktree/gtd/*`) so linked worktrees sharing one `.git` don't clobber each other's retained history. */
 const HISTORY_REF = "refs/worktree/gtd/history";
+/** One ref per finished process, kept past the branch's deletion; distinct from the per-worktree `HISTORY_REF`. */
+const PROCESS_HISTORY_PREFIX = "refs/gtd/history/";
+const processHistoryRef = (hash) => `${PROCESS_HISTORY_PREFIX}${hash}`;
 const readRetainedHistory = (git) => git.readRefOption(HISTORY_REF);
 /**
 * Whether resetting to `tipHash` is safe: HEAD must be an ancestor of
@@ -6855,6 +6867,12 @@ const TRAILER_READERS = {
 	"Gtd-Review-Base": (value, into) => {
 		into.reviewBase ??= value.split(/\s/)[0];
 	},
+	"Gtd-Branch": (value, into) => {
+		if (value !== "") into.branch ??= value;
+	},
+	"Gtd-Version": (value, into) => {
+		if (value !== "") into.version ??= value;
+	},
 	"Gtd-Format": (value, into) => {
 		if (FORMAT_RE.test(value)) into.format ??= Number(value);
 	},
@@ -6873,6 +6891,8 @@ const parseCommitMessage = (message) => {
 		step: void 0,
 		workflow: void 0,
 		reviewBase: void 0,
+		branch: void 0,
+		version: void 0,
 		judge: [],
 		vars: {},
 		config: {},
@@ -6898,6 +6918,8 @@ const formatCommitMessage = (spec) => {
 	for (const [path, hash] of sortedEntries(spec.config)) lines.push(`Gtd-Config: ${hash} ${encodePath(path)}`);
 	if (spec.cost !== void 0) lines.push(`Gtd-Cost: ${spec.cost.cost}${spec.cost.model !== void 0 ? ` ${spec.cost.model}` : ""}`);
 	for (const verdict of spec.judge ?? []) lines.push(`Gtd-Judge: ${JSON.stringify(verdict)}`);
+	if (spec.branch !== void 0) lines.push(`Gtd-Branch: ${spec.branch}`);
+	if (spec.version !== void 0) lines.push(`Gtd-Version: ${spec.version}`);
 	lines.push(`Gtd-Format: 1`);
 	return `${formatSubject(spec.actor, spec.to, spec.from)}\n\n${lines.join("\n")}`;
 };
@@ -8206,6 +8228,14 @@ const planStep = (snapshot, opts = {}) => {
 					message
 				}
 			},
+			...landing.keepHistory !== void 0 ? [{
+				kind: "gitWrite",
+				write: {
+					kind: "updateRef",
+					ref: landing.keepHistory,
+					target: "HEAD"
+				}
+			}] : [],
 			outcome
 		]
 	};
@@ -8513,25 +8543,38 @@ const currentRun = gen(function* () {
 	const config = yield* (yield* ConfigService).load;
 	return yield* computeProcessRun(git, config.workflow);
 });
-/** The process HEAD closes or sits inside — `gtd summary`'s run. */
-const summaryRun = gen(function* () {
-	const git = yield* GitService;
-	const def = (yield* (yield* ConfigService).load).workflow;
-	const headEntry = (yield* git.subjectHistory(1, 0))[0];
-	if (headEntry === void 0) {
+const runAtTip = (git, def, tip) => gen(function* () {
+	if (tip === void 0) {
 		const history = yield* historyUpTo(git, def, void 0);
 		return yield* runOf(history, locateEpisode(def, history));
 	}
-	if (!(parseCommitMessage(headEntry.subject).parsed?.to === def.initial)) {
-		const history = yield* historyUpTo(git, def, headEntry.hash);
+	if (!(parseCommitMessage(tip.subject).parsed?.to === def.initial)) {
+		const history = yield* historyUpTo(git, def, tip.hash);
 		return yield* runOf(history, locateEpisode(def, history));
 	}
-	const parentRef = `${headEntry.hash}~1`;
+	const parentRef = `${tip.hash}~1`;
 	const before = yield* historyUpTo(git, def, parentRef);
 	const location = locateEpisode(def, before);
-	let closing = yield* git.commitHistory(parentRef, headEntry.hash);
-	if (closing.length === 0) closing = yield* git.commitHistory(void 0, headEntry.hash);
-	return yield* runOf([...before, ...closing], { ...location }, headEntry.hash);
+	let closing = yield* git.commitHistory(parentRef, tip.hash);
+	if (closing.length === 0) closing = yield* git.commitHistory(void 0, tip.hash);
+	return yield* runOf([...before, ...closing], { ...location }, tip.hash);
+});
+/** The process HEAD closes or sits inside — `gtd summary`'s run. */
+const summaryRun = gen(function* () {
+	const git = yield* GitService;
+	const def = (yield* (yield* ConfigService).load).workflow;
+	return yield* runAtTip(git, def, (yield* git.subjectHistory(1, 0))[0]);
+});
+/** The process whose finishing commit is `tip` — reads from `tip`'s own ancestry, so it works when no branch reaches it. */
+const closedRunAt = (tip) => gen(function* () {
+	const git = yield* GitService;
+	const def = (yield* (yield* ConfigService).load).workflow;
+	const hash = yield* git.resolveRef(tip);
+	const subject = yield* git.lastCommitSubject(hash);
+	return yield* runAtTip(git, def, {
+		hash,
+		subject
+	});
 });
 const commitTree = (workspace, hash) => {
 	let entries;
@@ -8751,13 +8794,7 @@ const costByModel = (entries) => {
 		cost
 	})).sort((a, b) => b.cost - a.cost || a.model.localeCompare(b.model));
 };
-/** Resolve the rest at `ref`, or at HEAD when `ref` is `undefined`. */
-const restAt = (ref, startOverrides = {}) => gen(function* () {
-	const git = yield* GitService;
-	const config = yield* (yield* ConfigService).load;
-	const workspace = yield* Workspace;
-	const host = yield* Host;
-	const run = yield* computeProcessRun(git, config.workflow, ref);
+const setupFor = (config, run, workspace, host, startOverrides = {}) => gen(function* () {
 	const resolved = yield* workflowOf(config, run);
 	const def = resolved.def;
 	const { vars, env } = settingsFor(resolved, run.pinnedVars, host.env, startOverrides);
@@ -8781,19 +8818,34 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 		tree: commitTree(workspace, c.hash)
 	}));
 	let pendingMemo;
-	const setup = {
+	return {
+		resolved,
 		def,
-		run,
 		vars,
 		env,
-		budget,
-		skills,
-		access,
-		workspace,
-		base,
-		episode,
-		pendingWorktree: () => pendingMemo ??= workspace.worktreeSync()
+		setup: {
+			def,
+			run,
+			vars,
+			env,
+			budget,
+			skills,
+			access,
+			workspace,
+			base,
+			episode,
+			pendingWorktree: () => pendingMemo ??= workspace.worktreeSync()
+		}
 	};
+});
+/** Resolve the rest at `ref`, or at HEAD when `ref` is `undefined`. */
+const restAt = (ref, startOverrides = {}) => gen(function* () {
+	const git = yield* GitService;
+	const config = yield* (yield* ConfigService).load;
+	const workspace = yield* Workspace;
+	const host = yield* Host;
+	const run = yield* computeProcessRun(git, config.workflow, ref);
+	const { resolved, def, vars, env, setup } = yield* setupFor(config, run, workspace, host, startOverrides);
 	const outcome = yield* promise(() => replayFor(setup));
 	const error = replayError(outcome);
 	if (error !== void 0 || outcome.kind !== "rest") return yield* fail$5(error ?? /* @__PURE__ */ new Error("gtd: replay found no rest"));
@@ -8935,14 +8987,21 @@ const initialStepRefusal = (workflow, step, initial) => workflow !== void 0 && s
 	kind: "refusal",
 	message: `gtd: workflow "${workflow}" reaches step "${step}", the default workflow's first step — that is where a finished process waits, so a started process must never land there; rename the step`
 } : void 0;
-const landingTo = (rest, to) => {
-	if (rest.changes.length === 0 && rest.stepDef.kind === "script" && to === rest.state) return {
+const closingTrailers = (branch) => ({
+	version: GTD_VERSION,
+	...isSome(branch) ? { branch: branch.value } : {}
+});
+const isSettledNoop = (rest, to) => rest.changes.length === 0 && rest.stepDef.kind === "script" && to === rest.state;
+const landingTo = (rest, to, branch) => {
+	if (isSettledNoop(rest, to)) return {
 		kind: "noop",
 		settled: true
 	};
-	const starts = noProcessUnderway(rest) && to !== rest.def.initial;
+	const underway = !noProcessUnderway(rest);
+	const starts = !underway && to !== rest.def.initial;
 	const refused = starts ? multilineRefusal(rest.vars) : void 0;
 	if (refused !== void 0) return refused;
+	const finishes = underway && to === rest.def.initial;
 	return {
 		kind: "commit",
 		to,
@@ -8954,8 +9013,10 @@ const landingTo = (rest, to) => {
 			...starts ? {
 				vars: rest.vars,
 				config: rest.config
-			} : {}
-		}
+			} : {},
+			...finishes ? closingTrailers(branch) : {}
+		},
+		...finishes ? { keepHistory: processHistoryRef(rest.run.startHash) } : {}
 	};
 };
 /**
@@ -8963,7 +9024,7 @@ const landingTo = (rest, to) => {
 * replay with the working tree as the pending turn. The target step is
 * computed by replaying, never matched.
 */
-const decideLanding = (rest, verdicts) => gen(function* () {
+const decideLanding = (rest, verdicts, branch) => gen(function* () {
 	const early = cleanLanding(rest);
 	if (early !== void 0) return early;
 	if (rest.stepDef.kind === "prompt" && rest.stepDef.access?.write != null) {
@@ -8979,13 +9040,14 @@ const decideLanding = (rest, verdicts) => gen(function* () {
 	}));
 	const to = yield* landingTarget(outcome, rest);
 	if (typeof to !== "string") return to;
-	return landingTo(rest, to);
+	return landingTo(rest, to, branch);
 });
 /** Where landing the pending turn would leave the process, or `undefined` when it would land nothing. */
-const previewLanding = (rest) => decideLanding(rest, void 0).pipe(map$4((landing) => landing.kind === "commit" ? landing.to : void 0), catchAll$1(() => succeed$6(void 0)));
+const previewLanding = (rest) => decideLanding(rest, void 0, none()).pipe(map$4((landing) => landing.kind === "commit" ? landing.to : void 0), catchAll$1(() => succeed$6(void 0)));
 /** Every fact the pure landing planner needs, read once: the rest, its steering file, and the landing decision. */
 const snapshotFromRest = (rest, verdicts) => gen(function* () {
-	const landing = yield* decideLanding(rest, verdicts);
+	const branch = yield* (yield* GitService).currentBranch();
+	const landing = yield* decideLanding(rest, verdicts, branch);
 	return {
 		stepDef: rest.stepDef,
 		state: rest.state,
@@ -9016,6 +9078,66 @@ const summaryFor = (run) => gen(function* () {
 		...settingsFor(resolved, run.pinnedVars, host.env)
 	});
 });
+/** Repository-relative paths of the config files today's config and the process's own record name; one outside the repository cannot be read at a ref, so it is left out. */
+const inRepoConfigPaths = (root, files, recorded) => {
+	const paths = new Set(Object.keys(recorded));
+	for (const file of files) paths.add(relative(root, resolve(root, file)).split(sep).join("/"));
+	return [...paths].filter((p) => p !== "" && !p.startsWith("..") && !isAbsolute(p)).sort();
+};
+const configRefusal = (tip, paths) => /* @__PURE__ */ new Error(`gtd history: refused — config differs at ${tip.slice(0, 7)}: ${paths.join(", ")}. A history ref replays under today's config, so it is unreadable after the config changes`);
+const differingConfigPaths = (git, workspace, root, config, run, hash) => gen(function* () {
+	const differing = [];
+	for (const path of inRepoConfigPaths(root, config.workflowFiles, run.pinnedConfig?.files ?? {})) if ((yield* orElseSucceed(git.readFileAtRef(hash, path), () => void 0)) !== workspace.readSync(path)) differing.push(path);
+	return differing;
+});
+const notClosedError = (hash, outcome) => outcome.kind === "rest" ? /* @__PURE__ */ new Error(`gtd history: ${hash.slice(0, 7)} does not close a process under today's config`) : replayError(outcome) ?? /* @__PURE__ */ new Error("gtd history: replay failed");
+const historySteps = (run) => {
+	const messages = new Map(run.episode.commits.map((c) => [c.hash, c.message]));
+	return run.trace.map((entry) => {
+		const message = parseCommitMessage(messages.get(entry.hash) ?? "");
+		return {
+			hash: entry.hash,
+			subject: (messages.get(entry.hash) ?? "").split("\n")[0] ?? "",
+			actor: entry.actor,
+			from: message.parsed?.from,
+			to: entry.state,
+			verdicts: message.judge
+		};
+	});
+};
+const versionWarningFor = (recorded) => recorded === GTD_VERSION ? void 0 : `gtd: warning: this history was recorded by ${recorded === void 0 ? "an unknown gtd version" : `gtd ${recorded}`} and is replayed by gtd ${GTD_VERSION} — a workflow imported from @pmelab/gtd/workflows may have changed since`;
+/**
+* Replays the closed run at `tip` under today's config. The workflow is not
+* fingerprinted for a version change: one imported from `@pmelab/gtd/workflows`
+* moves with every upgrade, and the version warning is the only signal.
+*/
+const historyTrail = (tip) => gen(function* () {
+	const git = yield* GitService;
+	const config = yield* (yield* ConfigService).load;
+	const workspace = yield* Workspace;
+	const host = yield* Host;
+	const hash = yield* git.resolveRef(tip);
+	const run = yield* closedRunAt(hash);
+	const differing = yield* differingConfigPaths(git, workspace, host.root, config, run, hash);
+	if (differing.length > 0) return yield* fail$5(configRefusal(hash, differing));
+	const { setup } = yield* setupFor(config, run, workspace, host);
+	yield* workspace.episodeTrees(run.episode.base, run.episode.commits.map((c) => c.hash));
+	const outcome = yield* promise(() => replayFor(setup));
+	if (outcome.kind !== "ended") return yield* fail$5(notClosedError(hash, outcome));
+	const steps = historySteps(run);
+	const recorded = parseCommitMessage(yield* git.lastCommitMessage(hash)).version;
+	const versionWarning = versionWarningFor(recorded);
+	return {
+		tip: hash,
+		steps,
+		ended: outcome.via,
+		version: {
+			recorded,
+			running: GTD_VERSION
+		},
+		...versionWarning !== void 0 ? { versionWarning } : {}
+	};
+});
 //#endregion
 //#region src/emit/GitScript.ts
 const shellQuote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
@@ -9037,8 +9159,8 @@ const commitAllowEmpty = (message) => {
 		`fi`
 	].join("\n");
 };
-/** `git add -A` then `commitAllowEmpty`, joined with `&&` so a failing `git add` never reaches the commit. */
-const commitAll = (message) => `git add -A &&\n${commitAllowEmpty(message)}`;
+/** `git add -A || exit 1` (an `&&` left side would not abort under `set -e`) then `commitAllowEmpty`. */
+const commitAll = (message) => `git add -A || exit 1\n${commitAllowEmpty(message)}`;
 /** No current caller — see `Git.ts`'s `GitWriterOperations.commitAsIs` for why it's kept anyway. */
 const commitAsIs = (message) => commitAllowEmpty(message);
 /** No current caller — see `Git.ts`'s `GitWriterOperations.softResetTo` for why it's kept anyway. */
@@ -9056,6 +9178,17 @@ const discardPending = () => `git add -A && git reset --hard HEAD`;
 const updateRef = (ref, hash) => `git update-ref ${shellQuote(ref)} ${shellQuote(hash)}`;
 /** `git update-ref -d <ref>` — idempotent: deleting a missing ref is already a no-op in real git. */
 const deleteRef = (ref) => `git update-ref -d ${shellQuote(ref)}`;
+/**
+* No `+` on the refspec: a local ref the remote's tip does not descend from
+* fails the fetch instead of being overwritten (a fast-forward still applies).
+*/
+const fetchHistoryRefs = (remote) => [
+	`set -eu`,
+	`before=$(git for-each-ref --format='x' 'refs/gtd/history/' | wc -l)`,
+	`git fetch ${shellQuote(remote)} 'refs/gtd/history/*:refs/gtd/history/*'`,
+	`after=$(git for-each-ref --format='x' 'refs/gtd/history/' | wc -l)`,
+	`printf '%s history refs arrived\\n' "$((after - before))"`
+].join("\n");
 /** Marks an emitted block as print-only — mirrors `OutcomeScript.ts`'s `OUTCOME_MARKER` verbatim, so `src/testkit/EmittedScriptRecognizer.ts` recognizes either path's output identically. */
 const OUTCOME_MARKER$1 = "# gtd: outcome (print-only)";
 const printfLine$1 = (fmt, args) => `${OUTCOME_MARKER$1}\nprintf ${shellQuote(fmt.replace(/\n/g, "\\n"))} ${args.join(" ")}`;
@@ -9073,6 +9206,7 @@ const renderOutcome = (outcome) => {
 const renderGitWrite = (write) => {
 	switch (write.kind) {
 		case "commitAll": return commitAll(write.message);
+		case "updateRef": return updateRef(write.ref, write.target);
 	}
 };
 /**
@@ -9440,7 +9574,7 @@ const validateScriptFor = (resolved, file) => gen(function* () {
 */
 var ToolCommands = class extends Tag("ToolCommands")() {};
 //#endregion
-//#region src/cli/Program.ts
+//#region src/cli/Output.ts
 /**
 * A command-level failure that should exit like a CLI usage error (2), not a
 * generic runtime failure (1): an unknown `--json=<path>` selector, or a
@@ -9450,12 +9584,92 @@ var ToolCommands = class extends Tag("ToolCommands")() {};
 * about the resolved rest's own state.
 */
 var SelectorUsageError = class extends Error {};
-/** The `--json=<path>` select branch, shared by all three emitting commands so none drift on the unknown-selector message. `absent` writes nothing and lets the caller's success path continue. */
+/** The `--json=<path>` select branch, shared by the emitting commands so none drift on the unknown-selector message. `absent` writes nothing and lets the caller's success path continue. */
 const writeSelection = (out, fields, path) => gen(function* () {
 	const selection = selectPath(fields, path);
 	if (selection.kind === "value") out.write(`${selection.text}\n`);
 	else if (selection.kind === "unknown") return yield* fail$5(new SelectorUsageError(`gtd: unknown --json selector "${selection.path}" — see \`gtd --help\``));
 });
+//#endregion
+//#region src/cli/History.ts
+/** Newest tip first. */
+const historyEntries = gen(function* () {
+	const git = yield* GitService;
+	return yield* forEach$2((yield* git.listRefs(PROCESS_HISTORY_PREFIX)).filter(({ ref }) => ENTRY_HASH.test(ref.slice(17))), ({ ref, hash, date }) => gen(function* () {
+		const entry = ref.slice(17);
+		return {
+			ref,
+			entry,
+			branch: parseCommitMessage(yield* git.lastCommitMessage(hash)).branch ?? null,
+			tip: hash,
+			date,
+			subject: yield* git.lastCommitSubject(entry)
+		};
+	}));
+});
+const ENTRY_HASH = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
+const HEX = /^[0-9a-f]+$/i;
+/**
+* Lookup order: full ref; then entry hash or hex prefix (unique → it, several
+* → fail listing them); then branch name (newest tip first, as `entries` is
+* ordered). A hex-looking name that matches no entry still resolves as a
+* branch. No match → fail.
+*/
+const resolveHistoryRef = (arg, entries) => {
+	const byRef = entries.find((e) => e.ref === arg);
+	if (byRef !== void 0) return succeed$6(byRef);
+	if (HEX.test(arg)) {
+		const lower = arg.toLowerCase();
+		const matches = entries.filter((e) => e.entry.toLowerCase().startsWith(lower));
+		if (matches.length === 1) return succeed$6(matches[0]);
+		if (matches.length > 1) return fail$5(/* @__PURE__ */ new Error(`gtd history: "${arg}" is ambiguous — it matches:\n${matches.map((e) => `  ${e.entry} ${e.branch ?? "-"}`).join("\n")}`));
+	}
+	const byBranch = entries.find((e) => e.branch === arg);
+	if (byBranch !== void 0) return succeed$6(byBranch);
+	return fail$5(/* @__PURE__ */ new Error(`gtd history: no history ref matches "${arg}"`));
+};
+const seven = (hash) => hash.slice(0, 7);
+/** Writes `document` per `json` (bare → whole, `=path` → one value); returns false for `off`. */
+const writeJson = (json, out, document) => gen(function* () {
+	if (json.kind === "off") return false;
+	if (json.kind === "document") out.write(`${JSON.stringify(document)}\n`);
+	else yield* writeSelection(out, document, json.path);
+	return true;
+});
+const runHistoryListCommand = (json, out) => gen(function* () {
+	const entries = yield* historyEntries;
+	if (yield* writeJson(json, out, entries)) return;
+	if (entries.length === 0) {
+		out.write("no history refs; run gtd history fetch | sh to pull them\n");
+		return;
+	}
+	out.write(entries.map((e) => `${seven(e.entry)} ${e.branch ?? "-"} ${seven(e.tip)} ${e.date} ${e.subject}\n`).join(""));
+});
+const runHistoryShowCommand = (ref, json, out) => gen(function* () {
+	const entry = yield* resolveHistoryRef(ref, yield* historyEntries);
+	const trail = yield* historyTrail(entry.tip);
+	const document = {
+		ref: entry.ref,
+		entry: entry.entry,
+		branch: entry.branch,
+		...trail
+	};
+	if (yield* writeJson(json, out, document)) return;
+	if (trail.versionWarning !== void 0) yield* (yield* Narrator).warn(trail.versionWarning);
+	const lines = [`${entry.ref} (branch ${entry.branch ?? "-"}, tip ${seven(entry.tip)})`];
+	for (const step of trail.steps) {
+		lines.push(`${seven(step.hash)} ${step.subject}`);
+		for (const v of step.verdicts) lines.push(`  judge ${v.id} = ${v.answer} (p=${v.p})`);
+	}
+	lines.push(`ended (${trail.ended})`);
+	out.write(`${lines.join("\n")}\n`);
+});
+/** Prints the script and never runs git: gtd's promise that it only decides and prints. */
+const runHistoryFetchCommand = (remote, out) => sync$2(() => {
+	out.write(`${combinedScript(fetchHistoryRefs(remote), "")}\n`);
+});
+//#endregion
+//#region src/cli/Program.ts
 const selfGtd = () => {
 	const script = process.argv[1];
 	return script === void 0 ? ["gtd"] : [process.execPath, script];
@@ -10074,6 +10288,9 @@ const dispatchVoidCommand = (command, json, out) => {
 		case "judge": return runJudgeCommand(json, out);
 		case "judgeAnswer": return runJudgeAnswerCommand(json, out);
 		case "judgeRun": return runJudgeRunCommand(command, out);
+		case "historyList": return runHistoryListCommand(json, out);
+		case "historyShow": return runHistoryShowCommand(command.ref, json, out);
+		case "historyFetch": return runHistoryFetchCommand(command.remote, out);
 	}
 };
 /**
@@ -10112,13 +10329,13 @@ const FLAGS = [
 		name: "--json",
 		arity: "optional",
 		repeatable: false,
-		scope: (kind) => kind === "next" || kind === "land" || kind === "judge" || kind === "judgeAnswer" || kind === "doors",
+		scope: (kind) => kind === "next" || kind === "land" || kind === "judge" || kind === "judgeAnswer" || kind === "doors" || kind === "historyList" || kind === "historyShow",
 		decode: ([raw]) => right(raw ?? ""),
-		scopeError: "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors` — every other command prints plain text; see `gtd install` for the driver protocol briefing",
+		scopeError: "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd history list`/`gtd history show` — every other command prints plain text; see `gtd install` for the driver protocol briefing",
 		valueHint: "<path>",
 		help: [
-			"(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors only) output",
-			"structured JSON. Bare --json prints the whole document;",
+			"(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd history",
+			"list/gtd history show only) output structured JSON. Bare --json prints the whole document;",
 			"--json=<path> (a dotted key path into that document, e.g.",
 			"kind, content, session.id) prints just that value: a",
 			"scalar raw and unquoted, a boolean as true/false, a list",
@@ -10626,6 +10843,44 @@ const COMMAND_ROWS = [
 			"repository. jev and llm exit 1 when they cannot answer",
 			"every question, with nothing on stdout"
 		]
+	},
+	{
+		token: "history list",
+		kind: "historyList",
+		arity: "none",
+		details: [
+			"List the finished processes kept behind refs/gtd/history/*,",
+			"newest first: entry, branch, tip, date and subject per line.",
+			"--json prints one array of { ref, entry, branch, tip, date,",
+			"subject }. Writes nothing and never replays; with no refs it",
+			"hints at `gtd history fetch | sh` and still exits 0"
+		]
+	},
+	{
+		token: "history show",
+		kind: "historyShow",
+		arity: { name: "ref" },
+		details: [
+			"Replay one kept process under today's config and print its",
+			"steps and judge verdicts. <ref> is a full ref, an entry hash",
+			"(or unique prefix) or a branch name. Refuses (exit 1) when a",
+			"config file differs from its content at the ref's tip. A",
+			"version mismatch only warns on stderr. --json prints the",
+			"trail as one document; writes nothing"
+		]
+	},
+	{
+		token: "history fetch",
+		kind: "historyFetch",
+		arity: {
+			name: "remote",
+			optional: true
+		},
+		details: [
+			"Print a script that fetches every refs/gtd/history/* from",
+			"<remote> (default origin) and reports how many arrived — run",
+			"it with `gtd history fetch | sh`. Never runs git itself"
+		]
 	}
 ];
 const commandByToken = (token) => COMMAND_ROWS.find((r) => r.token === token);
@@ -10645,7 +10900,7 @@ const flagHeader = (row) => {
 };
 const renderHelp = () => {
 	const commandBlocks = COMMAND_ROWS.map((row) => {
-		const header = row.arity === "none" ? row.token : "names" in row.arity ? `${row.token} <${row.arity.names[0]}> <${row.arity.names[1]}>` : "variadic" in row.arity ? `${row.token} <${row.arity.name}> [${row.arity.variadic}...]` : `${row.token} <${row.arity.name}>`;
+		const header = row.arity === "none" ? row.token : "names" in row.arity ? `${row.token} <${row.arity.names[0]}> <${row.arity.names[1]}>` : "variadic" in row.arity ? `${row.token} <${row.arity.name}> [${row.arity.variadic}...]` : "optional" in row.arity ? `${row.token} [${row.arity.name}]` : `${row.token} <${row.arity.name}>`;
 		return renderBlock(header, row.details);
 	});
 	return `Usage: gtd [command] [options]\n\nCommands:\n${[
@@ -10756,6 +11011,7 @@ const conflictViolation = (present) => {
 const arityError = (cmd, rest, arity) => {
 	if (arity === "none") return rest.length > 0 ? `gtd ${cmd}: too many arguments — expected none, got: ${rest.join(", ")}` : void 0;
 	if ("names" in arity) return pairArityError(cmd, rest, arity.names);
+	if ("optional" in arity) return rest.length > 1 ? `gtd ${cmd}: too many arguments — expected at most one ${arity.name}, got: ${rest.join(", ")}` : void 0;
 	if (rest.length === 0) return `gtd ${cmd}: missing ${arity.name} argument`;
 	if (!("variadic" in arity) && rest.length > 1) return `gtd ${cmd}: too many arguments — expected one ${arity.name}, got: ${rest.join(", ")}`;
 };
@@ -10806,7 +11062,9 @@ const parseArgv = (argv) => {
 		kind: "output",
 		stdout: renderHelp()
 	};
-	const row = first === void 0 ? void 0 : commandByToken(first);
+	const isHistory = first === "history";
+	const row = first === void 0 ? void 0 : commandByToken(isHistory ? `history ${positionals[1] ?? ""}` : first);
+	if (isHistory && row === void 0) return usagePlan("gtd history: expected a subcommand — list, show <ref> or fetch [remote]", jsonSeen);
 	const judgeAnswer = row?.kind === "judge" && positionals[1] === "answer";
 	const selectsStart = workflowPresent && first === void 0;
 	const judgeRun = row?.kind === "judge" && positionals[1] === "run";
@@ -10817,11 +11075,11 @@ const parseArgv = (argv) => {
 		if (first === void 0) return usagePlan("gtd: missing command — gtd decides and prints, a driver executes; run `gtd install`, or copy one from https://github.com/pmelab/gtd/blob/main/docs/driver.md's \"A complete minimal driver\" section and run that, or see usage above (`gtd --help`)", jsonSeen, renderHelp());
 		return usagePlan(`unknown command '${first}'`, jsonSeen);
 	}
-	const restPositionals = first === void 0 ? positionals : positionals.slice(judgeAnswer || judgeRun ? 2 : 1);
+	const restPositionals = first === void 0 ? positionals : positionals.slice(judgeAnswer || judgeRun || isHistory ? 2 : 1);
 	if (kind === "start" && first === void 0) {
 		if (restPositionals.length > 0) return usagePlan(`gtd: too many arguments — expected none, got: ${restPositionals.join(", ")}`, jsonSeen);
 	} else {
-		const arityMsg = kind === "check" && restPositionals.length === 0 && present.has("--open-threads") ? void 0 : arityError(first, restPositionals, row.arity);
+		const arityMsg = kind === "check" && restPositionals.length === 0 && present.has("--open-threads") ? void 0 : arityError(isHistory ? row.token : first, restPositionals, row.arity);
 		if (arityMsg !== void 0) return usagePlan(arityMsg, jsonSeen);
 	}
 	const violation = scopeViolation(kind, present);
@@ -10910,6 +11168,24 @@ const parseArgv = (argv) => {
 			verbose
 		};
 	}
+	if (kind === "historyShow") return {
+		kind: "command",
+		command: {
+			kind: "historyShow",
+			ref: restPositionals[0]
+		},
+		json,
+		verbose
+	};
+	if (kind === "historyFetch") return {
+		kind: "command",
+		command: {
+			kind: "historyFetch",
+			remote: restPositionals[0] ?? "origin"
+		},
+		json,
+		verbose
+	};
 	if (kind === "uncheck") return {
 		kind: "command",
 		command: {
@@ -11010,6 +11286,7 @@ var InMemRepo = class InMemRepo {
 	currentBranch = "main";
 	worktree = /* @__PURE__ */ new Map();
 	index = /* @__PURE__ */ new Map();
+	nextSeq = 1;
 	getCommit(hash) {
 		return this.commits.get(hash) ?? null;
 	}
@@ -11084,10 +11361,25 @@ var InMemRepo = class InMemRepo {
 		if (!c) return null;
 		return c.message.split("\n")[0] ?? null;
 	}
-	lastCommitMessage() {
-		const c = this.headCommit();
-		if (!c) return null;
-		return c.message;
+	lastCommitMessage(ref) {
+		const hash = ref === void 0 ? this.head : this.resolveRef(ref);
+		const c = hash === null ? null : this.getCommit(hash);
+		return c === null ? null : c.message;
+	}
+	branchName() {
+		return this.currentBranch;
+	}
+	/** Refs under `prefix`, newest tip first; the commit sequence number stands in for the committer date. */
+	listRefs(prefix) {
+		return [...this.refs.entries()].filter(([ref]) => ref.startsWith(prefix)).map(([ref, hash]) => ({
+			ref,
+			hash,
+			seq: this.getCommit(hash)?.seq ?? 0
+		})).sort((a, b) => b.seq - a.seq).map(({ ref, hash, seq }) => ({
+			ref,
+			hash,
+			date: (/* @__PURE__ */ new Date(seq * 1e3)).toISOString().replace(/\.\d{3}Z$/, "Z")
+		}));
 	}
 	/**
 	* `head` (default `this.head`, mirroring production's `"HEAD"` default) is
@@ -11201,7 +11493,8 @@ var InMemRepo = class InMemRepo {
 			hash,
 			message,
 			files: new Map(tree),
-			parent
+			parent,
+			seq: this.nextSeq++
 		};
 		this.commits.set(hash, commit);
 		this.head = hash;
@@ -11222,7 +11515,8 @@ var InMemRepo = class InMemRepo {
 			hash,
 			message,
 			files: new Map(tree),
-			parent
+			parent,
+			seq: this.nextSeq++
 		};
 		this.commits.set(hash, commit);
 		this.head = hash;
@@ -11364,10 +11658,12 @@ const makeGitReaderOps = (repo, root) => ({
 		const subject = repo.lastCommitSubject(ref);
 		return subject !== null ? succeed$6(subject) : fail$5(/* @__PURE__ */ new Error("No commits"));
 	},
-	lastCommitMessage: () => {
-		const message = repo.lastCommitMessage();
+	lastCommitMessage: (ref) => {
+		const message = repo.lastCommitMessage(ref);
 		return message !== null ? succeed$6(message) : fail$5(/* @__PURE__ */ new Error("No commits"));
 	},
+	currentBranch: () => succeed$6(some(repo.branchName())),
+	listRefs: (prefix) => succeed$6(repo.listRefs(prefix)),
 	resolveRef: (ref) => {
 		const hash = repo.resolveRef(ref);
 		return hash !== null ? succeed$6(hash) : fail$5(/* @__PURE__ */ new Error(`Cannot resolve ref: ${ref}`));
@@ -11647,7 +11943,7 @@ const recognizeGitBuilders = (repo, block) => {
 		return { kind: "applied" };
 	}
 	const conditionLine = conditionStatement(block);
-	if (block.startsWith("git add -A &&\n")) {
+	if (block.startsWith("git add -A || exit 1\n")) {
 		const [message] = extractQuotedTokens(conditionLine);
 		if (message !== void 0 && commitAll(message) === block) {
 			repo.commitAllWithPrefix(message);
@@ -12212,6 +12508,21 @@ const gitExecIn = (dir, ...args) => execSync(`git ${args.join(" ")}`, {
 const makeLiveTier = (initialCommit = true) => {
 	const root = realpathSync(mkdtempSync(join(tmpdir(), "gtd-git-tier-")));
 	const gitExec = (...args) => gitExecIn(root, ...args);
+	let tick = 0;
+	const commitEnv = () => ({
+		...process.env,
+		GIT_COMMITTER_DATE: new Date(Date.UTC(2024, 0, 1, 0, 0, ++tick)).toISOString()
+	});
+	const gitCommit = (message, allowEmpty = false) => execFileSync("git", [
+		"commit",
+		...allowEmpty ? ["--allow-empty"] : [],
+		"-m",
+		message
+	], {
+		cwd: root,
+		env: commitEnv(),
+		stdio: "pipe"
+	});
 	gitExec("init");
 	gitExec(`config user.email "test@test.com"`);
 	gitExec(`config user.name "Test"`);
@@ -12219,7 +12530,7 @@ const makeLiveTier = (initialCommit = true) => {
 	if (initialCommit) {
 		writeFileSync(join(root, "readme.txt"), "hello");
 		gitExec("add", "-A");
-		gitExec(`commit -m "init: first commit"`);
+		gitCommit("init: first commit");
 	}
 	const provide = (eff) => runPromise(eff.pipe(provide$2(GitService.Live), provide$2(Host.layer({
 		root,
@@ -12250,7 +12561,7 @@ const makeLiveTier = (initialCommit = true) => {
 					writeFileSync(join(root, path), content);
 				}
 				gitExec("add", "-A");
-				gitExec(`commit --allow-empty -m "${message}"`);
+				gitCommit(message, true);
 			},
 			writeFile: (path, content) => {
 				mkdirSync(dirname(join(root, path)), { recursive: true });
@@ -12414,6 +12725,54 @@ const runGitServiceContract = (makeTier) => {
 			expect(await runGit(t, (g) => g.lastCommitMessage())).toBe("feat: subject only");
 		});
 	});
+	describe("lastCommitMessage with a ref", () => {
+		it("reads the given ref's full message, not HEAD's", async () => {
+			t.seed.commit("feat: first\n\nGtd-Branch: one");
+			t.seed.commit("feat: second", { "extra.txt": "extra" });
+			expect(await runGit(t, (g) => g.lastCommitMessage("HEAD~1"))).toBe("feat: first\n\nGtd-Branch: one");
+		});
+	});
+	describe("currentBranch", () => {
+		it("is the checked-out branch's name", async () => {
+			expect(isSome(await runGit(t, (g) => g.currentBranch()))).toBe(true);
+		});
+		it.skipIf(!capabilities.onDiskContent)("is none on a detached HEAD, never a failure", async () => {
+			gitExecIn(t.root, "checkout", "--detach", "HEAD");
+			expect(isNone(await runGit(t, (g) => g.currentBranch()))).toBe(true);
+		});
+	});
+	describe("listRefs", () => {
+		it("is [] when no ref lives under the prefix", async () => {
+			expect(await runGit(t, (g) => g.listRefs("refs/gtd/history/"))).toEqual([]);
+		});
+		it("lists {ref, hash, date} for refs under the prefix only, newest tip first", async () => {
+			const first = t.observe.resolveRef("HEAD");
+			t.seed.commit("feat: second", { "second.txt": "2" });
+			const second = t.observe.resolveRef("HEAD");
+			t.seed.updateRef("refs/gtd/history/old", first);
+			t.seed.updateRef("refs/gtd/history/new", second);
+			t.seed.updateRef("refs/gtd/other/elsewhere", second);
+			const refs = await runGit(t, (g) => g.listRefs("refs/gtd/history/"));
+			expect(refs.map((r) => [r.ref, r.hash])).toEqual([["refs/gtd/history/new", second], ["refs/gtd/history/old", first]]);
+			for (const r of refs) expect(r.date.length).toBeGreaterThan(0);
+		});
+		it("reports the date as ISO 8601 strict", async () => {
+			t.seed.updateRef("refs/gtd/history/x", t.observe.resolveRef("HEAD"));
+			const [entry] = await runGit(t, (g) => g.listRefs("refs/gtd/history/"));
+			expect(entry?.date).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|[+-]\d{2}:\d{2})$/);
+		});
+	});
+	describe("history reachable only from a retained ref", () => {
+		it("commitHistory and readFileAtRef read it after HEAD moved off those commits", async () => {
+			t.seed.commit("feat: second", { "kept.txt": "kept" });
+			const tip = t.observe.resolveRef("HEAD");
+			t.seed.updateRef("refs/gtd/history/tip", tip);
+			t.seed.mixedReset("HEAD~1");
+			expect(t.observe.resolveRef("HEAD")).not.toBe(tip);
+			expect((await runGit(t, (g) => g.commitHistory(void 0, "refs/gtd/history/tip"))).map((c) => c.message)).toEqual(["init: first commit", "feat: second"]);
+			expect(await runGit(t, (g) => g.readFileAtRef("refs/gtd/history/tip", "kept.txt"))).toBe("kept");
+		});
+	});
 	describe("hasCommits", () => {
 		it("returns false in an empty repo", async () => {
 			const empty = t.emptyRepo();
@@ -12974,6 +13333,11 @@ const runGitScriptContract = () => {
 			expect(t.observe.refExists("refs/gtd/marker")).toBe(true);
 			expect(t.observe.resolveRef("refs/gtd/marker")).toBe(head);
 		});
+		it("updateRef with HEAD points the ref at the commit just made", () => {
+			execScript(t, commitAll("feat: just made"));
+			execScript(t, updateRef("refs/gtd/history/x", "HEAD"));
+			expect(t.observe.resolveRef("refs/gtd/history/x")).toBe(t.observe.resolveRef("HEAD"));
+		});
 		it("deleteRef removes an existing ref, and tolerates deleting it again", () => {
 			const head = t.observe.resolveRef("HEAD");
 			execScript(t, updateRef("refs/gtd/marker", head));
@@ -12986,6 +13350,54 @@ const runGitScriptContract = () => {
 			expect(t.observe.refExists("refs/gtd/never-created")).toBe(false);
 		});
 	});
+	describe("fetchHistoryRefs", () => {
+		it("pulls every refs/gtd/history/* from a bare remote and prints the count", () => {
+			const bare = realpathSync(mkdtempSync(join(tmpdir(), "gtd-git-tier-bare-")));
+			try {
+				gitExecIn(bare, "init", "-q", "--bare");
+				gitExecIn(t.root, "remote", "add", "origin", bare);
+				const head = t.observe.resolveRef("HEAD");
+				gitExecIn(t.root, "push", "-q", "origin", `${head}:refs/gtd/history/one`);
+				gitExecIn(t.root, "push", "-q", "origin", `${head}:refs/gtd/history/two`);
+				gitExecIn(t.root, "push", "-q", "origin", `${head}:refs/gtd/other/skip`);
+				const out = execFileSync("bash", ["-c", fetchHistoryRefs("origin")], {
+					cwd: t.root,
+					encoding: "utf8"
+				});
+				expect(t.observe.refExists("refs/gtd/history/one")).toBe(true);
+				expect(t.observe.refExists("refs/gtd/history/two")).toBe(true);
+				expect(t.observe.refExists("refs/gtd/other/skip")).toBe(false);
+				expect(out.trim()).toBe("2 history refs arrived");
+			} finally {
+				rmSync(bare, {
+					recursive: true,
+					force: true
+				});
+			}
+		});
+		it("fails loudly when a local history ref conflicts with the remote's", () => {
+			const bare = realpathSync(mkdtempSync(join(tmpdir(), "gtd-git-tier-bare-")));
+			try {
+				gitExecIn(bare, "init", "-q", "--bare");
+				gitExecIn(t.root, "remote", "add", "origin", bare);
+				const first = t.observe.resolveRef("HEAD");
+				t.seed.commit("feat: second", { "second.txt": "x" });
+				const second = t.observe.resolveRef("HEAD");
+				gitExecIn(t.root, "push", "-q", "origin", `${first}:refs/gtd/history/one`);
+				t.seed.updateRef("refs/gtd/history/one", second);
+				expect(() => execFileSync("bash", ["-c", fetchHistoryRefs("origin")], {
+					cwd: t.root,
+					stdio: "pipe"
+				})).toThrow();
+				expect(t.observe.resolveRef("refs/gtd/history/one")).toBe(second);
+			} finally {
+				rmSync(bare, {
+					recursive: true,
+					force: true
+				});
+			}
+		});
+	});
 };
 //#endregion
 //#region src/testkit/StrictGitOperations.ts