@pmelab/gtd 45.2.0 → 47.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "45.2.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
@@ -741,21 +741,6 @@ hand or leave it for cleanup.
 
 The delivery model these workflows implement: [Delivery model](SDLC.md).
 
-### Reviving skipped tests
-
-The opt-in `tests` workflow revisits tests nobody runs. Export `tests` from
-`@pmelab/gtd/workflows/tests` and run `gtd door tests` (or
-`gtd --workflow tests`). On a green baseline an agent sweeps the whole
-repository — every skipped test plus the `test-audit` skill's findings — into
-`.gtd/TESTS.md`, one section per test file. Each file is then rewritten in its
-own turn until nothing in it is skipped and the suite is green. A test the agent
-calls obsolete stays skipped and is proposed for deletion: the review in
-`.gtd/REVIEW.md` gives each proposal `delete it`, `keep it skipped` or
-`_your answer_`, and refuses sign-off until each holds one tick. An agent turn
-that deletes a test file is refused. Skip detection is a factory option with
-JavaScript/TypeScript and cucumber defaults; see
-[Reviving skipped tests](docs/configuration.md#reviving-skipped-tests).
-
 ## Checking a range for stray files
 
 ```sh
@@ -894,15 +879,15 @@ approvals as `approvals` (`[]` when none), and `gtd history show` prints each as
 gtd is one package, `@pmelab/gtd`, and every entrypoint shares its version and
 [SemVer promise](https://github.com/pmelab/gtd/blob/main/COMPATIBILITY.md).
 
-| Import                                                                                                                                                                                        | What it is                                                                                                                                                                                             |
-| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `@pmelab/gtd/flows`                                                                                                                                                                           | The flow API a workflow is written in: the steps (`agent`, `human`, `run`, …), `scope` and `slice` (named spans of a process), workflow factories, `defineConfig` and `FLOWS_PROTOCOL`.                |
-| `@pmelab/gtd/wire`                                                                                                                                                                            | The driver protocol: `WIRE_SCHEMA`, the exit codes and the types of every `--json` document.                                                                                                           |
-| `@pmelab/gtd/steering`                                                                                                                                                                        | The steering-file formats (`qa`, `review`) and the review-note readers.                                                                                                                                |
-| `@pmelab/gtd/workflow-kit`                                                                                                                                                                    | Policy-free building blocks to compose a workflow from: health checks, quality laps, scenario freezing, review tails.                                                                                  |
-| `@pmelab/gtd/workflows`                                                                                                                                                                       | Every shipped workflow and all its parts in one module; also resolvable as `@pmelab/gtd/workflow`.                                                                                                     |
-| `@pmelab/gtd/workflows/feature`, `@pmelab/gtd/workflows/review`, `@pmelab/gtd/workflows/fix`, `@pmelab/gtd/workflows/rollout`, `@pmelab/gtd/workflows/cleanup`, `@pmelab/gtd/workflows/tests` | One shipped workflow each: its factory as the default export, its parts, and the reserved exports (`defaults`, `envDefaults`, `summary`, `steering`, `skills`, `access`). `gtd install` imports these. |
-| `@pmelab/gtd/testkit`                                                                                                                                                                         | Runs any workflow against the real engine, in an in-memory or a real repository. Needs `vitest` and `quickpickle`, optional peer dependencies.                                                         |
+| Import                                                                                                                                                         | What it is                                                                                                                                                                                             |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `@pmelab/gtd/flows`                                                                                                                                            | The flow API a workflow is written in: the steps (`agent`, `human`, `run`, …), `scope` and `slice` (named spans of a process), workflow factories, `defineConfig` and `FLOWS_PROTOCOL`.                |
+| `@pmelab/gtd/wire`                                                                                                                                             | The driver protocol: `WIRE_SCHEMA`, the exit codes and the types of every `--json` document.                                                                                                           |
+| `@pmelab/gtd/steering`                                                                                                                                         | The steering-file formats (`qa`, `review`) and the review-note readers.                                                                                                                                |
+| `@pmelab/gtd/workflow-kit`                                                                                                                                     | Policy-free building blocks to compose a workflow from: health checks, quality laps, scenario freezing, review tails.                                                                                  |
+| `@pmelab/gtd/workflows`                                                                                                                                        | Every shipped workflow and all its parts in one module; also resolvable as `@pmelab/gtd/workflow`.                                                                                                     |
+| `@pmelab/gtd/workflows/feature`, `@pmelab/gtd/workflows/review`, `@pmelab/gtd/workflows/fix`, `@pmelab/gtd/workflows/rollout`, `@pmelab/gtd/workflows/cleanup` | One shipped workflow each: its factory as the default export, its parts, and the reserved exports (`defaults`, `envDefaults`, `summary`, `steering`, `skills`, `access`). `gtd install` imports these. |
+| `@pmelab/gtd/testkit`                                                                                                                                          | Runs any workflow against the real engine, in an in-memory or a real repository. Needs `vitest` and `quickpickle`, optional peer dependencies.                                                         |
 
 Types come from the TypeScript sources the package ships. Configs never need an
 install for any of these but `./testkit`: gtd resolves a `gtd.config.ts`'s

package/dist/chunks/{reserved-FWrjy7zo.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 = "
";
@@ -226,11 +226,6 @@ const testFileGlobs = [
 	"**/__tests__/**"
 ];
 const defaultFlagRegistry = "src/flags/index.ts";
-/** The `tests` workflow's own process settings: where it looks for skipped tests, and how a skip reads. */
-const testsDefaults = {
-	testFiles: testFileGlobs.join(", "),
-	skipPattern: "^\\s*(?:(?:describe|context|suite|it|test|specify)\\.(?:skip|todo)\\b|x(?:describe|context|it|test|specify)\\s*\\(|(?:@\\S+\\s+)*@(?:skip|ignore)(?:\\s|$))"
-};
 /** Process settings. */
 const defaults = {
 	reviewBase: "",
@@ -549,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 —
@@ -563,7 +572,7 @@ const composedReview = (base, report) => {
 		return name;
 	};
 	const chunk = (title, body) => `## ${title}\n\n${body.trim()}`;
-	const answerBoxes = ([fix, wontFix] = [ANSWER_FIX, ANSWER_WONT_FIX]) => `${ANSWER_LEAD}\n\n- [ ] ${fix}\n- [ ] ${wontFix}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`;
+	const answerBoxes = `${ANSWER_LEAD}\n\n- [ ] ${ANSWER_FIX}\n- [ ] ${ANSWER_WONT_FIX}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`;
 	const conflicts = (report.standards?.undecided ?? []).map((c) => chunk(unique(conflictTitle(c)), conflictBody(c)));
 	const added = report.standards?.added ?? [];
 	const notes = report.notes.map((n) => ({
@@ -575,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(n.answers)}`)),
-		...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.
 
@@ -1259,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}
@@ -1803,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",
@@ -1944,24 +1958,6 @@ const flagShipped = (flow, name) => defineWorkflow(standardSchemaV1(FlagOptions,
 		base: void 0
 	};
 });
-const TestsOptions = Struct({
-	...ShippedOptions.fields,
-	testFiles: setting,
-	skipPattern: setting
-});
-const testsShipped = (flow) => defineWorkflow(standardSchemaV1(TestsOptions, {
-	onExcessProperty: "error",
-	errors: "all"
-}), ({ contextLimit, ...options }) => ({
-	flow: limited(flow, contextLimit),
-	defaults: over({
-		...defaults,
-		...testsDefaults
-	}, options),
-	envDefaults: over(envDefaults, options),
-	doors: { tests: {} },
-	base: void 0
-}));
 //#endregion
 //#region src/workflows/shared/skills.ts
 const skills = (vars) => {
@@ -1977,8 +1973,6 @@ const skills = (vars) => {
 		design: ["spec-driven-development", "planning-and-task-breakdown"],
 		notes: ["incremental-implementation", "code-simplification"],
 		feedback: ["test-driven-development", "incremental-implementation"],
-		tests: ["test-audit", "test-driven-development"],
-		"tests.health": ["debugging-and-error-recovery"],
 		...build,
 		...Object.fromEntries(Object.entries(build).map(([name, list]) => [`refactor.${name}`, list])),
 		refactor: ["ponytail"],
@@ -2011,4 +2005,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { implementFixPrompt as $, planner as A, conflictBody as At, composedReview as B, flipProblems as Bt, awaitReview as C, unwindFailedMessage as Ct, fixNits as D, testFileGlobs as Dt, fixCheck as E, envDefaults as Et, buildReviewCollectingPrompt as F, parseStandards as Ft, designGateAnswerMessage as G, coverageQuestion as H, requireFlag as Ht, buildReviewTriageMessage as I, renderStandards as It, finisherSystem as J, designSystem as K, builderSystem as L, standardKey as Lt, reviewQuality as M, conflictTitle as Mt, reviewing as N, isConflictTitle as Nt, fixQuality as O, testsDefaults as Ot, agentWithSkills as P, oneLine as Pt, implementBuildingPrompt as Q, clearCriteriaMessage as R, flagMentions as Rt, answerReviewQuestions as S, uncoveredMessage as St, collecting as T, defaults as Tt, coveringPrompt as U, coverageMessage as V, registryEntry as Vt, criterionLine as W, handOffAwaitReviewMessage as X, fixReviewNotesPrompt as Y, idleMessage as Z, REFACTOR as _, reviewerSystem as _t, flagModeOn as a, qualityTriageMessage as at, REVIEW as b, slicingPrompt as bt, testsShipped as c, refactorDroppedRefusal as ct, gate as d, refactorRules as dt, naiveApplyFailure as et, guarded as f, reviewEditNotesCapture as ft, QUALITY as g, reviewNotesCapture as gt, HANDOFF as h, reviewGateBlockedMessage as ht, skills as i, qualityFindingsFile as it, reviewMissing as j, conflictFor as jt, fixRisks as k, STANDARDS as kt, baseline as l, refactorFixPrompt as lt, FEEDBACK as m, reviewFeedbackFixPrompt as mt, summary as n, normaliseCriteriaScript as nt, flagShipped as o, qualityUnresolvedMessage as ot, healthy as p, reviewEditsCapture as pt, designTriagePrompt as q, access as r, oversizedMessage as rt, shipped as s, refactorBuildingPrompt as st, steering as t, naivePassPrompt as tt, escalation as u, refactorNotePrompt as ut, REFACTOR_NOTE as v, seamByHandMessage as vt, coder as w, unwindFailure as wt, SLICES as x, startGateBlockedMessage as xt, REQUIREMENTS as y, seamSteerMessage as yt, clearCriteriaQuestion as z, flagReferences 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-Dhl4vvDe.mjs → review-Bv40kZu9.mjs}

@@ -1,7 +1,7 @@
-import { answered, changesSince, head, judge, numeric, read, removeScript, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
+import { answered, changesSince, head, judge, numeric, read, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
 import { removedAssertions, review } from "../workflow-kit.mjs";
-import { At as conflictBody, B as composedReview, C as awaitReview, D as fixNits, E as fixCheck, Ft as parseStandards, I as buildReviewTriageMessage, It as renderStandards, J as finisherSystem, Lt as standardKey, Mt as conflictTitle, Nt as isConflictTitle, P as agentWithSkills, Pt as oneLine, S as answerReviewQuestions, T as collecting, b as REVIEW, f as guarded, ft as reviewEditNotesCapture, g as QUALITY, gt as reviewNotesCapture, j as reviewMissing, jt as conflictFor, k as fixRisks, kt as STANDARDS, mt as reviewFeedbackFixPrompt, p as healthy, pt as reviewEditsCapture, w as coder, y as REQUIREMENTS } from "./reserved-FWrjy7zo.mjs";
-import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-B-Es6Hwj.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
@@ -303,7 +303,7 @@ const composing = (base, report, carry, nitFix, answered = /* @__PURE__ */ new S
 * praise dropped.
 */
 const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
-	const { guard, guardRests, fixAccess, rules, awaitMessage } = options;
+	const { guard, guardRests, fixAccess, rules } = options;
 	const feedback = options.feedback ?? {
 		file: ".gtd/REQUIREMENTS.md",
 		collecting,
@@ -328,7 +328,7 @@ const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 			guardRests,
 			rules
 		}),
-		awaitReview: (b) => awaitReview(b, awaitMessage?.(b)),
+		awaitReview,
 		reviewMissing,
 		collecting: feedback.collecting,
 		triage: triage(severities),
@@ -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, {
@@ -388,17 +385,6 @@ const callForm = (first, second, [third, fourth, ...extra]) => {
 	if (typeof second === "string") return legacyForm(first, second, third, fourth);
 	if (typeof first === "string") return currentForm(first, second, third, fourth);
 };
-/** Build the concerns a review round collected into `.gtd/REQUIREMENTS.md`, then remove it. */
-const fixFeedback = async () => {
-	await agentWithSkills("feedback.fixing", reviewFeedbackFixPrompt(), {
-		label: "Fixing your review feedback",
-		file: REQUIREMENTS,
-		model: coder(),
-		system: finisherSystem(),
-		allowEmpty: true
-	});
-	await run("feedback.closing", removeScript([REQUIREMENTS]), { label: "Closing the feedback" });
-};
 /**
 * Undo the human's review-round code edits. A path changed since the human
 * left it is not overwritten; requireRevert names it instead.
@@ -416,4 +402,4 @@ const reUnwind = async (feedback) => {
 	requireRevert(edited, base);
 };
 //#endregion
-export { reUnwind as a, isCode as i, fixFeedback as n, humanReview as r, buildTail as t };
+export { reUnwind as i, humanReview as n, isCode as r, buildTail as t };

package/dist/chunks/{tail-B-Es6Hwj.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 { C as awaitReview, E as fixCheck, M as reviewQuality, N as reviewing, O as fixQuality, X as handOffAwaitReviewMessage, at as qualityTriageMessage, b as REVIEW, f as guarded, g as QUALITY, it as qualityFindingsFile, j as reviewMissing, k as fixRisks, p as healthy, u as escalation } from "./reserved-FWrjy7zo.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/gtd.bundle.mjs

@@ -21606,11 +21606,10 @@ rather than starting the review; \`gtd-door fix\` on a GREEN suite is a no-op
 straight back to \`idle\` — the exec'd \`gtd-build\` exits immediately on it.
 \`gtd doors\` lists the doors a repository offers (those of the workflows its
 config exports — the bundled \`fix\` and \`review [base]\`, plus the opt-in
-\`rollout <flag>\` (turn a release flag default-on), \`cleanup <flag>\`
-(remove it) and \`tests\` (revive skipped tests), which a config adds by
-exporting \`rollout\` from \`@pmelab/gtd/workflows/rollout\`, \`cleanup\` from
-\`@pmelab/gtd/workflows/cleanup\` and \`tests\` from
-\`@pmelab/gtd/workflows/tests\` — plus any it declares). Refuses with
+\`rollout <flag>\` (turn a release flag default-on) and \`cleanup <flag>\`
+(remove it), which a config adds by exporting \`rollout\` from
+\`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
+\`@pmelab/gtd/workflows/cleanup\` — plus any it declares). Refuses with
 \`usage: gtd-door <name> [args...]\` on stderr and exit \`2\` when the name is
 missing — nothing was even attempted. Default path: \`~/.local/bin/gtd-door\`.
 
@@ -21723,8 +21722,7 @@ const CONFIG_SCAFFOLD = `// The workflows gtd runs here: gtd's shipped feature,
 // its own doors: \`gtd door review [base]\` and \`gtd door fix\`. Export \`rollout\`
 // from \`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
 // \`@pmelab/gtd/workflows/cleanup\` to add \`gtd door rollout <flag>\` and
-// \`gtd door cleanup <flag>\`, and \`tests\` from \`@pmelab/gtd/workflows/tests\`
-// to add \`gtd door tests\`.
+// \`gtd door cleanup <flag>\`.
 export {
   feature as default,
   feature,

package/dist/testkit.mjs

@@ -6643,11 +6643,10 @@ rather than starting the review; \`gtd-door fix\` on a GREEN suite is a no-op
 straight back to \`idle\` — the exec'd \`gtd-build\` exits immediately on it.
 \`gtd doors\` lists the doors a repository offers (those of the workflows its
 config exports — the bundled \`fix\` and \`review [base]\`, plus the opt-in
-\`rollout <flag>\` (turn a release flag default-on), \`cleanup <flag>\`
-(remove it) and \`tests\` (revive skipped tests), which a config adds by
-exporting \`rollout\` from \`@pmelab/gtd/workflows/rollout\`, \`cleanup\` from
-\`@pmelab/gtd/workflows/cleanup\` and \`tests\` from
-\`@pmelab/gtd/workflows/tests\` — plus any it declares). Refuses with
+\`rollout <flag>\` (turn a release flag default-on) and \`cleanup <flag>\`
+(remove it), which a config adds by exporting \`rollout\` from
+\`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
+\`@pmelab/gtd/workflows/cleanup\` — plus any it declares). Refuses with
 \`usage: gtd-door <name> [args...]\` on stderr and exit \`2\` when the name is
 missing — nothing was even attempted. Default path: \`~/.local/bin/gtd-door\`.
 
@@ -6760,8 +6759,7 @@ const CONFIG_SCAFFOLD = `// The workflows gtd runs here: gtd's shipped feature,
 // its own doors: \`gtd door review [base]\` and \`gtd door fix\`. Export \`rollout\`
 // from \`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
 // \`@pmelab/gtd/workflows/cleanup\` to add \`gtd door rollout <flag>\` and
-// \`gtd door cleanup <flag>\`, and \`tests\` from \`@pmelab/gtd/workflows/tests\`
-// to add \`gtd door tests\`.
+// \`gtd door cleanup <flag>\`.
 export {
   feature as default,
   feature,

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { Et as envDefaults, Ht as requireFlag, Tt as defaults, Vt as registryEntry, i as skills, n as summary, o as flagShipped, r as access, t as steering, w as coder, zt as flagReferences } from "../chunks/reserved-FWrjy7zo.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-B-Es6Hwj.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 () => {