@pmelab/gtd 54.0.0 → 56.0.0

package/dist/chunks/{tail-JZ9PAOwp.mjs → tail-BSLah2mA.mjs}

@@ -1,11 +1,14 @@
-import { answered, head, judge, mark, numeric, read, refuse, removeScript, run, scope, sectionBodies, showScript, vars, writeScript } from "../flows.mjs";
+import { answered, head, human, judge, mark, numeric, read, refuse, removeScript, run, scope, sectionBodies, showScript, vars, writeScript } from "../flows.mjs";
+import { F as formatFinding, p as findingEntries, r as steeringFormatFor, x as reviewRisks } from "./steering-CCNvngSH.mjs";
 import { lensEntriesOf, lensOf, qualityLap, reviewToHandOff } from "../workflow-kit.mjs";
-import { A as reviewing, C as fixCheck, E as fixRisks, K as handOffAwaitReviewMessage, O as reviewMissing, T as fixQuality, at as qualityFindingsFile, b as awaitReview, d as healthy, k as reviewQuality, kt as withLapFindings, m as QUALITY, ot as qualityTriageMessage, u as guarded, v as REVIEW } from "./reserved-CQ7amcKG.mjs";
+import { A as reviewing, C as fixCheck, E as fixRisks, Et as withSummary, H as findingGateFile, K as handOffAwaitReviewMessage, O as reviewMissing, T as fixQuality, Tt as withGuidance, U as findingGateMessage, b as awaitReview, d as healthy, k as reviewQuality, m as QUALITY, ot as qualityFindingsFile, st as qualityTriageMessage, u as guarded, v as REVIEW } from "./reserved-B8EC-WE8.mjs";
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
-	notes: [],
 	fixed: [],
-	noise: []
+	gateFixed: [],
+	dropped: [],
+	noise: [],
+	unresolved: []
 };
 const UNTITLED = "Quality findings";
 const below = (section) => section.split("\n").slice(1).join("\n").trim();
@@ -78,31 +81,18 @@ const classify = async (findings) => {
 		design: of("design")
 	};
 };
