@pmelab/gtd 15.2.0 → 15.2.1

package/dist/gtd.bundle.mjs

@@ -8,7 +8,7 @@ import { isIP } from "node:net";
 import * as Crypto from "node:crypto";
 import { createHash, randomUUID } from "node:crypto";
 import * as NFS from "node:fs";
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, realpathSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import * as OS from "node:os";
 import { homedir, tmpdir } from "node:os";
 import * as Path from "node:path";
@@ -47623,6 +47623,7 @@ const makeGitImpl = (executor, root) => {
 		isAncestor: (a, b) => run$1(root, "git", "merge-base", "--is-ancestor", a, b).pipe(provide$2(succeed$2(CommandExecutor, executor)), map$4(() => true), catchAll(() => succeed$3(false))),
 		topLevel: () => exec("git", "rev-parse", "--show-toplevel").pipe(map$4((s) => s.trim())),
 		gitDir: () => exec("git", "rev-parse", "--absolute-git-dir").pipe(map$4((s) => s.trim())),
+		gitCommonDir: () => exec("git", "rev-parse", "--path-format=absolute", "--git-common-dir").pipe(map$4((s) => s.trim())),
 		commitHistory: (base, head = "HEAD") => {
 			const range = base !== void 0 ? `${base}..${head}` : head !== "HEAD" ? head : void 0;
 			const args = [
@@ -47647,6 +47648,27 @@ const makeGitImpl = (executor, root) => {
 				};
 			})), catchAll(() => succeed$3([])));
 		},
