@pmelab/gtd 46.0.0 → 47.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "46.0.0",
+  "version": "47.0.0",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -504,12 +504,12 @@ noted in steps 3 and 4 below.
    unsure verdict (below `qualityTriageMinP`, `0.7`) is `design`; mechanical
    findings the fix turns leave become notes too. This lap is where code quality
    is looked at, and every round pays for it. It never replaces step 4 — your
-   review stays the final gate, and nothing here skips it. Between
-   [coarse slices](#coarse-slices) no review follows, so there the fix turn
-   fixes every finding, and those the fix cap leaves rest at
-   `build.quality-unresolved` until you delete or empty `.gtd/QUALITY.md`; the
-   suite then runs on any hand edits before the next slice. The `fix` door
-   (below) repairs a red baseline through the untriaged lap.
+   review stays the final gate, and nothing here skips it. Every
+   [coarse slice](docs/configuration.md#coarse-slices) runs the same triaged lap
+   and never rests for its findings: its notes are carried to the review after
+   the last slice, each naming its slice and lens, beside every slice's fixes.
+   The `fix` and `cleanup` doors triage their lap too, and hand its notes to
+   their own review.
 
    A red suite that keeps failing past a few fix attempts escalates instead of
    retrying forever: an agent turn reads the failing output and writes

package/dist/chunks/{reserved-BENPy6IJ.mjs → reserved-DF1HD6jL.mjs}

@@ -1,6 +1,6 @@
 import { accessFor, agent, answered, changesSince, check, codeThreads, defineWorkflow, displayPath, env, head, human, judge, mark, numeric, quote, read, refuse, scope, skillsFor, start, vars } from "../flows.mjs";
 import { d as ANSWER_FIX, f as ANSWER_LEAD, p as ANSWER_WONT_FIX, v as FREE_TEXT_PLACEHOLDER } from "./steering-D7hWeMgE.mjs";
-import { escalation as escalation$1, gate as gate$1, healthy as healthy$1, lensScopes, lensesOf, removedAssertions } from "../workflow-kit.mjs";
+import { gate as gate$1, healthy as healthy$1, lensScopes, lensesOf, removedAssertions } from "../workflow-kit.mjs";
 import { c as String$, g as standardSchemaV1, h as optionalWith, l as Struct, n as Boolean$, s as Number$ } from "./Schema-C6fLlQzx.mjs";
 //#region src/workflows/shared/registry.ts
 const FILL = "
";
@@ -544,6 +544,20 @@ const SUMMARY_TITLES = [
 ];
 const unboxed = (body) => body.replace(/^(\s*(?:>\s*)*(?:[-*+]|\d+[.)])\s+)\[[ xX]\]\s?/gm, "$1");
 const short = (hash) => hash.slice(0, 7);
+/** `slice 2, lens tests`; empty when neither is known. */
+const originOf = (f) => [...f.slice === void 0 ? [] : [`slice ${f.slice}`], ...f.lens === void 0 ? [] : [`lens ${f.lens}`]].join(", ");
+const originLine = (f) => {
+	const origin = originOf(f);
+	return origin === "" ? "" : `_From ${origin}._\n\n`;
+};
+const withOrigin = (f, rest) => [rest, originOf(f)].filter((s) => s !== "").join(", ");
+const noteBody = (n) => {
+	const body = unboxed(n.body) || "_No detail given._";
+	if (n.unresolved === true) return `_The fixer left this unresolved._\n\n${body}`;
+	if (n.unclear === true) return `_A fix turn removed this while renaming another finding — check whether it was fixed._\n\n${body}`;
+	return body;
+};
+const carriedOnly = (f) => f.slice === void 0 ? {} : f;
 /**
 * \`.gtd/REVIEW.md\` as gtd writes it: one chunk per note, each ending in its
 * answer boxes, then the fixed and noise lists. Chunk titles are made unique —
@@ -570,25 +584,14 @@ const composedReview = (base, report) => {
 		...report.nitFix === void 0 ? [] : [chunk("Fixed from your notes", `Your nits and fix-as-suggested notes were worked on in ${short(report.nitFix)}; the notes you answered are left out — check the diff.`)],
 		...weakened.length === 0 ? [] : [chunk("Weakened scenarios", `These scenarios lost an assertion the review base had:\n\n${weakened.join("\n")}`)],
 		...conflicts,
-		...notes.map((n) => chunk(n.title, `${n.unresolved === true ? `_The fixer left this unresolved._\n\n${unboxed(n.body)}` : n.unclear === true ? `_A fix turn removed this while renaming another finding — check whether it was fixed._\n\n${unboxed(n.body)}` : unboxed(n.body) || "_No detail given._"}\n\n${answerBoxes}`)),
-		...report.fixed.length === 0 ? [] : [chunk("Fixed automatically", report.fixed.map((f) => `- ${f.title} (${short(f.commit)})`).join("\n"))],
+		...notes.map((n) => chunk(n.title, `${originLine(carriedOnly(n))}${noteBody(n)}\n\n${answerBoxes}`)),
+		...report.fixed.length === 0 ? [] : [chunk("Fixed automatically", report.fixed.map((f) => fixedLine(f, carriedOnly(f))).join("\n"))],
 		...added.length === 0 ? [] : [chunk("Standards added", `Learned from your answers and kept in \`${STANDARDS}\`:\n\n${added.map((s) => `- ${s}`).join("\n")}`)],
-		...report.noise.length === 0 ? [] : [chunk("Dropped as noise", report.noise.map((f) => `- ${f.title} (p=${f.p})`).join("\n"))]
+		...report.noise.length === 0 ? [] : [chunk("Dropped as noise", report.noise.map((f) => noiseLine(f, carriedOnly(f))).join("\n"))]
 	];
 	const body = chunks.length > 0 ? chunks : [chunk("Nothing to note", "No quality lens raised anything for you — or none ran. Review the diff yourself.")];
 	return `# Review: ${short(base)}\n\n<!-- base: ${base} -->\n\n${body.join("\n\n")}\n`;
 };
-const qualityUnresolvedMessage = () => `The quality lap's fix turns hit their cap and \`.gtd/QUALITY.md\` still
-holds findings. Nothing after this fixes them, so the process will not
-go on with them open.
-
-Fix what matters by hand, then delete or empty \`.gtd/QUALITY.md\` —
-dropping a finding is your call to make.
-
-What each change does next (then run \`gtd land\`):
-- **Delete or empty \`.gtd/QUALITY.md\`** — the suite runs on your edits, then the next slice is built, or after the last one you review the change (**build.review.reviewing**).
-- **Anything else** — rests here again.
-`;
 const startGateBlockedMessage = () => `The test baseline is red — gtd will not start new work on a broken suite.
 \`.gtd/FEEDBACK.md\` holds the failing output.
 
@@ -1254,6 +1257,28 @@ const lapRange = {
 	feedback: "it starts at the previous review's boundary, so it covers only what is new since the previous review.",
 	refactor: "it covers the whole refactor since it started, on every round. A refactor may update an existing test's call sites only: give any test-file hunk its own chunk, and say so if it changes a test, an assertion or an expected value."
 };
+const fixedLine = (f, origin = f) => `- ${f.title} (${withOrigin(origin, short(f.commit))})`;
+const noiseLine = (f, origin = f) => `- ${f.title} (${withOrigin(origin, `p=${f.p}`)})`;
+/**
+* `review` with the lap's notes appended as prose chunks — no pointer, no
+* answer boxes — then what it fixed and dropped. A title the review already
+* holds gets a numbered suffix, as notes are told apart by title.
+*/
+const withLapFindings = (review, { notes, fixed, noise }) => {
+	const used = new Set(review.split("\n").filter((line) => line.startsWith("## ")).map((line) => line.slice(3).trim()));
+	const unique = (title) => {
+		let name = title;
+		for (let n = 2; used.has(name); n++) name = `${title} (${n})`;
+		used.add(name);
+		return name;
+	};
+	const chunks = [
+		...notes.map((n) => `## ${unique(n.title)}\n\n${originLine(n)}${noteBody(n)}`),
+		...fixed.length === 0 ? [] : [`## ${unique("Fixed automatically")}\n\n${fixed.map((f) => fixedLine(f)).join("\n")}`],
+		...noise.length === 0 ? [] : [`## ${unique("Dropped as noise")}\n\n${noise.map((f) => noiseLine(f)).join("\n")}`]
+	];
+	return chunks.length === 0 ? review : `${review.trimEnd()}\n\n${chunks.join("\n\n")}\n`;
+};
 const buildReviewReviewingPrompt = (base, lap, carry, removed = []) => `${styleBlock}
 
 ${styleFormatContract}
@@ -1798,12 +1823,6 @@ const guardedSteps = (guard, describeGuard, rests = true, rules) => {
 		exhausted: guarded(steps.exhausted, rests ? guard : void 0)
 	};
 };
-/**
-* Hand a red suite that repeated attempts could not fix to a person: an
-* agent writes `.gtd/ESCALATION.md`, a human narrows it. From the third round
-* on, the human is told the budget is spent instead.
-*/
-const escalation = (count, guard, guardRests = true, rules) => escalation$1(count, guardedSteps(guard, void 0, guardRests, rules));
 /** "Is this red round the same failure as the last one?" — asked of two reports, or of nothing when one is empty. */
 const retryQuestion = (comparable) => comparable ? {
 	id: "verdict",
@@ -1986,4 +2005,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { naiveApplyFailure as $, reviewMissing as A, conflictTitle as At, coverageMessage as B, requireFlag as Bt, coder as C, unwindFailure as Ct, fixQuality as D, STANDARDS as Dt, fixNits as E, testFileGlobs as Et, buildReviewTriageMessage as F, standardKey as Ft, designSystem as G, coveringPrompt as H, builderSystem as I, flagMentions as It, fixReviewNotesPrompt as J, designTriagePrompt as K, clearCriteriaMessage as L, flagReferences as Lt, reviewing as M, oneLine as Mt, agentWithSkills as N, parseStandards as Nt, fixRisks as O, conflictBody as Ot, buildReviewCollectingPrompt as P, renderStandards as Pt, implementFixPrompt as Q, clearCriteriaQuestion as R, flipProblems as Rt, awaitReview as S, unwindFailedMessage as St, fixCheck as T, envDefaults as Tt, criterionLine as U, coverageQuestion as V, designGateAnswerMessage as W, idleMessage as X, handOffAwaitReviewMessage as Y, implementBuildingPrompt as Z, REFACTOR_NOTE as _, seamByHandMessage as _t, flagModeOn as a, qualityUnresolvedMessage as at, SLICES as b, startGateBlockedMessage as bt, baseline as c, refactorFixPrompt as ct, guarded as d, reviewEditNotesCapture as dt, naivePassPrompt as et, healthy as f, reviewEditsCapture as ft, REFACTOR as g, reviewerSystem as gt, QUALITY as h, reviewNotesCapture as ht, skills as i, qualityTriageMessage as it, reviewQuality as j, isConflictTitle as jt, planner as k, conflictFor as kt, escalation as l, refactorNotePrompt as lt, HANDOFF as m, reviewGateBlockedMessage as mt, summary as n, oversizedMessage as nt, flagShipped as o, refactorBuildingPrompt as ot, FEEDBACK as p, reviewFeedbackFixPrompt as pt, finisherSystem as q, access as r, qualityFindingsFile as rt, shipped as s, refactorDroppedRefusal as st, steering as t, normaliseCriteriaScript as tt, gate as u, refactorRules as ut, REQUIREMENTS as v, seamSteerMessage as vt, collecting as w, defaults as wt, answerReviewQuestions as x, uncoveredMessage as xt, REVIEW as y, slicingPrompt as yt, composedReview as z, registryEntry as zt };
+export { naivePassPrompt as $, reviewQuality as A, isConflictTitle as At, coverageQuestion as B, collecting as C, defaults as Ct, fixRisks as D, conflictBody as Dt, fixQuality as E, STANDARDS as Et, builderSystem as F, flagMentions as Ft, designTriagePrompt as G, criterionLine as H, clearCriteriaMessage as I, flagReferences as It, handOffAwaitReviewMessage as J, finisherSystem as K, clearCriteriaQuestion as L, flipProblems as Lt, agentWithSkills as M, parseStandards as Mt, buildReviewCollectingPrompt as N, renderStandards as Nt, planner as O, conflictFor as Ot, buildReviewTriageMessage as P, standardKey as Pt, naiveApplyFailure as Q, composedReview as R, registryEntry as Rt, coder as S, withLapFindings as St, fixNits as T, testFileGlobs as Tt, designGateAnswerMessage as U, coveringPrompt as V, designSystem as W, implementBuildingPrompt as X, idleMessage as Y, implementFixPrompt as Z, REQUIREMENTS as _, slicingPrompt as _t, flagModeOn as a, refactorDroppedRefusal as at, answerReviewQuestions as b, unwindFailedMessage as bt, baseline as c, refactorRules as ct, healthy as d, reviewFeedbackFixPrompt as dt, normaliseCriteriaScript as et, FEEDBACK as f, reviewGateBlockedMessage as ft, REFACTOR_NOTE as g, seamSteerMessage as gt, REFACTOR as h, seamByHandMessage as ht, skills as i, refactorBuildingPrompt as it, reviewing as j, oneLine as jt, reviewMissing as k, conflictTitle as kt, gate as l, reviewEditNotesCapture as lt, QUALITY as m, reviewerSystem as mt, summary as n, qualityFindingsFile as nt, flagShipped as o, refactorFixPrompt as ot, HANDOFF as p, reviewNotesCapture as pt, fixReviewNotesPrompt as q, access as r, qualityTriageMessage as rt, shipped as s, refactorNotePrompt as st, steering as t, oversizedMessage as tt, guarded as u, reviewEditsCapture as ut, REVIEW as v, startGateBlockedMessage as vt, fixCheck as w, envDefaults as wt, awaitReview as x, unwindFailure as xt, SLICES as y, uncoveredMessage as yt, coverageMessage as z, requireFlag as zt };

package/dist/chunks/{review-DcbgUwr7.mjs → review-Bv40kZu9.mjs}

@@ -1,7 +1,7 @@
 import { answered, changesSince, head, judge, numeric, read, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
 import { removedAssertions, review } from "../workflow-kit.mjs";
-import { A as reviewMissing, At as conflictTitle, Dt as STANDARDS, E as fixNits, F as buildReviewTriageMessage, Ft as standardKey, Mt as oneLine, Nt as parseStandards, O as fixRisks, Ot as conflictBody, Pt as renderStandards, S as awaitReview, T as fixCheck, d as guarded, dt as reviewEditNotesCapture, f as healthy, ft as reviewEditsCapture, h as QUALITY, ht as reviewNotesCapture, jt as isConflictTitle, kt as conflictFor, w as collecting, x as answerReviewQuestions, y as REVIEW, z as composedReview } from "./reserved-BENPy6IJ.mjs";
-import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-CDNMZ-2E.mjs";
+import { At as isConflictTitle, C as collecting, D as fixRisks, Dt as conflictBody, Et as STANDARDS, Mt as parseStandards, Nt as renderStandards, Ot as conflictFor, P as buildReviewTriageMessage, Pt as standardKey, R as composedReview, T as fixNits, b as answerReviewQuestions, d as healthy, jt as oneLine, k as reviewMissing, kt as conflictTitle, lt as reviewEditNotesCapture, pt as reviewNotesCapture, u as guarded, ut as reviewEditsCapture, v as REVIEW, w as fixCheck, x as awaitReview } from "./reserved-DF1HD6jL.mjs";
+import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-D89fU_wf.mjs";
 //#region src/workflows/shared/learn.ts
 const SUMMARY_MAX = 200;
 const BANNER = /^_(?:The fixer left this unresolved\.|A fix turn removed this while renaming another finding — check whether it was fixed\.|No detail given\.)_\s*/;
@@ -276,7 +276,7 @@ const triage = (severities) => async (notes) => {
 const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
 /**
 * gtd writes `.gtd/REVIEW.md` from the quality lap's `report` — no reviewer
-* turn — and removes what the fixer left in `.gtd/QUALITY.md`. A re-review
+* turn. A re-review
 * after fixed nits restores the doc as committed at `carry`, answers kept;
 * a fresh one leaves out the notes the human already answered.
 */
@@ -289,7 +289,7 @@ const composing = (base, report, carry, nitFix, answered = /* @__PURE__ */ new S
 		added: standardsAddedSince(base),
 		undecided: parseStandards(read(".gtd/STANDARDS.md") ?? "").undecided
 	}
-}), [QUALITY]) : showScript(carry, REVIEW, REVIEW), {
+})) : showScript(carry, REVIEW, REVIEW), {
 	label: "Composing the review",
 	file: REVIEW,
 	base
@@ -371,10 +371,7 @@ function buildTail(first, second, ...rest) {
 	return tail((escalations, report) => humanReview(base, escalations, {
 		...form,
 		report
-	}), {
-		...form,
-		triage: true
-	});
+	}), form);
 }
 const isOptionalBoolean = (value) => value == null || typeof value === "boolean";
 const legacyForm = (fixFirst, base, green, options) => isOptionalBoolean(fixFirst) && isOptionalBoolean(green) && isOptionalObject(options) ? [base, {

package/dist/chunks/{tail-CDNMZ-2E.mjs → tail-D89fU_wf.mjs}

@@ -1,12 +1,24 @@
 import { answered, head, judge, mark, numeric, read, refuse, removeScript, run, scope, sectionBodies, showScript, vars, writeScript } from "../flows.mjs";
-import { fixFindings, lensEntriesOf, lensOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
-import { A as reviewMissing, D as fixQuality, M as reviewing, O as fixRisks, S as awaitReview, T as fixCheck, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, it as qualityTriageMessage, j as reviewQuality, l as escalation, rt as qualityFindingsFile, y as REVIEW } from "./reserved-BENPy6IJ.mjs";
+import { lensEntriesOf, lensOf, qualityLap, reviewToHandOff } from "../workflow-kit.mjs";
+import { A as reviewQuality, D as fixRisks, E as fixQuality, J as handOffAwaitReviewMessage, St as withLapFindings, d as healthy, j as reviewing, k as reviewMissing, m as QUALITY, nt as qualityFindingsFile, rt as qualityTriageMessage, u as guarded, v as REVIEW, w as fixCheck, x as awaitReview } from "./reserved-DF1HD6jL.mjs";
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
 	notes: [],
 	fixed: [],
 	noise: []
 };
+/** `reports` as one, each finding labelled with the slice it came from, in slice order. */
+const joinReports = (reports) => {
+	const tag = (slice, fs) => fs.map((f) => ({
+		...f,
+		slice
+	}));
+	return {
+		notes: reports.flatMap((r) => tag(r.slice, r.report.notes)),
+		fixed: reports.flatMap((r) => tag(r.slice, r.report.fixed)),
+		noise: reports.flatMap((r) => tag(r.slice, r.report.noise))
+	};
+};
 const UNTITLED = "Quality findings";
 const below = (section) => section.split("\n").slice(1).join("\n").trim();
 const strayProse = (text, sections) => sections.reduce((rest, body) => rest.replace(body, "\n"), text).split("\n").filter((line) => !/^#\s/.test(line)).join("\n").trim();
@@ -86,7 +98,14 @@ const classify = async (findings) => {
 */
 const triageFindings = async (options) => {
 	const { escalations, guard, guardRests, rules } = options;
-	const findings = findingsOf(read(".gtd/QUALITY.md") ?? "");
+	const withLens = (f) => {
+		const lens = options.lensOf?.(f);
+		return lens === void 0 ? f : {
+			...f,
+			lens
+		};
+	};
+	const findings = findingsOf(read(".gtd/QUALITY.md") ?? "").map(withLens);
 	if (findings.length === 0) return NO_FINDINGS;
 	const { mechanical, noise, design } = await classify(findings);
 	const sorted = qualityFindingsFile(mechanical);
@@ -103,7 +122,10 @@ const triageFindings = async (options) => {
 			commit
 		})));
 		unclear.push(...turn.unclear);
-		open = turn.open;
+		open = turn.open.map((f) => ({
+			...mechanical.find((m) => m.title === f.title),
+			...f
+		}));
 	}
 	if (mechanical.length > 0) await healthy(() => fixCheck(rules), {
 		escalations,
@@ -131,22 +153,15 @@ const triageFindings = async (options) => {
 //#region src/workflows/shared/tail.ts
 /** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
 const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
-/**
-* One review turn per lens over the whole change, each appending every
-* finding to `.gtd/QUALITY.md`. Resolves `"findings"` when that file
-* has any.
-*/
-const qualityLap = (guard, lenses, base) => qualityLap$1(lenses ?? lensEntriesOf(vars.qualityReviews ?? ""), guarded((entry) => {
+const lensLap = (guard, lenses, base, seen) => qualityLap(lenses ?? lensEntriesOf(vars.qualityReviews ?? ""), guarded(async (entry) => {
 	const { lens, model } = lensOf(entry);
-	return reviewQuality(lens, base, model);
+	await reviewQuality(lens, base, model);
+	seen(lens, findingsOf(read(".gtd/QUALITY.md") ?? ""));
 }, guard), QUALITY);
-/** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
-const fixQualityFindings = (escalations, guard, guardRests = true, rules) => fixFindings({
-	fix: guarded(() => fixQuality(rules), guard),
-	findings: QUALITY,
-	cap: 3,
-	escalate: () => escalation(escalations, guard, guardRests, rules)
-});
+const closeQuality = async () => {
+	if (read(".gtd/QUALITY.md") === void 0) return;
+	await run("quality.closing", removeScript([QUALITY]), { label: "Clearing quality findings" });
+};
 /** `.gtd/REVIEW.md` removed at the end of a round at commit `round`. */
 const closeReview = (round) => run("review.closing", removeScript([REVIEW, REVIEW_ORIG]), {
 	label: "Closing the review",
@@ -183,7 +198,7 @@ const runTail = (finish, options) => scope("build", async () => {
 	const guardRests = options.guardRests === void 0 ? true : options.guardRests;
 	const escalations = { rounds: 0 };
 	const fix = () => fixCheck(rules);
-	const repair = async () => {
+	if (options.fixFirst) {
 		await guarded(fix, guard)();
 		await healthy(fix, {
 			fixesSoFar: 1,
@@ -192,38 +207,52 @@ const runTail = (finish, options) => scope("build", async () => {
 			guardRests,
 			rules
 		});
-	};
-	if (options.fixFirst) await repair();
-	else if (!options.green) await healthy(fix, {
+	} else if (!options.green) await healthy(fix, {
 		escalations,
 		guard,
 		guardRests,
 		rules
 	});
-	const lap = await qualityLap(guard, lenses, lensBase);
-	if (options.triage) return finish(escalations, lap === "findings" ? await triageFindings({
-		escalations,
-		guard,
-		guardRests,
-		rules
-	}) : NO_FINDINGS);
-	if (lap === "findings") if (await fixQualityFindings(escalations, guard, guardRests, rules)) await healthy(fix, {
+	const byTitle = [];
+	const lap = await lensLap(guard, lenses, lensBase, (lens, findings) => {
+		const before = byTitle.map((f) => f.title);
+		for (const { title } of findings) {
+			const at = before.indexOf(title);
+			if (at >= 0) before.splice(at, 1);
+			else byTitle.push({
+				title,
+				lens
+			});
+		}
+	});
+	const lensOf = (f) => {
+		const at = byTitle.findIndex((e) => e.title === f.title);
+		return at < 0 ? void 0 : byTitle.splice(at, 1)[0].lens;
+	};
+	const report = lap === "findings" ? await triageFindings({
 		escalations,
 		guard,
 		guardRests,
-		rules
-	});
-	else await repair();
-	return finish(escalations, NO_FINDINGS);
+		rules,
+		lensOf
+	}) : NO_FINDINGS;
+	await closeQuality();
+	return finish(escalations, report);
 });
 /**
 * The fix workflow's human review since `base`: a sign-off closes
 * `.gtd/REVIEW.md`; a note leaves it, with the reviewer's own version as
 * `REVIEW_ORIG`, for the next `fix` to read — never a re-plan.
 */
-const handOffReview = (base, escalations, guard) => reviewToHandOff(base, {
+const handOffReview = (base, escalations, guard, report = NO_FINDINGS) => reviewToHandOff(base, {
 	file: REVIEW,
-	reviewing: guarded((b, carry) => reviewing(b, carry), guard),
+	reviewing: guarded(async (b, carry) => {
+		await reviewing(b, carry);
+		const review = read(REVIEW);
+		if (review === void 0) return;
+		const full = withLapFindings(review, report);
+		if (full !== review) await run("review.carrying", writeScript(REVIEW, full), { label: "Adding the quality lap's findings" });
+	}, guard),
 	fixRisks: guarded(fixRisks, guard),
 	keepGreen: () => healthy(fixCheck, {
 		escalations,
@@ -237,10 +266,10 @@ const handOffReview = (base, escalations, guard) => reviewToHandOff(base, {
 	unparsed: "gtd land: review-doc: your edit to .gtd/REVIEW.md contains no note fix can read — restore the deleted chunk, or write the note as a line under its entry.",
 	deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note to hand to fix."
 });
-/** The tail the fix workflow runs: ends at the hand-off review since `base`. */
-const handOffTail = (fixFirst, base, guard) => tail((escalations) => handOffReview(base, escalations, guard), {
+/** The tail the fix workflow runs: ends at the hand-off review since `base`, which gets what the lap left. */
+const handOffTail = (fixFirst, base, guard) => tail((escalations, report) => handOffReview(base, escalations, guard, report), {
 	fixFirst,
 	guard
 });
 //#endregion
-export { refusePendingHandOff as a, isOptionalObject as i, closeReview as n, tail as o, handOffTail as r, NO_FINDINGS as s, REVIEW_ORIG as t };
+export { refusePendingHandOff as a, joinReports as c, isOptionalObject as i, closeReview as n, tail as o, handOffTail as r, NO_FINDINGS as s, REVIEW_ORIG as t };

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { Bt as requireFlag, C as coder, Lt as flagReferences, Tt as envDefaults, i as skills, n as summary, o as flagShipped, r as access, t as steering, wt as defaults, zt as registryEntry } from "../chunks/reserved-BENPy6IJ.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-CDNMZ-2E.mjs";
+import { Ct as defaults, It as flagReferences, Rt as registryEntry, S as coder, i as skills, n as summary, o as flagShipped, r as access, t as steering, wt as envDefaults, zt as requireFlag } from "../chunks/reserved-DF1HD6jL.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-D89fU_wf.mjs";
 //#region src/workflows/cleanup/cleanup.ts
 const removingPrompt = (name, registry) => `Clean up the release flag "${name}", which is default-on: delete its entry in ${registry}, and remove every \`GTD_FLAG_${name.toUpperCase()}\` check from the shipped sources. Keep the flag-on path; delete code only the off path reached, including tests that pin the off path.`;
 const cleanupFlow = async () => {

package/dist/workflows/feature.mjs

@@ -1,8 +1,8 @@
 import { agent, answered, applyScript, changes, changesSince, check, codeChanges, env, hasThreadFor, head, human, judge, judgeDiffShape, kept, mark, matches, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireThreadsClosed, revertScript, run, scope, slice, start, vars, wrote } from "../flows.mjs";
 import { lensEntriesOf } from "../workflow-kit.mjs";
-import { $ as naiveApplyFailure, B as coverageMessage, C as coder, Ct as unwindFailure, E as fixNits, Et as testFileGlobs, G as designSystem, H as coveringPrompt, I as builderSystem, K as designTriagePrompt, L as clearCriteriaMessage, N as agentWithSkills, P as buildReviewCollectingPrompt, Q as implementFixPrompt, R as clearCriteriaQuestion, St as unwindFailedMessage, T as fixCheck, Tt as envDefaults, U as criterionLine, V as coverageQuestion, W as designGateAnswerMessage, X as idleMessage, Z as implementBuildingPrompt, _ as REFACTOR_NOTE, _t as seamByHandMessage, a as flagModeOn, at as qualityUnresolvedMessage, b as SLICES, bt as startGateBlockedMessage, ct as refactorFixPrompt, et as naivePassPrompt, f as healthy, g as REFACTOR, gt as reviewerSystem, h as QUALITY, i as skills, k as planner, lt as refactorNotePrompt, m as HANDOFF, n as summary, nt as oversizedMessage, ot as refactorBuildingPrompt, p as FEEDBACK, r as access, s as shipped, st as refactorDroppedRefusal, t as steering, tt as normaliseCriteriaScript, u as gate, ut as refactorRules, v as REQUIREMENTS, vt as seamSteerMessage, w as collecting, wt as defaults, x as answerReviewQuestions, xt as uncoveredMessage, yt as slicingPrompt } from "../chunks/reserved-BENPy6IJ.mjs";
-import { a as refusePendingHandOff, o as tail } from "../chunks/tail-CDNMZ-2E.mjs";
-import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-DcbgUwr7.mjs";
+import { $ as naivePassPrompt, B as coverageQuestion, C as collecting, Ct as defaults, F as builderSystem, G as designTriagePrompt, H as criterionLine, I as clearCriteriaMessage, L as clearCriteriaQuestion, M as agentWithSkills, N as buildReviewCollectingPrompt, O as planner, Q as naiveApplyFailure, S as coder, T as fixNits, Tt as testFileGlobs, U as designGateAnswerMessage, V as coveringPrompt, W as designSystem, X as implementBuildingPrompt, Y as idleMessage, Z as implementFixPrompt, _ as REQUIREMENTS, _t as slicingPrompt, a as flagModeOn, at as refactorDroppedRefusal, b as answerReviewQuestions, bt as unwindFailedMessage, ct as refactorRules, d as healthy, et as normaliseCriteriaScript, f as FEEDBACK, g as REFACTOR_NOTE, gt as seamSteerMessage, h as REFACTOR, ht as seamByHandMessage, i as skills, it as refactorBuildingPrompt, l as gate, mt as reviewerSystem, n as summary, ot as refactorFixPrompt, p as HANDOFF, r as access, s as shipped, st as refactorNotePrompt, t as steering, tt as oversizedMessage, vt as startGateBlockedMessage, wt as envDefaults, xt as unwindFailure, y as SLICES, yt as uncoveredMessage, z as coverageMessage } from "../chunks/reserved-DF1HD6jL.mjs";
+import { a as refusePendingHandOff, c as joinReports, o as tail } from "../chunks/tail-D89fU_wf.mjs";
+import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-Bv40kZu9.mjs";
 import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
@@ -1103,17 +1103,20 @@ const buildFeature = async (firstBase) => {
 	const handedOut = new Set(listedIds());
 	const one = slices.length === 1;
 	const built = (i) => sliceIds(sliceCriteria(slices, i))?.length !== 0;
+	const reports = [];
 	for (const i of slices.keys()) {
 		if (!built(i)) continue;
 		const n = one ? "" : `-${i + 1}`;
 		await buildSlice(i === 0 ? firstBase : head(), {
+			number: `${i + 1}`,
 			tier,
 			criteria: sliceCriteria(slices, i),
 			refactor: `refactor${n}`,
 			feature: `feature${n}`,
 			more: () => slices.some((_, j) => j > i && built(j)),
 			reviewBase: one ? void 0 : firstBase,
-			handedOut
+			handedOut,
+			laps: reports
 		});
 	}
 };
@@ -1145,38 +1148,39 @@ const buildSlice = async (sliceBase, build) => {
 		const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path) && !carried.includes(c.path)) ? sliceBase : seam.base;
 		if (more) {
 			const guard = () => requireCriteriaFrozen(REQUIREMENTS);
-			await tail(settleQuality, {
+			const report = await tail(async (_, report) => report, {
 				green: true,
 				lensBase: base,
 				guard,
 				guardRests: false
 			});
+			build.laps.push({
+				slice: build.number,
+				report
+			});
 			return;
 		}
 		const reviewBase = build.reviewBase ?? base;
-		await featureFeedback(await reviewedTail(reviewBase, base), base, {
+		const outcome = await reviewedTail(reviewBase, base, {
+			slice: build.number,
+			laps: build.laps
+		});
+		await featureFeedback(outcome, base, {
 			closed,
 			used
 		});
 	});
 };
-const settleQuality = async () => {
-	let rested = false;
-	while ((read(".gtd/QUALITY.md") ?? "").length > 0) {
-		rested = true;
-		await human("quality-unresolved", {
-			message: qualityUnresolvedMessage(),
-			label: "Quality findings left unresolved",
-			file: QUALITY
-		});
-	}
-	if (rested) await healthy(() => fixCheck());
-};
-/** The triaged quality lap, then the human review since `base`. */
-const reviewedTail = (base, lensBase) => tail((escalations, report) => humanReview(base, escalations, { report }), {
+/** The quality lap of slice `last.slice`, then the human review since `base`, listing what earlier slices' `laps` left too. */
+const reviewedTail = (base, lensBase, last = {
+	slice: "",
+	laps: []
+}) => tail((escalations, report) => humanReview(base, escalations, { report: last.laps.length === 0 ? report : joinReports([...last.laps, {
+	slice: last.slice,
+	report
+}]) }), {
 	green: true,
-	lensBase,
-	triage: true
+	lensBase
 });
 const featureFeedback = async (first, lensBase, ids) => {
 	let outcome = first;

package/dist/workflows/fix.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, scope, start } from "../flows.mjs";
 import { g as reviewRisks, h as reviewNotes } from "../chunks/steering-D7hWeMgE.mjs";
-import { C as coder, J as fixReviewNotesPrompt, N as agentWithSkills, Tt as envDefaults, c as baseline, i as skills, n as summary, q as finisherSystem, r as access, s as shipped, t as steering, wt as defaults, y as REVIEW } from "../chunks/reserved-BENPy6IJ.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-CDNMZ-2E.mjs";
+import { Ct as defaults, K as finisherSystem, M as agentWithSkills, S as coder, c as baseline, i as skills, n as summary, q as fixReviewNotesPrompt, r as access, s as shipped, t as steering, v as REVIEW, wt as envDefaults } from "../chunks/reserved-DF1HD6jL.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-D89fU_wf.mjs";
 //#region src/workflows/fix/fix.ts
 /**
 * Fix every note a human left in a handed-off `.gtd/REVIEW.md` and every

package/dist/workflows/review.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, start } from "../flows.mjs";
-import { C as coder, N as agentWithSkills, Tt as envDefaults, i as skills, mt as reviewGateBlockedMessage, n as summary, pt as reviewFeedbackFixPrompt, q as finisherSystem, r as access, s as shipped, t as steering, u as gate, v as REQUIREMENTS, wt as defaults } from "../chunks/reserved-BENPy6IJ.mjs";
-import { a as refusePendingHandOff } from "../chunks/tail-CDNMZ-2E.mjs";
-import { i as reUnwind, t as buildTail } from "../chunks/review-DcbgUwr7.mjs";
+import { Ct as defaults, K as finisherSystem, M as agentWithSkills, S as coder, _ as REQUIREMENTS, dt as reviewFeedbackFixPrompt, ft as reviewGateBlockedMessage, i as skills, l as gate, n as summary, r as access, s as shipped, t as steering, wt as envDefaults } from "../chunks/reserved-DF1HD6jL.mjs";
+import { a as refusePendingHandOff } from "../chunks/tail-D89fU_wf.mjs";
+import { i as reUnwind, t as buildTail } from "../chunks/review-Bv40kZu9.mjs";
 //#region src/workflows/review/review.ts
 const fixFeedback = async () => {
 	await agentWithSkills("feedback.fixing", reviewFeedbackFixPrompt(), {

package/dist/workflows/rollout.mjs

@@ -1,5 +1,5 @@
 import { agent, changesSince, glob, head, mark, read, refuse, removeScript, run, scope, vars } from "../flows.mjs";
-import { Bt as requireFlag, C as coder, It as flagMentions, Rt as flipProblems, Tt as envDefaults, i as skills, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, wt as defaults } from "../chunks/reserved-BENPy6IJ.mjs";
+import { Ct as defaults, Ft as flagMentions, Lt as flipProblems, S as coder, f as FEEDBACK, i as skills, l as gate, n as summary, o as flagShipped, r as access, t as steering, wt as envDefaults, zt as requireFlag } from "../chunks/reserved-DF1HD6jL.mjs";
 //#region src/workflows/rollout/rollout.ts
 const flippingPrompt = (name, registry) => `Roll out the release flag "${name}": in ${registry}, set \`defaultOn: true\` on its entry. Change nothing else — no other entry, no other field, no other file, no comments.`;
 const suiteBlockedMessage = () => "The suite is red after the rollout. Fix it by hand — a rollout may only touch the flag's registry entry — then land.";