@pmelab/gtd 14.0.1 → 14.1.0

package/dist/gtd.bundle.mjs

@@ -30948,15 +30948,25 @@ const scope = async (scope, fn) => {
 const read = (path) => ctx().read(path);
 /** Every path in the tree matching `pattern` (`*` stays within a segment, `**` crosses them). */
 const glob = (pattern) => ctx().glob(pattern);
+const toChanges = (list) => Object.freeze(Object.assign([...list], {
+	paths: list.map((c) => c.path),
+	get: (path) => list.find((c) => c.path === path)
+}));
 /** What the last step changed, optionally only the paths matching a glob. */
 const changes = (pattern) => {
 	const context = ctx();
 	const all = context.changes();
-	const list = pattern === void 0 ? all : all.filter((c) => context.matches(c.path, pattern));
-	return Object.freeze(Object.assign([...list], {
-		paths: list.map((c) => c.path),
-		get: (path) => list.find((c) => c.path === path)
-	}));
+	return toChanges(pattern === void 0 ? all : all.filter((c) => context.matches(c.path, pattern)));
+};
+/**
+* Every change from the tree at `hash` to the tree replay stands on — this
+* package's own range, when `hash` is captured at its first step. `hash` must
+* be the episode's base or one of its commits; anything else fails the step.
+*/
+const changesSince = (hash, pattern) => {
+	const context = ctx();
+	const all = context.changesSince(hash);
+	return toChanges(pattern === void 0 ? all : all.filter((c) => context.matches(c.path, pattern)));
 };
 /** The commit the process stands on at this point of the flow. */
 const head = () => ctx().head();
@@ -31128,6 +31138,7 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	agent: () => agent,
 	answered: () => answered,
 	changes: () => changes,
+	changesSince: () => changesSince,
 	check: () => check,
 	checkScript: () => checkScript,
 	codeChanges: () => codeChanges,
@@ -45412,6 +45423,7 @@ const replay = async (input) => {
 		...c,
 		parsed: parseCommitMessage(c.message)
 	}));
+	const treeAt = (hash) => hash === input.episode.base.hash ? input.episode.base.tree : commits.find((c) => c.hash === hash)?.tree;
 	let cursor = 0;
 	let pendingUsed = false;
 	let position = input.episode.base;
@@ -45616,6 +45628,11 @@ const replay = async (input) => {
 		read: (path) => position.tree.read(path),
 		glob: (pattern) => position.tree.paths().filter((path) => globMatches(path, pattern)),
 		changes: () => changesBetween(previousPosition.tree, position.tree),
+		changesSince: (hash) => {
+			const tree = treeAt(hash);
+			if (tree === void 0) throw new Error(`gtd: changesSince(${hash}): ${hash} is not the episode base or one of its commits — pass a hash this run read from head() or start(), not one captured earlier, read from state, or from another branch`);
+			return changesBetween(tree, position.tree);
+		},
 		matches: globMatches,
 		sections: (text) => headingSections(text),
 		sectionBodies: (text) => headingSectionBodies(text),
@@ -46638,29 +46655,286 @@ const gate = (name, message) => scope(name, async () => {
 	});
 });
 //#endregion