+		subjectHistory: (pageSize, skip, head = "HEAD") => {
+			const ref = head !== "HEAD" ? head : void 0;
+			const args = [
+				"git",
+				"log",
+				"--first-parent",
+				"--reverse",
+				"-z",
+				"--format=%H%x02%s",
+				`--skip=${skip}`,
+				...Number.isFinite(pageSize) ? [`--max-count=${pageSize}`] : [],
+				...ref !== void 0 ? [ref] : []
+			];
+			return exec(...args).pipe(map$4((out) => splitNul(out).map((chunk) => {
+				const sep = chunk.indexOf("");
+				return {
+					hash: (sep === -1 ? chunk : chunk.slice(0, sep)).trim(),
+					subject: (sep === -1 ? "" : chunk.slice(sep + 1)).trim()
+				};
+			})), catchAll(() => succeed$3([])));
+		},
 		commitAllWithPrefix: (prefix) => gen(function* () {
 			yield* exec("git", "add", "-A");
 			yield* exec("git", "commit", "--allow-empty", "-m", prefix).pipe(catchAll((error) => error.message.includes("empty git commit") ? exec("git", "commit", "--allow-empty", "--no-verify", "-m", prefix) : fail$2(error)));
@@ -47676,6 +47698,158 @@ var GitService = class GitService extends Tag("GitService")() {
 const toError = (e) => e instanceof Error ? e : new Error(String(e));
 const MAX_BUFFER = 256 * 1024 * 1024;
 const HASH_CHUNK = 500;
+/** A full sha1 or sha256 object id — the only refs an immutable, disk-cached read is safe to key on. */
+const isObjectHash = (ref) => /^[0-9a-f]{40}$|^[0-9a-f]{64}$/.test(ref);
+const GTD_CACHE_SUBDIR = "gtd-cache";
+const treeCachePath = (commonDir, hash) => join(commonDir, GTD_CACHE_SUBDIR, "trees", hash);
+const blobCachePath = (commonDir, id) => join(commonDir, GTD_CACHE_SUBDIR, "blobs", id);
+const readTextCache = (path) => {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return;
+	}
+};
+/**
+* Atomic write: a temp name in the SAME directory, `rename`d into place —
+* rename is atomic on POSIX, so a concurrent reader sees either the old file
+* or the whole new one, never a half-written one. Any failure (full disk, a
+* read-only git directory, a raced directory removal) is swallowed: the
+* cache is a best-effort speedup, never a correctness dependency, and the
+* alternative — failing a gtd command over a cache write — is worse.
+*/
+const writeTextCacheAtomic = (path, content) => {
+	try {
+		mkdirSync(dirname(path), { recursive: true });
+		const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+		writeFileSync(tmp, content, "utf8");
+		renameSync(tmp, path);
+	} catch {}
+};
+/** A commit's `path → blob id` map, serialized as JSON. `undefined` on ANY read failure — missing, truncated, unparseable — so the caller falls back to asking git. */
+const readTreeCache = (commonDir, hash) => {
+	const raw = readTextCache(treeCachePath(commonDir, hash));
+	if (raw === void 0) return void 0;
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+		const map = /* @__PURE__ */ new Map();
+		for (const [path, id] of Object.entries(parsed)) {
+			if (typeof id !== "string") return void 0;
+			map.set(path, id);
+		}
+		return map;
+	} catch {
+		return;
+	}
+};
+const writeTreeCache = (commonDir, hash, tree) => writeTextCacheAtomic(treeCachePath(commonDir, hash), JSON.stringify(Object.fromEntries(tree)));
+/** Parses a `:`-prefixed raw-diff header token into its status letter and new blob id. */
+const parseRawDiffHeader = (header) => {
+	const fields = header.slice(1).split(" ").filter((f) => f.length > 0);
+	const status = fields[4] ?? "";
+	const newId = fields[3] ?? "";
+	return {
+		letter: status[0] ?? "",
+		newId
+	};
+};
+/**
+* Consumes the 1 (or, for rename/copy, 2) NUL-separated path tokens that
+* follow a raw-diff header, starting at `tokens[i]`. Returns the resulting
+* entry (`undefined` if a path token is missing) and the next index.
+*/
+const consumeRawDiffPaths = (tokens, i, letter, newId) => {
+	if (letter === "R" || letter === "C") {
+		const oldPath = tokens[i];
+		const path = tokens[i + 1];
+		return {
+			entry: oldPath !== void 0 && path !== void 0 ? {
+				status: letter,
+				oldPath,
+				path,
+				newId
+			} : void 0,
+			next: i + 2
+		};
+	}
+	const path = tokens[i];
+	return {
+		entry: path !== void 0 ? {
+			status: letter,
+			path,
+			newId
+		} : void 0,
+		next: i + 1
+	};
+};
+/** Parses the NUL-separated body of ONE commit's `--raw -z` diff (the format string's own separator already stripped). */
+const parseRawDiff = (body) => {
+	const tokens = body.split("\0").filter((t) => t.length > 0);
+	const entries = [];
+	let i = 0;
+	while (i < tokens.length) {
+		const header = tokens[i];
+		i += 1;
+		if (!header.startsWith(":")) continue;
+		const { letter, newId } = parseRawDiffHeader(header);
+		const { entry, next } = consumeRawDiffPaths(tokens, i, letter, newId);
+		i = next;
+		if (entry !== void 0) entries.push(entry);
+	}
+	return entries;
+};
+/** Applies one commit's raw-diff entries to a (mutable, working-copy) tree map. */
+const applyRawDiff = (tree, entries) => {
+	for (const entry of entries) if (entry.status === "D") tree.delete(entry.path);
+	else {
+		if (entry.status === "R") tree.delete(entry.oldPath);
+		tree.set(entry.path, entry.newId);
+	}
+};
+/** `git ls-tree -r -z --full-tree <ref>`'s output, parsed into `path → blob id`. */
+const parseLsTree = (out) => {
+	const entries = /* @__PURE__ */ new Map();
+	for (const record of out.split("\0")) {
+		const tab = record.indexOf("	");
+		if (tab === -1) continue;
+		const id = record.slice(0, tab).split(" ")[2];
+		if (id !== void 0) entries.set(record.slice(tab + 1), id);
+	}
+	return entries;
+};
+/**
+* Runs `git ls-tree` for `ref` and reports whether it actually succeeded —
+* `ok: false` on ANY subprocess failure (a transient `EAGAIN`/`ENOMEM` on
+* fork, a `git gc` race, a signal), never folded into an empty tree here.
+* The disk/memo cache must only ever hold a git-CONFIRMED tree: an immutable
+* key can serve a wrong answer forever if what's stored under it came from a
+* failed read rather than from the key itself, so callers that cache must
+* check `ok` before doing so.
+*/
+const fetchTree = (root, ref) => {
+	try {
+		return {
+			ok: true,
+			entries: parseLsTree(execFileSync("git", [
+				"ls-tree",
+				"-r",
+				"-z",
+				"--full-tree",
+				ref
+			], {
+				cwd: root,
+				encoding: "utf8",
+				maxBuffer: MAX_BUFFER
+			}))
+		};
+	} catch {
+		return {
+			ok: false,
+			entries: /* @__PURE__ */ new Map()
+		};
+	}
+};
 const assertRepoRelative = (path) => {
 	if (isAbsolute(path)) throw new Error(`Workspace: "${path}" is an absolute path — this member takes repo-relative paths only (use "atPath"/"writeAtPath" to read/write outside the repo)`);
 	return path;
@@ -47696,13 +47870,96 @@ const lstatOrAbsent = (path) => {
 		throw e;
 	}
 };
-const makeWorkspaceOps = (root, git) => {
+/**
+* Runs `git log --raw` for `base..head` (or all of `head`'s first-parent
+* history when `base` is `undefined`) and splits the output into one
+* `RawLogEntry` per commit, validating the result against `commits` — same
+* count, same hashes, in order — since the two disagreeing means the episode
+* bounds no longer match git's own history.
+*/
+const runRawLogReplay = (root, base, head, commits) => {
+	const chunks = execFileSync("git", [
+		"log",
+		"--first-parent",
+		"--reverse",
+		"-z",
+		"--raw",
+		"-r",
+		"--no-abbrev",
+		"--format=%x01%H",
+		base !== void 0 ? `${base}..${head}` : head
+	], {
+		cwd: root,
+		encoding: "utf8",
+		maxBuffer: MAX_BUFFER
+	}).split("
").filter((c) => c.length > 0);
+	if (chunks.length !== commits.length) throw new Error(`gtd: episode reconstruction expected ${commits.length} commit(s) from git log, got ${chunks.length} — the episode bounds disagree with git's own history`);
+	return chunks.map((chunk, i) => {
+		const nul = chunk.indexOf("\0");
+		const hash = nul === -1 ? chunk : chunk.slice(0, nul);
+		if (hash !== commits[i]) throw new Error(`gtd: episode reconstruction hash mismatch at position ${i}: expected ${commits[i]}, got ${hash}`);
+		const tail = nul === -1 ? "" : chunk.slice(nul + 1);
+		return {
+			hash,
+			tail: tail.startsWith("\n") ? tail.slice(1) : tail
+		};
+	});
+};
+/** Applies each `RawLogEntry`'s diff in order onto `baseTree`, caching (and returning) every resulting tree. */
+const foldRawDiffs = (baseTree, replay, rememberTree) => {
+	const result = /* @__PURE__ */ new Map();
+	let current = new Map(baseTree);
+	for (const { hash, tail } of replay) {
+		const next = new Map(current);
+		applyRawDiff(next, parseRawDiff(tail));
+		current = next;
+		result.set(hash, current);
+		rememberTree(hash, current);
+	}
+	return result;
+};
+const makeWorkspaceOps = (root, git, commonDir) => {
 	const resolveAny = (path) => isAbsolute(path) ? path : join(root, path);
+	const treeMemo = /* @__PURE__ */ new Map();
+	const blobMemo = /* @__PURE__ */ new Map();
+	/** A commit's tree, from the in-process memo or the on-disk cache — no subprocess. `undefined` on a cold miss. */
+	const peekTree = (hash) => {
+		const memoHit = treeMemo.get(hash);
+		if (memoHit !== void 0) return memoHit;
+		if (commonDir === void 0) return void 0;
+		const cached = readTreeCache(commonDir, hash);
+		if (cached !== void 0) treeMemo.set(hash, cached);
+		return cached;
+	};
+	const rememberTree = (hash, tree) => {
+		treeMemo.set(hash, tree);
+		if (commonDir !== void 0) writeTreeCache(commonDir, hash, tree);
+	};
 	const readSync = (path) => readFileOrAbsent(join(root, assertRepoRelative(path)));
-	const readCommittedSync = (path, ref = "HEAD") => {
-		const relPath = assertRepoRelative(path);
+	/**
+	* A blob's content, keyed on its OWN id rather than a (path, ref) pair —
+	* the same content read from two different commits costs one read, not
+	* two. `git cat-file -p` reads any object by id directly, no pathspec
+	* needed. Any failure folds to `undefined`, matching `readCommittedSync`'s
+	* own catch-all-as-absence.
+	*/
+	const readBlobSync = (id) => {
+		const memoHit = blobMemo.get(id);
+		if (memoHit !== void 0) return memoHit;
+		if (commonDir !== void 0) {
+			const cached = readTextCache(blobCachePath(commonDir, id));
+			if (cached !== void 0) {
+				blobMemo.set(id, cached);
+				return cached;
+			}
+		}
+		let content;
 		try {
-			return execFileSync("git", ["show", `${ref}:${relPath}`], {
+			content = execFileSync("git", [
+				"cat-file",
+				"-p",
+				id
+			], {
 				cwd: root,
 				encoding: "utf8",
 				maxBuffer: MAX_BUFFER
@@ -47710,33 +47967,72 @@ const makeWorkspaceOps = (root, git) => {
 		} catch {
 			return;
 		}
+		blobMemo.set(id, content);
+		if (commonDir !== void 0) writeTextCacheAtomic(blobCachePath(commonDir, id), content);
+		return content;
 	};
-	const treeSync = (ref) => {
-		const entries = /* @__PURE__ */ new Map();
-		let out;
+	const readCommittedSync = (path, ref = "HEAD") => {
+		const relPath = assertRepoRelative(path);
+		if (isObjectHash(ref)) {
+			const id = treeSync(ref).get(relPath);
+			return id === void 0 ? void 0 : readBlobSync(id);
+		}
 		try {
-			out = execFileSync("git", [
-				"ls-tree",
-				"-r",
-				"-z",
-				"--full-tree",
-				ref
-			], {
+			return execFileSync("git", ["show", `${ref}:${relPath}`], {
 				cwd: root,
 				encoding: "utf8",
 				maxBuffer: MAX_BUFFER
 			});
 		} catch {
-			return entries;
+			return;
 		}
-		for (const record of out.split("\0")) {
-			const tab = record.indexOf("	");
-			if (tab === -1) continue;
-			const id = record.slice(0, tab).split(" ")[2];
-			if (id !== void 0) entries.set(record.slice(tab + 1), id);
+	};
+	const readTree = (ref, onFailure) => {
+		if (isObjectHash(ref)) {
+			const cached = peekTree(ref);
+			if (cached !== void 0) return cached;
+		}
+		const { ok, entries } = fetchTree(root, ref);
+		if (!ok) {
+			if (onFailure === "throw") throw new Error(`gtd: failed to read the tree at "${ref}" — git ls-tree did not succeed`);
+			return entries;
 		}
+		if (isObjectHash(ref)) rememberTree(ref, entries);
 		return entries;
 	};
+	const treeSync = (ref) => readTree(ref, "empty");
+	/**
+	* `treeSync`'s starting point when a failed read must not silently
+	* proceed: a cache hit or a git-confirmed `ls-tree` succeeds; any
+	* subprocess failure THROWS rather than folding to an empty tree, because
+	* `episodeTrees` folds every subsequent commit's diff on top of this one —
+	* a wrong empty base would poison every commit's cached tree in the
+	* episode, not just this one's.
+	*/
+	const confirmedTree = (ref) => readTree(ref, "throw");
+	/**
+	* The delta-stream reconstruction (package 4's Requirement A): one
+	* `ls-tree` for `base`, one `--raw` `git log` for every commit, applied in
+	* order. Skipped entirely when every requested hash is already known
+	* (memo or on-disk cache) — then this issues NO subprocess at all.
+	*/
+	const episodeTrees = (base, commits) => try_({
+		try: () => {
+			const result = /* @__PURE__ */ new Map();
+			const baseTree = base !== void 0 ? confirmedTree(base) : /* @__PURE__ */ new Map();
+			if (base !== void 0) result.set(base, baseTree);
+			if (commits.length === 0) return result;
+			if (commits.every((hash) => peekTree(hash) !== void 0)) {
+				for (const hash of commits) result.set(hash, treeSync(hash));
+				return result;
+			}
+			const head = commits[commits.length - 1];
+			const replay = runRawLogReplay(root, base, head, commits);
+			for (const [hash, tree] of foldRawDiffs(baseTree, replay, rememberTree)) result.set(hash, tree);
+			return result;
+		},
+		catch: toError
+	});
 	const gitSync = (args, input) => execFileSync("git", args, {
 		cwd: root,
 		encoding: "utf8",
@@ -47795,6 +48091,7 @@ const makeWorkspaceOps = (root, git) => {
 	return {
 		treeSync,
 		worktreeSync,
+		episodeTrees,
 		readSync,
 		read: (path) => try_({
 			try: () => readSync(path),
@@ -47820,7 +48117,8 @@ var Workspace = class Workspace extends Tag("Workspace")() {
 	static Live = effect$1(Workspace, gen(function* () {
 		const { root } = yield* Host;
 		const git = yield* GitService;
-		return makeWorkspaceOps(root, git);
+		const commonDir = yield* git.gitCommonDir().pipe(catchAll(() => succeed$3(void 0)));
+		return makeWorkspaceOps(root, git, commonDir);
 	}));
 };
 //#endregion
@@ -200431,7 +200729,9 @@ const load = gen(function* () {
 		workflowVars: { ...loaded.defaults },
 		rcVars: compiled.rcVars,
 		...compiled.ui !== void 0 ? { ui: compiled.ui } : {},
-		warnings: diagnostics.filter((d) => d.severity === "warning")
+		warnings: diagnostics.filter((d) => d.severity === "warning"),
+		configFiles: levels.map((level) => level.filepath),
+		workflowFiles: loaded.dependencyFiles
 	};
 });
 const TRANSFORM_MEMO_SIZE = 512;
@@ -200480,7 +200780,7 @@ const optionalFunction = (exports, name) => {
 * Read a workflow module: the default export is the flow; `defaults`,
 * `summary`, `base` and `steering` are optional; any other export is ignored.
 */
-const fromModule = (exported, origin) => {
+const fromModule = (exported, origin, dependencyFiles) => {
 	const exports = typeof exported === "object" && exported !== null ? exported : {};
 	const flow = exports.default;
 	if (typeof flow !== "function") throw new Error("the default export is not a flow — export default an async function");
@@ -200490,11 +200790,28 @@ const fromModule = (exported, origin) => {
 		steering: stringRecord(exports, "steering"),
 		summary: optionalFunction(exports, "summary"),
 		base: optionalFunction(exports, "base"),
-		origin
+		origin,
+		dependencyFiles
 	};
 };
-/** Evaluate `gtd.config.ts`, or take the bundled default. */
-const loadWorkflow = (module) => module === void 0 ? fromModule(unified_exports, BUILT_IN_ORIGIN) : fromModule(jiti().evalModule(module.source, { filename: module.filepath }), module.filepath);
+/**
+* Evaluate `gtd.config.ts`, or take the bundled default. `cache` is jiti's
+* OWN per-call module cache (unrelated to the instance's `moduleCache:
+* false` — that governs reuse ACROSS calls, this one is populated fresh
+* DURING this one) — passing an empty object in has the side effect of
+* collecting every real file jiti resolved evaluating this module, module
+* AND every relative import it pulled in, transitively. Virtual modules
+* (`@pmelab/gtd/flows`) never touch it — no real file backs them.
+*/
+const loadWorkflow = (module) => {
+	if (module === void 0) return fromModule(unified_exports, BUILT_IN_ORIGIN, []);
+	const cache = {};
+	const exported = jiti().evalModule(module.source, {
+		filename: module.filepath,
+		cache
+	});
+	return fromModule(exported, module.filepath, Object.keys(cache));
+};
 const headTree = (workspace) => {
 	let entries;
 	const list = () => entries ??= workspace.treeSync("HEAD");
@@ -206061,8 +206378,86 @@ const runOf = (history, location, closingHash = void 0) => {
 		}
 	};
 };
-const historyUpTo = (git, head) => git.commitHistory(void 0, head);
-const computeProcessRun = (git, def, head) => map$4(historyUpTo(git, head), (history) => runOf(history, locateEpisode(def, history)));
+const PAGE_TIERS = [
+	32,
+	128,
+	512,
+	Infinity
+];
+/**
+* `locateEpisode`'s own boundary test, subject-only: a commit that isn't a
+* gtd step commit, or one landing the flow's initial state, bounds an
+* episode from below — EXCEPT a bare `gtd(human): <x>` subject (no `→`),
+* which is NEVER a boundary here, whatever `<x>` is. That bare shape is
+* `locateEpisode`'s own `opening` branch (an entered episode's first commit),
+* which takes priority there over the initial-state check no matter what the
+* entry is named — including an entry named after `def.initial` itself,
+* where the two branches would otherwise disagree. A bare human commit can
+* also be a self-loop step landing rather than a real opening (this
+* subject-only pass can't read the `Gtd-Step` trailer that would tell them
+* apart), so ruling it out here can only make `findBoundaryBase` walk a FEW
+* commits further back than strictly needed — never stop short of the
+* boundary `locateEpisode` would find once it has full commit bodies in
+* hand. That asymmetry is the only direction this approximation may err in;
+* it must never call a real boundary "not yet found".
+*/
+const subjectIsBoundary = (def, subject) => {
+	const parsed = parseCommitMessage(subject).parsed;
+	if (parsed === void 0 || !ACTORS.has(parsed.actor)) return true;
+	if (parsed.actor === "human" && parsed.from === void 0) return false;
+	return parsed.to === def.initial;
+};
+/** The last page index (walking newest→oldest, same direction as `locateEpisode`) whose subject is a boundary, or `undefined` if none in `page`. */
+const boundaryIndexIn = (def, page) => {
+	for (let i = page.length - 1; i >= 0; i--) if (subjectIsBoundary(def, page[i].subject)) return i;
+};
+/**
+* `findBoundaryBase`'s result: `base` is the hash to pass `commitHistory` so
+* a `git.commitHistory(base, head)` call reads exactly the episode ending at
+* `head`, plus whatever a subject-only read couldn't rule out — never the
+* whole repository. `base` is deliberately the boundary commit's PARENT, not
+* the boundary commit itself: `commitHistory`'s range excludes `base`, and
+* `runOf` needs the boundary commit present in the read history
+* (`episode.base`, `startParentHash`). `base: undefined` means "read from the
+* repository root" — an empty repository, an unresolvable `head`, or an
+* episode that reaches the root commit, none of which cost anything extra
+* since that IS the whole history in those cases.
+*
+* `head` is the CONCRETE hash the literal `head` argument resolved to on this
+* call's first read — `undefined` only when it never resolved (an empty
+* repository, or an unresolvable ref). The caller must hand this hash, not
+* the original `head` argument, to its own `commitHistory` call: resolving a
+* symbolic ref (literal `HEAD`, most callers' default) a second time risks
+* reading a DIFFERENT commit than this function paged through, if something
+* moves HEAD in between — pinning both reads to one resolved hash is what
+* keeps the two-read split from disagreeing with itself.
+*/
+const findBoundaryBase = (git, def, head) => gen(function* () {
+	let pinnedHead = head;
+	for (const pageSize of PAGE_TIERS) {
+		const page = yield* git.subjectHistory(pageSize, 0, pinnedHead);
+		if (pinnedHead === void 0) pinnedHead = page[page.length - 1]?.hash;
+		const wholeHistory = !Number.isFinite(pageSize) || page.length < pageSize;
+		const boundaryIdx = boundaryIndexIn(def, page);
+		if (boundaryIdx === void 0 || boundaryIdx === 0) {
+			if (wholeHistory) return {
+				base: void 0,
+				head: pinnedHead
+			};
+			continue;
+		}
+		return {
+			base: page[boundaryIdx - 1].hash,
+			head: pinnedHead
+		};
+	}
+	return {
+		base: void 0,
+		head: pinnedHead
+	};
+});
+const historyUpTo = (git, def, head) => flatMap$4(findBoundaryBase(git, def, head), ({ base, head: resolvedHead }) => git.commitHistory(base, resolvedHead));
+const computeProcessRun = (git, def, head) => map$4(historyUpTo(git, def, head), (history) => runOf(history, locateEpisode(def, history)));
 /** The run alone, never replaying — `gtd abandon` must work even when replay would refuse. */
 const currentRun = gen(function* () {
 	const git = yield* GitService;
@@ -206073,19 +206468,29 @@ const currentRun = gen(function* () {
 const summaryRun = gen(function* () {
 	const git = yield* GitService;
 	const def = (yield* (yield* ConfigService).load).workflow;
-	const history = yield* historyUpTo(git, void 0);
-	const head = history[history.length - 1];
-	if (!(head !== void 0 && parseCommitMessage(head.message).parsed?.to === def.initial)) return runOf(history, locateEpisode(def, history));
-	const before = history.slice(0, -1);
+	const headEntry = (yield* git.subjectHistory(1, 0))[0];
+	if (headEntry === void 0) {
+		const history = yield* historyUpTo(git, def, void 0);
+		return runOf(history, locateEpisode(def, history));
+	}
+	if (!(parseCommitMessage(headEntry.subject).parsed?.to === def.initial)) {
+		const history = yield* historyUpTo(git, def, headEntry.hash);
+		return runOf(history, locateEpisode(def, history));
+	}
+	const parentRef = `${headEntry.hash}~1`;
+	const before = yield* historyUpTo(git, def, parentRef);
 	const location = locateEpisode(def, before);
-	return runOf(history, { ...location }, head.hash);
+	let closing = yield* git.commitHistory(parentRef, headEntry.hash);
+	if (closing.length === 0) closing = yield* git.commitHistory(void 0, headEntry.hash);
+	return runOf([...before, ...closing], { ...location }, headEntry.hash);
 });
 const commitTree = (workspace, hash) => {
 	let entries;
 	const list = () => entries ??= workspace.treeSync(hash);
+	let sortedPaths;
 	const contents = /* @__PURE__ */ new Map();
 	return {
-		paths: () => [...list().keys()].sort(),
+		paths: () => sortedPaths ??= [...list().keys()].sort(),
 		read: (path) => {
 			if (!list().has(path)) return void 0;
 			if (!contents.has(path)) contents.set(path, workspace.readCommittedSync(path, hash));
@@ -206094,9 +206499,13 @@ const commitTree = (workspace, hash) => {
 		id: (path) => list().get(path)
 	};
 };
-/** The tree a landing would commit: the working tree, with any rewrite the landing script applies first. */
-const pendingTree = (workspace, rewrite) => {
-	const entries = workspace.worktreeSync();
+/**
+* The tree a landing would commit: the working tree, with any rewrite the
+* landing script applies first. `entries` is `setup.pendingWorktree()` —
+* already memoized — never a fresh `workspace.worktreeSync()` call; see that
+* field's own comment for why the memo lives there and not on `Workspace`.
+*/
+const pendingTree = (workspace, entries, rewrite) => {
 	const paths = [...entries.keys()];
 	const readWorktree = (path) => {
 		try {
@@ -206128,32 +206537,18 @@ const judgeBudgetBytes = (vars) => {
 	if (raw.trim() === "" || !Number.isInteger(n) || n <= 0) throw new Error(`"judgeBudgetBytes" must be a positive integer — got ${JSON.stringify(raw)} (blanking this var disables the payload bound rather than the mechanism it guards, so it is refused rather than defaulted)`);
 	return n;
 };
-const episodeCommits = (setup) => setup.run.episode.commits.map((c) => ({
-	hash: c.hash,
-	message: c.message,
-	tree: commitTree(setup.workspace, c.hash)
-}));
-const replayFor = (setup, pending) => {
-	const base = setup.run.episode.base;
-	return replay({
-		flow: setup.def.flow,
-		episode: {
-			entry: setup.run.entry,
-			base: base === void 0 ? {
-				hash: EMPTY_TREE$1,
-				tree: treeFromRecord({})
-			} : {
-				hash: base,
-				tree: commitTree(setup.workspace, base)
-			},
-			commits: episodeCommits(setup)
-		},
-		vars: setup.vars,
-		start: setup.run.diffBase,
-		budgetBytes: setup.budget,
-		...pending !== void 0 ? { pending } : {}
-	});
-};
+const replayFor = (setup, pending) => replay({
+	flow: setup.def.flow,
+	episode: {
+		entry: setup.run.entry,
+		base: setup.base,
+		commits: setup.episode
+	},
+	vars: setup.vars,
+	start: setup.run.diffBase,
+	budgetBytes: setup.budget,
+	...pending !== void 0 ? { pending } : {}
+});
 const replayError = (outcome) => {
 	if (outcome.kind === "divergence" || outcome.kind === "failed") return new Error(outcome.message);
 	if (outcome.kind === "refused") return /* @__PURE__ */ new Error(`gtd: ${outcome.message}`);
@@ -206288,15 +206683,33 @@ const restAt = (ref) => gen(function* () {
 	const def = config.workflow;
 	const run = yield* computeProcessRun(git, def, ref);
 	const vars = resolveVars(config.workflowVars, config.rcVars, run.entryVars, host.env);
+	const budget = yield* try_({
+		try: () => judgeBudgetBytes(vars),
+		catch: (e) => e instanceof Error ? e : new Error(String(e))
+	});
+	yield* workspace.episodeTrees(run.episode.base, run.episode.commits.map((c) => c.hash));
+	const base = run.episode.base === void 0 ? {
+		hash: EMPTY_TREE$1,
+		tree: treeFromRecord({})
+	} : {
+		hash: run.episode.base,
+		tree: commitTree(workspace, run.episode.base)
+	};
+	const episode = run.episode.commits.map((c) => ({
+		hash: c.hash,
+		message: c.message,
+		tree: commitTree(workspace, c.hash)
+	}));
+	let pendingMemo;
 	const setup = {
 		def,
 		run,
 		vars,
-		budget: yield* try_({
-			try: () => judgeBudgetBytes(vars),
-			catch: (e) => e instanceof Error ? e : new Error(String(e))
-		}),
-		workspace
+		budget,
+		workspace,
+		base,
+		episode,
+		pendingWorktree: () => pendingMemo ??= workspace.worktreeSync()
 	};
 	const outcome = yield* promise(() => replayFor(setup));
 	const error = replayError(outcome);
@@ -206347,7 +206760,7 @@ const entryRefusal = (rest, name, entryVars) => gen(function* () {
 			entry: name,
 			base: {
 				hash: "",
-				tree: pendingTree(workspace, void 0)
+				tree: pendingTree(workspace, rest.setup.pendingWorktree(), void 0)
 			},
 			commits: []
 		},
@@ -206411,7 +206824,7 @@ const decideLanding = (rest, verdicts) => gen(function* () {
 	const early = cleanLanding(rest);
 	if (early !== void 0) return early;
 	const outcome = yield* promise(() => replayFor(rest.setup, {
-		tree: pendingTree(rest.setup.workspace, reviewGateRewrite(rest.stepDef)),
+		tree: pendingTree(rest.setup.workspace, rest.setup.pendingWorktree(), reviewGateRewrite(rest.stepDef)),
 		...verdicts !== void 0 ? { verdicts } : {}
 	}));
 	if (outcome.kind === "refused") return {
@@ -218205,9 +218618,13 @@ const workspaceLayerForRoot = (root) => Workspace.Live.pipe(provide$1(merge(host
 const layersForRoot = (root) => mergeAll$1(gitLayerForRoot(root), ConfigService.Live, ConfigDiscovery.Live, workspaceLayerForRoot(root), hostLayerForRoot(root), Narrator.layer(() => {}, false));
 /**
 * One `ManagedRuntime` per root, memoised — caches the runtime (the
-* constructed service layer), not the config: each `LspEnv` method still
-* calls `ConfigService.load` itself, so an edited `.gtdrc` takes effect on
-* the next request; only the expensive layer construction is avoided.
+* constructed service layer), not the config: `currentSteeringFile` and a
+* `steeringMapFor` cache miss still call `ConfigService.load` fresh through
+* it. A `steeringMapFor` hit skips that load entirely, but its own memo (see
+* `makeNodeLspEnv`) is keyed on the `(path, size, mtimeMs)` of every file the
+* LAST such load reported touching, so an edit to `.gtdrc`, `gtd.config.ts`,
+* or a module `gtd.config.ts` imports still forces the next request to
+* reload — only an unrelated repeat request skips it.
 */
 const runtimeCache = /* @__PURE__ */ new Map();
 const runtimeFor = (root) => {
@@ -218237,21 +218654,75 @@ const reachedSteeringSteps = gen(function* () {
 	}));
 	return {
 		def: config.workflow,
-		steps: [...reached, ...declared]
+		steps: [...reached, ...declared],
+		dependencyFiles: [...config.configFiles, ...config.workflowFiles]
 	};
 });
+/** A cheap `(size, mtimeMs)` fingerprint of `path` — a stat, never a read. `"missing"` when it doesn't exist, so a file's creation OR deletion still changes the identity. */
+const fingerprintOf = (path) => {
+	try {
+		const stat = statSync(path);
+		return `${stat.size}:${stat.mtimeMs}`;
+	} catch {
+		return "missing";
+	}
+};
+/** `paths`' identity, sorted so the same set always reads the same regardless of build order. `known`'s fingerprint wins over a fresh `fingerprintOf` stat where it has one — see `steeringMapFor`'s miss path for why that matters. */
+const identityOf = (paths, known) => paths.map((path) => `${path}:${known?.get(path) ?? fingerprintOf(path)}`).sort().join("|");
+/**
+* Every path a `.gtdrc`/`gtd.config.ts` COULD live at for `root` — every
+* `SEARCH_PLACES` name plus `gtd.config.ts` itself, in every directory
+* `walkUp(root, home)` visits — computed from path strings alone, no
+* filesystem access. Unlike `ConfigOperations.configFiles`/`workflowFiles`
+* (which name only what a load actually FOUND), this list is complete
+* whether or not any of it exists yet, so `identityOf` on it catches a
+* brand-new `.gtdrc` appearing where there was none, not just an edit to one
+* that already existed.
+*/
+const candidateConfigPaths = (root) => walkUp(root, liveHost.home).flatMap((dir) => [...SEARCH_PLACES.map((name) => resolve(dir, name)), resolve(dir, WORKFLOW_MODULE)]);
 /** The Node adapter: the only place `LspEnv`'s Effects/layers get built and run. `startLspServer` is its production caller; most `Lsp.test.ts` coverage exercises a fake `LspEnv` instead, but this is exported so the real wiring (real git/config/repo-files layers) gets exercised against a real temp repo too. */
-const makeNodeLspEnv = (warn) => ({
-	cwd: liveHost.root,
-	steeringMapFor: async (root) => {
-		const { def, steps } = await runtimeFor(root).runPromise(reachedSteeringSteps);
-		const { map, warnings } = buildSteeringMap(def, steps, root);
-		for (const warning of warnings) warn(warning);
-		return map;
-	},
-	gitTopLevel: (dir) => runtimeFor(dir).runPromise(flatMap$4(GitService, (git) => git.topLevel())),
-	currentSteeringFile: (root) => runtimeFor(root).runPromise(resolveSteeringFile)
-});
+const makeNodeLspEnv = (warn) => {
+	const stepsMemo = /* @__PURE__ */ new Map();
+	const headHashFor = (root) => runtimeFor(root).runPromise(flatMap$4(GitService, (git) => git.resolveRef("HEAD"))).catch(() => "no-head");
+	/** `result.dependencyFiles` beyond `candidateConfigPaths(root)` — a genuine import elsewhere (e.g. a split workflow's sibling module), never `gtd.config.ts`/`.gtdrc` themselves, which the static set already names. */
+	const dynamicOnlyPaths = (root, result) => {
+		const staticSet = new Set(candidateConfigPaths(root));
+		return result.dependencyFiles.filter((path) => !staticSet.has(path));
+	};
+	const queues = /* @__PURE__ */ new Map();
+	const serialized = (root, task) => {
+		const settled = (queues.get(root) ?? Promise.resolve()).then(task, task);
+		queues.set(root, settled.then(() => void 0, () => void 0));
+		return settled;
+	};
+	return {
+		cwd: liveHost.root,
+		steeringMapFor: (root) => serialized(root, async () => {
+			const headHash = await headHashFor(root);
+			const cached = stepsMemo.get(root);
+			if (cached !== void 0 && cached.headHash === headHash && identityOf([...candidateConfigPaths(root), ...dynamicOnlyPaths(root, cached.result)]) === cached.configIdentity) {
+				const { map, warnings } = buildSteeringMap(cached.result.def, cached.result.steps, root);
+				for (const warning of warnings) warn(warning);
+				return map;
+			}
+			const staticPaths = candidateConfigPaths(root);
+			const knownDynamic = cached !== void 0 ? dynamicOnlyPaths(root, cached.result) : [];
+			const before = new Map([...staticPaths, ...knownDynamic].map((path) => [path, fingerprintOf(path)]));
+			const result = await runtimeFor(root).runPromise(reachedSteeringSteps);
+			const configIdentity = identityOf([...staticPaths, ...dynamicOnlyPaths(root, result)], before);
+			stepsMemo.set(root, {
+				headHash,
+				configIdentity,
+				result
+			});
+			const { map, warnings } = buildSteeringMap(result.def, result.steps, root);
+			for (const warning of warnings) warn(warning);
+			return map;
+		}),
+		gitTopLevel: (dir) => runtimeFor(dir).runPromise(flatMap$4(GitService, (git) => git.topLevel())),
+		currentSteeringFile: (root) => runtimeFor(root).runPromise(resolveSteeringFile)
+	};
+};
 /**
 * Starts the `gtd lsp` server over stdio. The returned Effect resolves when
 * the client disconnects (`exit` notification), so the process exits cleanly

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "15.2.0",
+  "version": "15.2.1",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {
@@ -38,6 +38,7 @@
     "build": "tsdown --filter web && npx @tailwindcss/cli -i src/web/styles.css -o dist/web/main.css --minify && node scripts/inline-web-client.mjs && tsdown --filter gtd",
     "postbuild": "jiti scripts/generate-schema.ts && node scripts/assert-no-test-doubles.mjs",
     "watch": "tsdown --watch",
+    "bench:replay": "node scripts/bench-replay.mjs",
     "test": "turbo run format:check typecheck lint lint:sh lint:boundaries test:unit test:e2e:inmem test:e2e:live test:web analyze",
     "test:unit": "vitest run --project unit",
     "test:watch": "vitest",