@pmelab/gtd 46.0.0 → 48.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "46.0.0",
+  "version": "48.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

@@ -302,17 +302,19 @@ this with your environment. See
 [Driving the loop](https://github.com/pmelab/gtd/blob/main/docs/driver.md) for
 the full protocol.
 
-Or skip writing one: **`gtd loop`** is that loop, shipped with gtd. It drives
-`claude` (or `pi`) until the process rests on you, logs every turn to the file
-`gtd next --json=log` names, and maps the workflow's `smart`/`base` model hints
-to real model names through per-machine settings — see
-[`gtd loop`](https://github.com/pmelab/gtd/blob/main/docs/driver.md#the-bundled-driver-gtd-loop).
+Or skip writing one: the
+[complete minimal driver](https://github.com/pmelab/gtd/blob/main/docs/driver.md#a-complete-minimal-driver)
+is a paste to own outright. It drives `claude` until the process rests on you,
+logs every turn to the file `gtd next --json=log` names, records each turn's
+cost on its landing, answers judge gates through `gtd judge run`, and maps the
+workflow's `smart`/`base` model hints to real model names through
+`GTD_LOOP_MODEL_SMART`/`GTD_LOOP_MODEL_BASE`.
 
 Both it and the Claude Code mod stop an agent turn that outgrows its context:
 past 60% of the model's window the agent is asked to wrap up with a handoff
-note, past 70% (or when the context is about to be compacted) the turn stops and
-nothing lands. A step's `context` option, or the bundled workflows'
-`contextLimit` option, moves the two limits — see
+note, past 70% after a tool call (or when the context is about to be compacted)
+the turn stops and nothing lands. A step's `context` option, or the bundled
+workflows' `contextLimit` option, moves the two limits — see
 [Context limits](https://github.com/pmelab/gtd/blob/main/docs/driver.md#context-limits).
 In `feature`, a naive pass, refactor or build turn that wrapped up that way is a
 snapshot: a fresh turn picks up from it with the handoff note and the criteria
@@ -478,10 +480,10 @@ noted in steps 3 and 4 below.
    - After you review: is each of your notes an edit, a question, a nit or
      praise?
 
-   gtd itself never calls a judge: `gtd loop`, the Claude Code mod and the
-   reference driver answer these through `gtd judge run` (auto selection: jev
-   when `TYPESAFE_API_KEY` is set, else `llm` via `claude`, default model
-   sonnet, while the Claude Code mod's own judge subagent stays on `haiku` —
+   gtd itself never calls a judge: the Claude Code mod and the reference driver
+   answer these through `gtd judge run` (auto selection: jev when
+   `TYPESAFE_API_KEY` is set, else `llm` via `claude`, default model sonnet,
+   while the Claude Code mod's own judge subagent stays on `haiku` —
    `--model <name>` overrides); if that fails it shows you the message and
    stops. **The `llm` provider's `p` is self-reported by the model, not a
    measured probability, so a confidently wrong verdict can clear the 0.7 floor
@@ -504,12 +506,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
@@ -896,7 +898,7 @@ install for any of these but `./testkit`: gtd resolves a `gtd.config.ts`'s
 The `gtd` bin's commands — `next`, `land`, `abandon`, `restore`, `validate`,
 `check`, `uncheck`, `install`, `summary`, `base`, `door`, `doors`, `slices`,
 `version`, `help`, `history list`, `history show`, `history metrics`,
-`history judges`, `history fetch`, `strays`, and the tools `ui`, `lsp`, `loop`,
+`history judges`, `history fetch`, `strays`, and the tools `ui`, `lsp`,
 `context-hook`, `judge` (`judge answer`, `judge run`) — are listed in the
 [CLI reference](https://github.com/pmelab/gtd/blob/main/docs/cli.md).
 `gtd slices` lists the spans a flow's `slice()` calls mark. It refuses (exit 1)

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 };