+//#region src/workflows/diff.ts
+const CONTEXT = 3;
+const TOO_LARGE_LINES = 1500;
+const LOCKFILES = /* @__PURE__ */ new Set([
+	"package-lock.json",
+	"npm-shrinkwrap.json",
+	"yarn.lock",
+	"pnpm-lock.yaml",
+	"bun.lock",
+	"bun.lockb",
+	"Cargo.lock",
+	"composer.lock",
+	"Gemfile.lock",
+	"poetry.lock",
+	"uv.lock",
+	"Pipfile.lock",
+	"go.sum",
+	"flake.lock",
+	"mix.lock",
+	"pubspec.lock",
+	"Podfile.lock",
+	"gradle.lockfile"
+]);
+const GENERATED_GLOBS = [
+	"dist/**",
+	"build/**",
+	"out/**",
+	"coverage/**",
+	"node_modules/**",
+	"vendor/**",
+	".turbo/**",
+	"**/__snapshots__/**",
+	"**/*.snap",
+	"**/*.min.js",
+	"**/*.min.css",
+	"**/*.map"
+];
+const BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"ico",
+	"pdf",
+	"zip",
+	"gz",
+	"tar",
+	"woff",
+	"woff2",
+	"ttf",
+	"otf",
+	"mp4",
+	"wasm",
+	"bin",
+	"exe",
+	"so",
+	"dylib"
+]);
+const globCache = /* @__PURE__ */ new Map();
+const compileGlob = (glob) => {
+	let pattern = "^";
+	let i = 0;
+	while (i < glob.length) {
+		const char = glob[i];
+		if (char !== "*") {
+			pattern += char.replace(/[.+^${}()|[\]\\?]/g, "\\$&");
+			i += 1;
+		} else if (glob[i + 1] !== "*") {
+			pattern += "[^/]*";
+			i += 1;
+		} else if (glob[i + 2] === "/") {
+			pattern += "(?:.*/)?";
+			i += 3;
+		} else {
+			pattern += ".*";
+			i += 2;
+		}
+	}
+	return new RegExp(`${pattern}$`);
+};
+const matchesGlob = (path, glob) => {
+	let regex = globCache.get(glob);
+	if (regex === void 0) {
+		regex = compileGlob(glob);
+		globCache.set(glob, regex);
+	}
+	return regex.test(path);
+};
+const extensionOf = (path) => {
+	const base = path.split("/").pop() ?? path;
+	const dot = base.lastIndexOf(".");
+	return dot === -1 ? "" : base.slice(dot + 1).toLowerCase();
+};
+const isBinary = (change) => BINARY_EXTENSIONS.has(extensionOf(change.path)) || (change.before?.includes("\0") ?? false) || (change.after?.includes("\0") ?? false);
+const isExcluded = (change) => change.path === ".gtd" || change.path.startsWith(".gtd/") || LOCKFILES.has(change.path.split("/").pop() ?? change.path) || GENERATED_GLOBS.some((glob) => matchesGlob(change.path, glob)) || isBinary(change);
+/** `changes` with lockfiles, generated trees and binaries dropped. */
+const filterChanges = (changes) => changes.filter((change) => !isExcluded(change));
+const linesOf = (content) => {
+	if (content === void 0 || content === "") return [];
+	const lines = content.split("\n");
+	if (lines[lines.length - 1] === "") lines.pop();
+	return lines;
+};
+/** `dp[i][j]` = the LCS length of `a[i:]` and `b[j:]`. */
+const lcsTable = (a, b) => {
+	const n = a.length;
+	const m = b.length;
+	const dp = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }).fill(0));
+	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+	return dp;
+};
+/** Walk an LCS table into an edit script, favoring a deletion on a tie. */
+const backtrack = (a, b, dp) => {
+	const ops = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) if (a[i] === b[j]) {
+		ops.push({
+			type: "eq",
+			line: a[i]
+		});
+		i++;
+		j++;
+	} else if (dp[i + 1][j] >= dp[i][j + 1]) {
+		ops.push({
+			type: "del",
+			line: a[i]
+		});
+		i++;
+	} else {
+		ops.push({
+			type: "add",
+			line: b[j]
+		});
+		j++;
+	}
+	while (i < a.length) ops.push({
+		type: "del",
+		line: a[i++]
+	});
+	while (j < b.length) ops.push({
+		type: "add",
+		line: b[j++]
+	});
+	return ops;
+};
+/** Longest-common-subsequence edit script between two (already trimmed) line arrays. */
+const lcsOps = (a, b) => backtrack(a, b, lcsTable(a, b));
+const commonAffixes = (before, after) => {
+	const maxPrefix = Math.min(before.length, after.length);
+	let prefix = 0;
+	while (prefix < maxPrefix && before[prefix] === after[prefix]) prefix++;
+	const maxSuffix = maxPrefix - prefix;
+	let suffix = 0;
+	while (suffix < maxSuffix && before[before.length - 1 - suffix] === after[after.length - 1 - suffix]) suffix++;
+	return {
+		prefix,
+		suffix
+	};
+};
+const buildHunks = (ops) => {
+	const beforeLineAt = [];
+	const afterLineAt = [];
+	let bl = 1;
+	let al = 1;
+	for (const op of ops) {
+		beforeLineAt.push(bl);
+		afterLineAt.push(al);
+		if (op.type !== "add") bl++;
+		if (op.type !== "del") al++;
+	}
+	const ranges = [];
+	ops.forEach((op, idx) => {
+		if (op.type === "eq") return;
+		const start = Math.max(0, idx - CONTEXT);
+		const end = Math.min(ops.length - 1, idx + CONTEXT);
+		const last = ranges[ranges.length - 1];
+		if (last !== void 0 && start <= last[1] + 1) last[1] = Math.max(last[1], end);
+		else ranges.push([start, end]);
+	});
+	return ranges.map(([start, end]) => {
+		const slice = ops.slice(start, end + 1);
+		return {
+			beforeStart: beforeLineAt[start],
+			beforeCount: slice.filter((op) => op.type !== "add").length,
+			afterStart: afterLineAt[start],
+			afterCount: slice.filter((op) => op.type !== "del").length,
+			lines: slice.map((op) => `${op.type === "add" ? "+" : op.type === "del" ? "-" : " "}${op.line}`)
+		};
+	});
+};
+const renderHunk = (hunk) => [`@@ -${hunk.beforeStart},${hunk.beforeCount} +${hunk.afterStart},${hunk.afterCount} @@`, ...hunk.lines];
+/** One file's unified diff, or a summary line when its changed region is too large to inline. */
+const renderFileDiff = (change) => {
+	const before = linesOf(change.before);
+	const after = linesOf(change.after);
+	const { prefix, suffix } = commonAffixes(before, after);
+	const beforeMiddle = before.slice(prefix, before.length - suffix);
+	const afterMiddle = after.slice(prefix, after.length - suffix);
+	if (beforeMiddle.length > TOO_LARGE_LINES || afterMiddle.length > TOO_LARGE_LINES) return `${change.path}: +${afterMiddle.length}/-${beforeMiddle.length} lines, too large to inline`;
+	const prefixOps = before.slice(0, prefix).map((line) => ({
+		type: "eq",
+		line
+	}));
+	const suffixOps = before.slice(before.length - suffix).map((line) => ({
+		type: "eq",
+		line
+	}));
+	const ops = [
+		...prefixOps,
+		...lcsOps(beforeMiddle, afterMiddle),
+		...suffixOps
+	];
+	const beforePath = change.status === "added" ? "/dev/null" : `a/${change.path}`;
+	const afterPath = change.status === "deleted" ? "/dev/null" : `b/${change.path}`;
+	return [
+		`--- ${beforePath}`,
+		`+++ ${afterPath}`,
+		...buildHunks(ops).flatMap(renderHunk)
+	].join("\n");
+};
+const omissionTrailer = (paths) => `${paths.length} file(s) omitted for the judge's byte budget: ${paths.join(", ")}`;
+/** The byte size of keeping `files`' first `keepCount` entries plus the trailer the rest would need — the trailer counts against the cap too, not just the kept text. */
+const sizeWithTrailer = (files, keepCount) => {
+	let used = 0;
+	for (let i = 0; i < keepCount; i++) used += Buffer.byteLength(files[i].text, "utf8") + (i > 0 ? 1 : 0);
+	if (files.length - keepCount === 0) return used;
+	const trailer = omissionTrailer(files.slice(keepCount).map((f) => f.path));
+	return used + (keepCount > 0 ? 1 : 0) + Buffer.byteLength(trailer, "utf8");
+};
+/**
+* The filtered `changes`, rendered as one unified diff (files in path order)
+* and bounded to `capBytes`: over the cap, whole files are dropped from the
+* end — never bytes off a hunk — and named in a trailer line, so the
+* judge is told what it did not see rather than handed a silently short diff.
+* The trailer itself is sized against the cap along with the files it keeps,
+* so a package with many touched files can never push the total past it.
+*/
+const packageDiff = (changes, capBytes) => {
+	const files = filterChanges(changes).slice().sort((a, b) => a.path.localeCompare(b.path)).map((change) => ({
+		path: change.path,
+		text: renderFileDiff(change)
+	}));
+	let keepCount = files.length;
+	while (keepCount > 0 && sizeWithTrailer(files, keepCount) > capBytes) keepCount--;
+	const dropped = files.slice(keepCount).map((f) => f.path);
+	return [...files.slice(0, keepCount).map((f) => f.text), ...dropped.length > 0 ? [omissionTrailer(dropped)] : []].join("\n");
+};
+//#endregion
 //#region src/workflows/packages.ts
 const MAX_SECTIONS = 8;