-/**
-* Judge each finding in `.gtd/QUALITY.md`, set the noise and design ones
-* aside, and fix the mechanical ones for up to `FIX_CAP` turns. Leaves
-* `.gtd/QUALITY.md` holding only what the fixer left: the caller must remove
-* it, or the next lap appends to stale findings.
-*/
-const triageFindings = async (options) => {
-	const { escalations, guard, guardRests, rules } = options;
-	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);
-	if (read(".gtd/QUALITY.md") !== sorted) await run("quality.sorting", mechanical.length === 0 ? removeScript([QUALITY]) : writeScript(QUALITY, sorted), { label: "Setting findings aside for the review" });
+const NOTHING_FIXED = {
+	fixed: [],
+	open: [],
+	unclear: []
+};
+/** Up to `FIX_CAP` fix turns over `.gtd/QUALITY.md`, which holds one chunk per finding in `findings`. */
+const fixTurns = async (findings, options) => {
 	const fixed = [];
 	const unclear = [];
-	let open = mechanical;
+	let open = findings;
 	for (let turns = 0; turns < 3 && open.length > 0; turns++) {
-		await guarded(() => fixQuality(rules), guard)();
+		await guarded(() => fixQuality(options.rules), options.guard)();
 		const turn = afterFix(open, findingsOf(read(".gtd/QUALITY.md") ?? ""));
 		const commit = head();
 		fixed.push(...turn.fixed.map((f) => ({
@@ -111,41 +101,135 @@ const triageFindings = async (options) => {
 		})));
 		unclear.push(...turn.unclear);
 		open = turn.open.map((f) => ({
-			...mechanical.find((m) => m.title === f.title),
+			...findings.find((m) => m.title === f.title),
 			...f
 		}));
 	}
-	if (mechanical.length > 0) await healthy(() => fixCheck(rules), {
+	const { escalations, guard, guardRests, rules } = options;
+	await healthy(() => fixCheck(rules), {
 		escalations,
 		guard,
 		guardRests,
 		rules
 	});
 	return {
-		notes: [
+		fixed,
+		open,
+		unclear
+	};
+};
+/** Matches each entry the human left to the finding it was written from, by title, first unused first; `left` is what no entry claimed. */
+const matcher = (findings) => {
+	const left = [...findings];
+	const of = (e) => {
+		const at = left.findIndex((f) => f.title === e.title);
+		return at < 0 ? void 0 : left.splice(at, 1)[0];
+	};
+	return {
+		of,
+		left
+	};
+};
+const gateProblems = (text) => steeringFormatFor("findings").validate(text).map((f) => `  - ${formatFinding(QUALITY, f)}`);
+/**
+* The human gate over the open notes and the noise: a ticked finding is
+* fixed — never re-planned — and the rest dropped. No notes and no noise, no gate.
+*/
+const findingGate = async (notes, noise, options) => {
+	if (notes.length + noise.length === 0) return NO_FINDINGS;
+	const written = findingGateFile(notes, noise);
+	await run("quality.gating", writeScript(QUALITY, written), { label: "Listing the findings for you" });
+	await human("quality.gate", {
+		message: findingGateMessage(),
+		label: "Deciding on the quality findings",
+		file: QUALITY,
+		mode: "findings",
+		acceptClean: true
+	});
+	const answered = read(".gtd/QUALITY.md") ?? written;
+	const problems = gateProblems(answered);
+	if (problems.length > 0) refuse(`gtd land: finding-gate: ${problems.length} problem(s) in ${QUALITY} — keep one \`- [ ] fix\` box per finding, ticked to fix it or unticked to drop it, and write guidance only under a ticked one:\n${problems.join("\n")}`);
+	const noteOf = matcher(notes);
+	const noiseOf = matcher(noise);
+	const decided = findingEntries(answered).map((e) => ({
+		e,
+		finding: (e.noise ? noiseOf.of(e) : noteOf.of(e)) ?? {
+			id: "",
+			title: e.title,
+			body: e.body
+		}
+	}));
+	const ticked = decided.filter(({ e }) => e.fix).map(({ e, finding }) => ({
+		...finding,
+		body: withGuidance(finding.body, e.guidance)
+	}));
+	let fixing = NOTHING_FIXED;
+	if (ticked.length > 0) {
+		await run("quality.picking", writeScript(QUALITY, qualityFindingsFile(ticked)), { label: "Keeping the findings you ticked" });
+		fixing = await fixTurns(ticked, options);
+	}
+	const unticked = (noisy) => decided.filter(({ e }) => !e.fix && e.noise === noisy).map(({ finding }) => finding);
+	return {
+		gateFixed: fixing.fixed,
+		dropped: [...unticked(false), ...noteOf.left],
+		noise: [...unticked(true), ...noiseOf.left],
+		unresolved: [...fixing.open, ...fixing.unclear.map((f) => ({
+			...f,
+			unclear: true
+		}))]
+	};
+};
+/**
+* Judge each finding in `.gtd/QUALITY.md` and fix the mechanical ones for up
+* to `FIX_CAP` turns; the rest — design, unresolved and noise — go to the
+* finding gate. Leaves `.gtd/QUALITY.md` holding only what the last fixer
+* left: the caller must remove it, or the next lap appends to stale findings.
+*/
+const triageFindings = async (options) => {
+	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);
+	let auto = NOTHING_FIXED;
+	if (mechanical.length > 0) {
+		const sorted = qualityFindingsFile(mechanical);
+		if (read(".gtd/QUALITY.md") !== sorted) await run("quality.sorting", writeScript(QUALITY, sorted), { label: "Setting findings aside for the finding gate" });
+		auto = await fixTurns(mechanical, options);
+	}
+	return {
+		...await findingGate([
 			...design,
-			...open.map((f) => ({
+			...auto.open.map((f) => ({
 				...f,
 				unresolved: true
 			})),
-			...unclear.map((f) => ({
+			...auto.unclear.map((f) => ({
 				...f,
 				unclear: true
 			}))
-		],
-		fixed,
-		noise
+		], noise, options),
+		fixed: auto.fixed
 	};
 };
 //#endregion
 //#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";
-const lensLap = (guard, lenses, base, seen) => qualityLap(lenses ?? lensEntriesOf(vars.qualityReviews ?? ""), guarded(async (entry) => {
-	const { lens, model } = lensOf(entry);
-	await reviewQuality(lens, base, model);
-	seen(lens, findingsOf(read(".gtd/QUALITY.md") ?? ""));
-}, guard), QUALITY);
+const COVERAGE = "criteria-coverage";
+const lensLap = (guard, lenses, base, given, seen) => {
+	const requirements = given ?? read(".gtd/REQUIREMENTS.md");
+	return qualityLap((lenses ?? lensEntriesOf(vars.qualityReviews ?? "")).filter((entry) => requirements !== void 0 || lensOf(entry).lens !== COVERAGE), guarded(async (entry) => {
+		const { lens, model } = lensOf(entry);
+		await reviewQuality(lens, base, model, lens === COVERAGE ? requirements : void 0);
+		seen(lens, findingsOf(read(".gtd/QUALITY.md") ?? ""));
+	}, guard), QUALITY);
+};
 const closeQuality = async () => {
 	if (read(".gtd/QUALITY.md") === void 0) return;
 	await run("quality.closing", removeScript([QUALITY]), { label: "Clearing quality findings" });
@@ -182,7 +266,7 @@ const tailForm = (first, second, rest) => {
 	if (typeof first === "function" && isOptionalObject(second) && rest.every((v) => v == null)) return [first, second ?? {}];
 };
 const runTail = (finish, options) => scope("build", async () => {
-	const { guard, lenses, lensBase, rules } = options;
+	const { guard, lenses, lensBase, rules, requirements } = options;
 	const guardRests = options.guardRests === void 0 ? true : options.guardRests;
 	const escalations = { rounds: 0 };
 	const fix = () => fixCheck(rules);
@@ -202,7 +286,7 @@ const runTail = (finish, options) => scope("build", async () => {
 		rules
 	});
 	const byTitle = [];
-	const lap = await lensLap(guard, lenses, lensBase, (lens, findings) => {
+	const lap = await lensLap(guard, lenses, lensBase, requirements, (lens, findings) => {
 		const before = byTitle.map((f) => f.title);
 		for (const { title } of findings) {
 			const at = before.indexOf(title);
@@ -232,28 +316,36 @@ const runTail = (finish, options) => scope("build", async () => {
 * `.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, report = NO_FINDINGS) => reviewToHandOff(base, {
-	file: REVIEW,
-	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,
-		guard
-	}),
-	awaitReview: (b) => awaitReview(b, handOffAwaitReviewMessage(b)),
-	reviewMissing,
-	close: closeReview,
-	handOff: (reviewed) => run("review.handing-off", showScript(reviewed, REVIEW, REVIEW_ORIG), { label: "Handing your notes to fix" }),
-	threadsPending: "gtd land: open-threads: a thread in .gtd/REVIEW.md or an `H:` code comment waits on the agent — nothing answers it here; delete it, or turn it into a note for fix.",
-	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."
-});
+const handOffReview = (base, escalations, guard, report = NO_FINDINGS) => {
+	let riskFixed = false;
+	return reviewToHandOff(base, {
+		file: REVIEW,
+		reviewing: guarded(async (b, carry) => {
+			const afterRiskFix = riskFixed;
+			riskFixed = false;
+			await reviewing(b, carry);
+			const review = read(REVIEW);
+			if (review === void 0 || !afterRiskFix && reviewRisks(review).length > 0) return;
+			const full = withSummary(review, { report });
+			if (full !== review) await run("review.carrying", writeScript(REVIEW, full), { label: "Adding the quality lap's summary" });
+		}, guard),
+		fixRisks: guarded((risks) => {
+			riskFixed = true;
+			return fixRisks(risks);
+		}, guard),
+		keepGreen: () => healthy(fixCheck, {
+			escalations,
+			guard
+		}),
+		awaitReview: (b) => awaitReview(b, handOffAwaitReviewMessage(b)),
+		reviewMissing,
+		close: closeReview,
+		handOff: (reviewed) => run("review.handing-off", showScript(reviewed, REVIEW, REVIEW_ORIG), { label: "Handing your notes to fix" }),
+		threadsPending: "gtd land: open-threads: a thread in .gtd/REVIEW.md or an `H:` code comment waits on the agent — nothing answers it here; delete it, or turn it into a note for fix.",
+		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`, which gets what the lap left. */
 const handOffTail = (fixFirst, base, guard) => tail((escalations, report) => handOffReview(base, escalations, guard, report), {
 	fixFirst,