+const DIFF_KEY = "diff";
 const sectionQuestion = (id, title) => ({
 	id,
 	primitive: "noul",
-	instructions: `Is the requirement "${title}" already fully satisfied by the code on the range from ${start()} to the working tree?`,
-	criteria: "Judge from the package markdown plus that range, read yourself. Only answer yes at a probability clearing the threshold below if genuinely confident nothing in this section is missing."
+	instructions: `Is the requirement "${title}" — the "${id}" evidence — already fully satisfied by the code in the "${DIFF_KEY}" evidence?`,
+	criteria: "Judge from the requirement text and the diff evidence alone. Only answer yes at a probability clearing the threshold below if genuinely confident nothing in this section is missing."
 });
 /**
 * Review one freshly built package against its spec: a pre-judge per
 * section, then an agent review of the sections it did not confidently
-* clear. Resolves `true` when approved.
+* clear. `since` is the commit the package's own build started from — the
+* pre-judge's evidence is a diff over exactly that range, never an earlier
+* package's commits. Resolves `true` when approved.
 */
-const specReview = async (pkg) => {
+const specReview = async (pkg, since) => {
 	const found = sectionBodies(read(pkg) ?? "");
 	const titles = found.map((section) => section.title);
 	const judged = titles.length > 0 && titles.length <= MAX_SECTIONS;
 	const evidence = {};
 	const questions = [];
-	if (judged) found.forEach(({ title, body }, i) => {
-		evidence[`section-${i + 1}`] = body;
-		questions.push(sectionQuestion(`section-${i + 1}`, title));
-	});
+	if (judged) {
+		found.forEach(({ title, body }, i) => {
+			evidence[`section-${i + 1}`] = body;
+			questions.push(sectionQuestion(`section-${i + 1}`, title));
+		});
+		const capBytes = Math.floor(numeric(vars.judgeBudgetBytes, 32768) / (found.length + 1));
+		evidence[DIFF_KEY] = packageDiff(changesSince(since), capBytes);
+	}
 	const { answers, truncated } = await judge("spec.pre", {
 		questions,
 		evidence,
@@ -46670,7 +46944,7 @@ const specReview = async (pkg) => {
 	const clearMinP = numeric(vars.specPreJudge, Infinity);
 	const failing = titles.filter((_, i) => {
 		const id = `section-${i + 1}`;
-		return !judged || truncated.includes(id) || !answered(answers[id], "yes", clearMinP);
+		return !judged || truncated.includes(id) || truncated.includes(DIFF_KEY) || !answered(answers[id], "yes", clearMinP);
 	});
 	if (titles.length > 0 && failing.length === 0) return true;
 	await reviewPackage(pkg, failing);
@@ -46680,10 +46954,11 @@ const specReview = async (pkg) => {
 };
 /** Build `pkg`, keep the suite green, review it against its spec, and close it out, which removes it. */
 const packageItem = async (pkg) => {
+	const since = head();
 	await build(pkg);
 	for (;;) {
 		await healthy(fixSuite);
-		if (await specReview(pkg)) break;
+		if (await specReview(pkg, since)) break;
 		await fixSpec(pkg);
 	}
 	await run$2("closing", removeScript([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "14.0.1",
+  "version": "14.1.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/flows/runtime.ts

@@ -125,6 +125,8 @@ export interface FlowContext {
   readonly glob: (pattern: string) => readonly string[]
   /** The last step's changes, content read on demand. */
   readonly changes: () => readonly Change[]
+  /** Every change from the tree at `hash` to the tree replay stands on. Throws when `hash` resolves to neither. */
+  readonly changesSince: (hash: string) => readonly Change[]
   readonly matches: (path: string, pattern: string) => boolean
   readonly sections: (text: string) => readonly string[]
   readonly sectionBodies: (text: string) => readonly Section[]
@@ -201,17 +203,34 @@ export const read = (path: string): string | undefined => ctx().read(path)
 /** Every path in the tree matching `pattern` (`*` stays within a segment, `**` crosses them). */
 export const glob = (pattern: string): readonly string[] => ctx().glob(pattern)
 
-/** What the last step changed, optionally only the paths matching a glob. */
-export const changes = (pattern?: string): Changes => {
-  const context = ctx()
-  const all = context.changes()
-  const list = pattern === undefined ? all : all.filter((c) => context.matches(c.path, pattern))
-  return Object.freeze(
+const toChanges = (list: readonly Change[]): Changes =>
+  Object.freeze(
     Object.assign([...list], {
       paths: list.map((c) => c.path),
       get: (path: string) => list.find((c) => c.path === path),
     }),
   )
+
+/** What the last step changed, optionally only the paths matching a glob. */
+export const changes = (pattern?: string): Changes => {
+  const context = ctx()
+  const all = context.changes()
+  return toChanges(
+    pattern === undefined ? all : all.filter((c) => context.matches(c.path, pattern)),
+  )
+}
+
+/**
+ * Every change from the tree at `hash` to the tree replay stands on — this
+ * package's own range, when `hash` is captured at its first step. `hash` must
+ * be the episode's base or one of its commits; anything else fails the step.
+ */
+export const changesSince = (hash: string, pattern?: string): Changes => {
+  const context = ctx()
+  const all = context.changesSince(hash)
+  return toChanges(
+    pattern === undefined ? all : all.filter((c) => context.matches(c.path, pattern)),
+  )
 }
 
 /** The commit the process stands on at this point of the flow. */

package/src/workflows/diff.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest"
+import type { Change } from "../flows/index.js"
+import { filterChanges, packageDiff } from "./diff.js"
+
+const change = (over: Partial<Change> & Pick<Change, "path" | "status">): Change => ({
+  before: undefined,
+  after: undefined,
+  ...over,
+})
+
+// A cap high enough that nothing is ever dropped, for cases exercising the
+// rendering pipeline rather than the byte-budget behavior itself.
+const NO_CAP = 10_000
+
+describe("packageDiff / rendering", () => {
+  it("renders a normal edit as hunks with three lines of context", () => {
+    const before = Array.from({ length: 10 }, (_, i) => `line ${i + 1}`).join("\n")
+    const after = before.replace("line 5", "line five")
+    const text = packageDiff([change({ path: "a.ts", status: "modified", before, after })], NO_CAP)
+    expect(text).toContain("--- a/a.ts")
+    expect(text).toContain("+++ b/a.ts")
+    expect(text).toContain("-line 5")
+    expect(text).toContain("+line five")
+    // three lines of context on either side of the one changed line
+    expect(text).toContain(" line 2")
+    expect(text).toContain(" line 8")
+    expect(text).not.toContain(" line 1\n")
+  })
+
+  it("degrades a 1500+ line change to its summary line", () => {
+    const before = Array.from({ length: 2000 }, (_, i) => `line ${i}`).join("\n")
+    const after = Array.from({ length: 2000 }, (_, i) => `changed ${i}`).join("\n")
+    const text = packageDiff(
+      [change({ path: "big.ts", status: "modified", before, after })],
+      NO_CAP,
+    )
+    expect(text).toBe("big.ts: +2000/-2000 lines, too large to inline")
+  })
+
+  it("renders files in path order for byte-identical output across replays", () => {
+    const a = change({ path: "z.ts", status: "added", after: "z" })
+    const b = change({ path: "a.ts", status: "added", after: "a" })
+    expect(packageDiff([a, b], NO_CAP)).toBe(packageDiff([b, a], NO_CAP))
+    expect(packageDiff([a, b], NO_CAP).indexOf("a.ts")).toBeLessThan(
+      packageDiff([a, b], NO_CAP).indexOf("z.ts"),
+    )
+  })
+})
+
+describe("filterChanges / exclusion list", () => {
+  it("excludes a lockfile change entirely", () => {
+    const c = change({ path: "package-lock.json", status: "modified", before: "a", after: "b" })
+    expect(filterChanges([c])).toEqual([])
+    expect(packageDiff([c], NO_CAP)).toBe("")
+  })
+
+  it("excludes .gtd/** paths", () => {
+    const c = change({ path: ".gtd/PLAN.md", status: "added", after: "x" })
+    expect(filterChanges([c])).toEqual([])
+  })
+
+  it("excludes a binary file by extension", () => {
+    const c = change({ path: "logo.png", status: "added", after: "binary-ish" })
+    expect(filterChanges([c])).toEqual([])
+  })
+
+  it("excludes a binary file by content, separately from extension", () => {
+    const c = change({ path: "weird.txt", status: "added", after: "abc\0def" })
+    expect(filterChanges([c])).toEqual([])
+  })
+
+  it("keeps an ordinary source file", () => {
+    const c = change({ path: "src/a.ts", status: "added", after: "export const a = 1\n" })
+    expect(filterChanges([c])).toEqual([c])
+  })
+})
+
+describe("packageDiff", () => {
+  it("drops whole files from the end and names them in a trailer", () => {
+    const a = change({ path: "a.ts", status: "added", after: "export const a = 1\n" })
+    const b = change({
+      path: "b.ts",
+      status: "added",
+      after: Array.from({ length: 50 }, (_, i) => `line ${i}`).join("\n"),
+    })
+    const text = packageDiff([a, b], 120)
+    expect(text).toContain("--- /dev/null")
+    expect(text).toContain("+++ b/a.ts")
+    expect(text).not.toContain("b.ts\n")
+    expect(text).toContain("1 file(s) omitted for the judge's byte budget: b.ts")
+  })
+
+  it("counts the omission trailer itself against the cap, so many dropped paths never push the total past it", () => {
+    const kept = change({ path: "a.ts", status: "added", after: "export const a = 1\n" })
+    const rest = Array.from({ length: 6 }, (_, i) =>
+      change({ path: `f${i}.ts`, status: "added", after: "y" }),
+    )
+    // A naive cap check (size the kept text alone, append the trailer
+    // afterwards) would keep a.ts plus two of the small files here — 150
+    // bytes of text — then tack on an unbudgeted trailer for the other four,
+    // landing well past capBytes. Budgeting the trailer itself must instead
+    // drop enough files that the total, trailer included, stays at or under it.
+    const capBytes = 150
+    const text = packageDiff([kept, ...rest], capBytes)
+    expect(Buffer.byteLength(text, "utf8")).toBeLessThanOrEqual(capBytes)
+    expect(text).toContain("omitted")
+  })
+
+  it("keeps every file when the cap is not exceeded", () => {
+    const a = change({ path: "a.ts", status: "added", after: "x" })
+    const text = packageDiff([a], 10_000)
+    expect(text).not.toContain("omitted")
+    expect(text).toContain("a.ts")
+  })
+})

package/src/workflows/diff.ts

@@ -0,0 +1,306 @@
+import type { Change } from "../flows/index.js"
+
+// Pure evidence rendering for `packages.item.spec.pre`: no step, no tree
+// access. Everything here works from the `Change` list a flow already holds.
+
+const CONTEXT = 3
+const TOO_LARGE_LINES = 1500
+
+// ── The fixed exclusion list — no configuration key ─────────────────────────
+
+const LOCKFILES = new Set([
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lock",
+  "bun.lockb",
+  "Cargo.lock",
+  "composer.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  "uv.lock",
+  "Pipfile.lock",
+  "go.sum",
+  "flake.lock",
+  "mix.lock",
+  "pubspec.lock",
+  "Podfile.lock",
+  "gradle.lockfile",
+])
+
+const GENERATED_GLOBS = [
+  "dist/**",
+  "build/**",
+  "out/**",
+  "coverage/**",
+  "node_modules/**",
+  "vendor/**",
+  ".turbo/**",
+  "**/__snapshots__/**",
+  "**/*.snap",
+  "**/*.min.js",
+  "**/*.min.css",
+  "**/*.map",
+]
+
+const BINARY_EXTENSIONS = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "ico",
+  "pdf",
+  "zip",
+  "gz",
+  "tar",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "mp4",
+  "wasm",
+  "bin",
+  "exe",
+  "so",
+  "dylib",
+])
+
+// A small, self-contained glob match — `*` stays within a segment, `**`
+// crosses them — kept local rather than reached through another boundary for
+// eighteen fixed patterns.
+const globCache = new Map<string, RegExp>()
+const compileGlob = (glob: string): RegExp => {
+  let pattern = "^"
+  let i = 0
+  while (i < glob.length) {
+    const char = glob[i]!
+    if (char !== "*") {
+      pattern += char.replace(/[.+^${}()|[\]\\?]/g, "\\$&")
+      i += 1
+    } else if (glob[i + 1] !== "*") {
+      pattern += "[^/]*"
+      i += 1
+    } else if (glob[i + 2] === "/") {
+      pattern += "(?:.*/)?"
+      i += 3
+    } else {
+      pattern += ".*"
+      i += 2
+    }
+  }
+  return new RegExp(`${pattern}$`)
+}
+const matchesGlob = (path: string, glob: string): boolean => {
+  let regex = globCache.get(glob)
+  if (regex === undefined) {
+    regex = compileGlob(glob)
+    globCache.set(glob, regex)
+  }
+  return regex.test(path)
+}
+
+const extensionOf = (path: string): string => {
+  const base = path.split("/").pop() ?? path
+  const dot = base.lastIndexOf(".")
+  return dot === -1 ? "" : base.slice(dot + 1).toLowerCase()
+}
+
+const isBinary = (change: Change): boolean =>
+  BINARY_EXTENSIONS.has(extensionOf(change.path)) ||
+  (change.before?.includes("\0") ?? false) ||
+  (change.after?.includes("\0") ?? false)
+
+const isExcluded = (change: Change): boolean =>
+  change.path === ".gtd" ||
+  change.path.startsWith(".gtd/") ||
+  LOCKFILES.has(change.path.split("/").pop() ?? change.path) ||
+  GENERATED_GLOBS.some((glob) => matchesGlob(change.path, glob)) ||
+  isBinary(change)
+
+/** `changes` with lockfiles, generated trees and binaries dropped. */
+export const filterChanges = (changes: readonly Change[]): readonly Change[] =>
+  changes.filter((change) => !isExcluded(change))
+
+// ── Line diff ────────────────────────────────────────────────────────────
+
+interface Op {
+  readonly type: "eq" | "add" | "del"
+  readonly line: string
+}
+
+const linesOf = (content: string | undefined): readonly string[] => {
+  if (content === undefined || content === "") return []
+  const lines = content.split("\n")
+  if (lines[lines.length - 1] === "") lines.pop()
+  return lines
+}
+
+/** `dp[i][j]` = the LCS length of `a[i:]` and `b[j:]`. */
+const lcsTable = (a: readonly string[], b: readonly string[]): number[][] => {
+  const n = a.length
+  const m = b.length
+  const dp: number[][] = Array.from({ length: n + 1 }, () =>
+    Array.from<number>({ length: m + 1 }).fill(0),
+  )
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i]![j] = a[i] === b[j] ? dp[i + 1]![j + 1]! + 1 : Math.max(dp[i + 1]![j]!, dp[i]![j + 1]!)
+    }
+  }
+  return dp
+}
+
+/** Walk an LCS table into an edit script, favoring a deletion on a tie. */
+const backtrack = (a: readonly string[], b: readonly string[], dp: number[][]): Op[] => {
+  const ops: Op[] = []
+  let i = 0
+  let j = 0
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      ops.push({ type: "eq", line: a[i]! })
+      i++
+      j++
+    } else if (dp[i + 1]![j]! >= dp[i]![j + 1]!) {
+      ops.push({ type: "del", line: a[i]! })
+      i++
+    } else {
+      ops.push({ type: "add", line: b[j]! })
+      j++
+    }
+  }
+  while (i < a.length) ops.push({ type: "del", line: a[i++]! })
+  while (j < b.length) ops.push({ type: "add", line: b[j++]! })
+  return ops
+}
+
+/** Longest-common-subsequence edit script between two (already trimmed) line arrays. */
+const lcsOps = (a: readonly string[], b: readonly string[]): Op[] => backtrack(a, b, lcsTable(a, b))
+
+const commonAffixes = (
+  before: readonly string[],
+  after: readonly string[],
+): { readonly prefix: number; readonly suffix: number } => {
+  const maxPrefix = Math.min(before.length, after.length)
+  let prefix = 0
+  while (prefix < maxPrefix && before[prefix] === after[prefix]) prefix++
+  const maxSuffix = maxPrefix - prefix
+  let suffix = 0
+  while (
+    suffix < maxSuffix &&
+    before[before.length - 1 - suffix] === after[after.length - 1 - suffix]
+  )
+    suffix++
+  return { prefix, suffix }
+}
+
+interface Hunk {
+  readonly beforeStart: number
+  readonly beforeCount: number
+  readonly afterStart: number
+  readonly afterCount: number
+  readonly lines: readonly string[]
+}
+
+const buildHunks = (ops: readonly Op[]): readonly Hunk[] => {
+  const beforeLineAt: number[] = []
+  const afterLineAt: number[] = []
+  let bl = 1
+  let al = 1
+  for (const op of ops) {
+    beforeLineAt.push(bl)
+    afterLineAt.push(al)
+    if (op.type !== "add") bl++
+    if (op.type !== "del") al++
+  }
+  const ranges: [number, number][] = []
+  ops.forEach((op, idx) => {
+    if (op.type === "eq") return
+    const start = Math.max(0, idx - CONTEXT)
+    const end = Math.min(ops.length - 1, idx + CONTEXT)
+    const last = ranges[ranges.length - 1]
+    if (last !== undefined && start <= last[1] + 1) {
+      last[1] = Math.max(last[1], end)
+    } else {
+      ranges.push([start, end])
+    }
+  })
+  return ranges.map(([start, end]) => {
+    const slice = ops.slice(start, end + 1)
+    return {
+      beforeStart: beforeLineAt[start]!,
+      beforeCount: slice.filter((op) => op.type !== "add").length,
+      afterStart: afterLineAt[start]!,
+      afterCount: slice.filter((op) => op.type !== "del").length,
+      lines: slice.map(
+        (op) => `${op.type === "add" ? "+" : op.type === "del" ? "-" : " "}${op.line}`,
+      ),
+    }
+  })
+}
+
+const renderHunk = (hunk: Hunk): readonly string[] => [
+  `@@ -${hunk.beforeStart},${hunk.beforeCount} +${hunk.afterStart},${hunk.afterCount} @@`,
+  ...hunk.lines,
+]
+
+/** One file's unified diff, or a summary line when its changed region is too large to inline. */
+const renderFileDiff = (change: Change): string => {
+  const before = linesOf(change.before)
+  const after = linesOf(change.after)
+  const { prefix, suffix } = commonAffixes(before, after)
+  const beforeMiddle = before.slice(prefix, before.length - suffix)
+  const afterMiddle = after.slice(prefix, after.length - suffix)
+  if (beforeMiddle.length > TOO_LARGE_LINES || afterMiddle.length > TOO_LARGE_LINES) {
+    return `${change.path}: +${afterMiddle.length}/-${beforeMiddle.length} lines, too large to inline`
+  }
+  const prefixOps: Op[] = before.slice(0, prefix).map((line) => ({ type: "eq", line }))
+  const suffixOps: Op[] = before.slice(before.length - suffix).map((line) => ({ type: "eq", line }))
+  const ops = [...prefixOps, ...lcsOps(beforeMiddle, afterMiddle), ...suffixOps]
+  const beforePath = change.status === "added" ? "/dev/null" : `a/${change.path}`
+  const afterPath = change.status === "deleted" ? "/dev/null" : `b/${change.path}`
+  return [`--- ${beforePath}`, `+++ ${afterPath}`, ...buildHunks(ops).flatMap(renderHunk)].join(
+    "\n",
+  )
+}
+
+const omissionTrailer = (paths: readonly string[]): string =>
+  `${paths.length} file(s) omitted for the judge's byte budget: ${paths.join(", ")}`
+
+interface RenderedFile {
+  readonly path: string
+  readonly text: string
+}
+
+/** The byte size of keeping `files`' first `keepCount` entries plus the trailer the rest would need — the trailer counts against the cap too, not just the kept text. */
+const sizeWithTrailer = (files: readonly RenderedFile[], keepCount: number): number => {
+  let used = 0
+  for (let i = 0; i < keepCount; i++) {
+    used += Buffer.byteLength(files[i]!.text, "utf8") + (i > 0 ? 1 : 0)
+  }
+  const droppedCount = files.length - keepCount
+  if (droppedCount === 0) return used
+  const trailer = omissionTrailer(files.slice(keepCount).map((f) => f.path))
+  return used + (keepCount > 0 ? 1 : 0) + Buffer.byteLength(trailer, "utf8")
+}
+
+/**
+ * The filtered `changes`, rendered as one unified diff (files in path order)
+ * and bounded to `capBytes`: over the cap, whole files are dropped from the
+ * end — never bytes off a hunk — and named in a trailer line, so the
+ * judge is told what it did not see rather than handed a silently short diff.
+ * The trailer itself is sized against the cap along with the files it keeps,
+ * so a package with many touched files can never push the total past it.
+ */
+export const packageDiff = (changes: readonly Change[], capBytes: number): string => {
+  const files = filterChanges(changes)
+    .slice()
+    .sort((a, b) => a.path.localeCompare(b.path))
+    .map((change) => ({ path: change.path, text: renderFileDiff(change) }))
+  let keepCount = files.length
+  while (keepCount > 0 && sizeWithTrailer(files, keepCount) > capBytes) keepCount--
+  const dropped = files.slice(keepCount).map((f) => f.path)
+  const kept = files.slice(0, keepCount).map((f) => f.text)
+  return [...kept, ...(dropped.length > 0 ? [omissionTrailer(dropped)] : [])].join("\n")
+}

package/src/workflows/packages.ts

@@ -1,7 +1,9 @@
 import {
   answered,
   changes,
+  changesSince,
   glob,
+  head,
   judge,
   numeric,
   read,
@@ -10,31 +12,34 @@ import {
   run,
   scope,
   sectionBodies,
-  start,
   vars,
   wrote,
   type JudgeQuestion,
 } from "../flows/index.js"
+import { packageDiff } from "./diff.js"
 import { healthy } from "./health.js"
 import { ARCHITECTURE, build, fixSpec, fixSuite, reviewPackage, SPEC_FEEDBACK } from "./steps.js"
 import * as t from "./text.js"
 
 const MAX_SECTIONS = 8
+const DIFF_KEY = "diff"
 
 const sectionQuestion = (id: string, title: string): JudgeQuestion => ({
   id,
   primitive: "noul",
-  instructions: `Is the requirement "${title}" already fully satisfied by the code on the range from ${start()} to the working tree?`,
+  instructions: `Is the requirement "${title}" — the "${id}" evidence — already fully satisfied by the code in the "${DIFF_KEY}" evidence?`,
   criteria:
-    "Judge from the package markdown plus that range, read yourself. Only answer yes at a probability clearing the threshold below if genuinely confident nothing in this section is missing.",
+    "Judge from the requirement text and the diff evidence alone. Only answer yes at a probability clearing the threshold below if genuinely confident nothing in this section is missing.",
 })
 
 /**
  * Review one freshly built package against its spec: a pre-judge per
  * section, then an agent review of the sections it did not confidently
- * clear. Resolves `true` when approved.
+ * clear. `since` is the commit the package's own build started from — the
+ * pre-judge's evidence is a diff over exactly that range, never an earlier
+ * package's commits. Resolves `true` when approved.
  */
-export const specReview = async (pkg: string): Promise<boolean> => {
+export const specReview = async (pkg: string, since: string): Promise<boolean> => {
   const found = sectionBodies(read(pkg) ?? "")
   const titles = found.map((section) => section.title)
   const judged = titles.length > 0 && titles.length <= MAX_SECTIONS
@@ -45,6 +50,10 @@ export const specReview = async (pkg: string): Promise<boolean> => {
       evidence[`section-${i + 1}`] = body
       questions.push(sectionQuestion(`section-${i + 1}`, title))
     })
+    // The diff's own even share of the budget: one key per section plus
+    // `diff` itself, so this cap equals what `budgeted` gives it below.
+    const capBytes = Math.floor(numeric(vars.judgeBudgetBytes, 32768) / (found.length + 1))
+    evidence[DIFF_KEY] = packageDiff(changesSince(since), capBytes)
   }
   const { answers, truncated } = await judge("spec.pre", {
     questions,
@@ -52,11 +61,17 @@ export const specReview = async (pkg: string): Promise<boolean> => {
     message: t.packagesItemSpecPreMessage(),
     label: "Judging spec coverage",
   })
-  // A section is cleared only by a confident yes on evidence that was not cut.
+  // A section is cleared only by a confident yes on evidence that was not
+  // cut — its own body, or the diff every question is judged against.
   const clearMinP = numeric(vars.specPreJudge, Infinity)
   const failing = titles.filter((_, i) => {
     const id = `section-${i + 1}`
-    return !judged || truncated.includes(id) || !answered(answers[id], "yes", clearMinP)
+    return (
+      !judged ||
+      truncated.includes(id) ||
+      truncated.includes(DIFF_KEY) ||
+      !answered(answers[id], "yes", clearMinP)
+    )
   })
   if (titles.length > 0 && failing.length === 0) return true
   await reviewPackage(pkg, failing)
@@ -69,10 +84,11 @@ export const specReview = async (pkg: string): Promise<boolean> => {
 
 /** Build `pkg`, keep the suite green, review it against its spec, and close it out, which removes it. */
 export const packageItem = async (pkg: string): Promise<void> => {
+  const since = head()
   await build(pkg)
   for (;;) {
     await healthy(fixSuite)
-    if (await specReview(pkg)) break
+    if (await specReview(pkg, since)) break
     await fixSpec(pkg)
   }
   // The spent technical plan goes with the first package built from it.

package/src/workflows/text.fixture.ts

@@ -22,6 +22,7 @@ export const renderText = <T>(text: () => T, context: TextContext = {}): T => {
     read: context.read ?? (() => undefined),
     glob: () => [],
     changes: () => [],
+    changesSince: unavailable,
     matches: () => false,
     sections: () => [],
     sectionBodies: () => [],