@pmelab/gtd 42.0.0 → 44.0.0

package/dist/chunks/review-X7Jfz0dY.mjs

@@ -0,0 +1,249 @@
+import { answered, changesSince, head, judge, numeric, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
+import { removedAssertions, review } from "../workflow-kit.mjs";
+import { A as reviewMissing, E as fixNits, F as buildReviewTriageMessage, O as fixRisks, S as awaitReview, T as fixCheck, d as guarded, dt as reviewEditNotesCapture, f as healthy, ft as reviewEditsCapture, h as QUALITY, ht as reviewNotesCapture, w as collecting, x as answerReviewQuestions, y as REVIEW, z as composedReview } from "./reserved-DJk_6-ju.mjs";
+import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-5w5mxGTq.mjs";
+//#region src/workflows/shared/review.ts
+const VERDICTS = [
+	"edit",
+	"question",
+	"nit",
+	"praise"
+];
+/** One four-way choice per note the human added to `.gtd/REVIEW.md`. */
+const verdictQuestion = (note) => ({
+	id: note.id,
+	primitive: "choice",
+	instructions: `Classify the human's note on review item "${note.anchor}" (in .gtd/REVIEW.md). Its evidence holds the anchor, the reviewer's text and the human's text.`,
+	criteria: "edit: a request to change behaviour, design or scope — anything needing a plan, or any note you are unsure about. question: asks something and wants an answer, with no change requested. nit: a small, local, unambiguous fix (naming, typo, formatting, comment wording) needing no re-plan. praise: an approving remark with nothing to do."
+});
+const TIER_ORDER = {
+	critical: 0,
+	should: 1,
+	could: 2
+};
+/** Capture order: critical, should, could; within a tier one-way doors, then new concepts. */
+const captureKey = (s) => s === void 0 ? 2 : TIER_ORDER[s.tier] * 3 + s.rank;
+const SEVERITY_ANSWERS = {
+	security: ["yes", "no"],
+	reversibility: ["one-way", "two-way"],
+	blastRadius: [
+		"local",
+		"module",
+		"contract"
+	],
+	newConcept: ["yes", "no"]
+};
+/** Anything unanswered, unrecognised, cut or below `minP` is `critical`, never `could`. */
+const severityOf = (note, judgment, minP) => {
+	const ans = (q) => judgment.answers[`${note.id}.${q}`];
+	const a = (q) => ans(q)?.answer;
+	const rank = () => a("reversibility") === "one-way" ? 0 : a("newConcept") === "yes" ? 1 : 2;
+	if (note.forced) return {
+		tier: "critical",
+		reason: "critical: forced by `!`",
+		rank: 2
+	};
+	if (judgment.truncated.includes(note.id) || Object.entries(SEVERITY_ANSWERS).some(([q, allowed]) => !allowed.includes(a(q) ?? "") || !((ans(q)?.p ?? NaN) >= minP))) return {
+		tier: "critical",
+		reason: "critical: judge unsure",
+		rank: 2
+	};
+	const critical = [...a("security") === "yes" ? ["security"] : [], ...a("reversibility") === "one-way" ? ["one-way door"] : []];
+	if (critical.length > 0) return {
+		tier: "critical",
+		reason: `critical: ${critical.join(", ")}`,
+		rank: rank()
+	};
+	const should = [...a("blastRadius") === "contract" ? ["contract"] : [], ...a("newConcept") === "yes" ? ["new concept"] : []];
+	if (should.length > 0) return {
+		tier: "should",
+		reason: `should: ${should.join(", ")}`,
+		rank: rank()
+	};
+	return {
+		tier: "could",
+		reason: "could",
+		rank: 2
+	};
+};
+const severityQuestions = (note) => [
+	{
+		id: `${note.id}.security`,
+		primitive: "noul",
+		instructions: `Does the change the human asks for in note "${note.id}" (on "${note.anchor}") touch security — authentication, authorisation, secrets, untrusted input or data exposure?`,
+		criteria: "yes: it changes or could weaken a security property. no: it does not."
+	},
+	{
+		id: `${note.id}.reversibility`,
+		primitive: "choice",
+		instructions: `Once the change in note "${note.id}" ships, can it be undone without breaking anyone who already depends on it?`,
+		criteria: "one-way: a published API, file format, persisted data, protocol or other contract that cannot be taken back. two-way: can be reverted freely."
+	},
+	{
+		id: `${note.id}.blastRadius`,
+		primitive: "choice",
+		instructions: `How far does the change in note "${note.id}" reach?`,
+		criteria: "local: one function or file. module: a whole module or several files. contract: a public interface other code or users depend on."
+	},
+	{
+		id: `${note.id}.newConcept`,
+		primitive: "noul",
+		instructions: `Does the change in note "${note.id}" introduce a concept new to this codebase — a new abstraction, entity or term? Judge from the evidence, never a glossary; reusing or extending an existing concept is not new.`,
+		criteria: "yes: a genuinely new concept. no: reuses or extends an existing one."
+	}
+];
+/**
+* One judge rest: a verdict per unforced note (a forced note is asked
+* nothing) plus four severity answers. Dismissing a note is the risky
+* direction, so only a confident non-`edit` verdict on uncut evidence counts;
+* a cut, unanswered or below-floor note is an `edit`. Severity answers on a
+* non-`edit` note are ignored; on an `edit` they order the collecting turn.
+*/
+const triage = (severities) => async (notes) => {
+	const asked = notes.filter((n) => !n.forced);
+	const judgment = asked.length === 0 ? {
+		answers: {},
+		truncated: []
+	} : await judge("review.triage", {
+		questions: asked.flatMap((n) => [verdictQuestion(n), ...severityQuestions(n)]),
+		evidence: Object.fromEntries(asked.map((n) => [n.id, `Anchor: ${n.anchor}\nReviewer's text: ${n.before}\nHuman's text: ${n.text}`])),
+		message: buildReviewTriageMessage(),
+		label: "Judging each note"
+	});
+	const { answers, truncated } = judgment;
+	const minP = numeric(vars.reviewNoteActionable, Infinity);
+	const severityMinP = numeric(vars.reviewSeverityMinP, Infinity);
+	severities.clear();
+	return new Map(notes.map((n) => {
+		const verdict = n.forced ? void 0 : VERDICTS.find((v) => v !== "edit" && answered(answers[n.id], v, minP));
+		if (verdict !== void 0 && !truncated.includes(n.id)) return [n.id, verdict];
+		severities.set(n.id, severityOf(n, judgment, severityMinP));
+		return [n.id, "edit"];
+	}));
+};
+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
+* after fixed nits restores the doc as committed at `carry`, answers kept;
+* a fresh one leaves out the notes the human already answered.
+*/
+const composing = (base, report, carry, nitFix, answered = /* @__PURE__ */ new Set()) => run("review.composing", carry === void 0 ? writeScript(REVIEW, composedReview(base, {
+	...report,
+	weakened: removedAssertions(changesSince(base)),
+	nitFix,
+	answered
+}), [QUALITY]) : showScript(carry, REVIEW, REVIEW), {
+	label: "Composing the review",
+	file: REVIEW,
+	base
+});
+/**
+* The quality lap's notes reach a human over everything since `base`, who
+* answers each one — fix as suggested, won't fix, or their own answer — and
+* may comment. A fix joins the nit batch, a won't-fix is dropped, and an own
+* answer or comment is judged: edits end the review as `feedback` for the
+* caller to build, questions are answered in place, nits fixed in one batch,
+* praise dropped.
+*/
+const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
+	const { guard, guardRests, fixAccess, rules } = options;
+	const feedback = options.feedback ?? {
+		file: ".gtd/REQUIREMENTS.md",
+		collecting,
+		unmatched: "gtd land: no declared pattern matches the pending changes — write .gtd/REQUIREMENTS.md from the feedback, or change nothing when it asks for nothing"
+	};
+	const severities = /* @__PURE__ */ new Map();
+	let nitFix;
+	const answered = /* @__PURE__ */ new Set();
+	return review(base, {
+		file: REVIEW,
+		feedback: feedback.file,
+		isCode,
+		reviewing: (b, carry) => {
+			const fixedAt = nitFix;
+			nitFix = void 0;
+			return composing(b, options.report ?? NO_FINDINGS, carry, fixedAt, answered);
+		},
+		fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
+		keepGreen: () => healthy(() => fixCheck(rules), {
+			escalations,
+			guard,
+			guardRests,
+			rules
+		}),
+		awaitReview: (b) => awaitReview(b),
+		reviewMissing,
+		collecting: feedback.collecting,
+		triage: triage(severities),
+		decided: (decisions) => decisions.forEach((d) => answered.add(d.anchor)),
+		answerQuestions: answerReviewQuestions,
+		fixNits: async (notes) => {
+			await guarded((n) => fixNits(n, fixAccess, rules), guard)(notes);
+			nitFix = head();
+		},
+		close: closeReview,
+		captures: {
+			edits: reviewEditsCapture,
+			notes: reviewNotesCapture,
+			editNotes: (round, edits, answeredAt) => reviewEditNotesCapture(round, edits.map((n, i) => ({
+				n,
+				i,
+				s: severities.get(n.id),
+				key: captureKey(severities.get(n.id))
+			})).sort((x, y) => x.key - y.key || x.i - y.i).map(({ n, s }) => ({
+				id: n.id,
+				anchor: n.anchor,
+				text: n.forced ? n.text.replace(/^!\s*/, "") : n.text,
+				...s === void 0 ? {} : { label: s.reason }
+			})), answeredAt)
+		},
+		refusals: {
+			deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note (or edit code) to request changes.",
+			unmatched: feedback.unmatched,
+			...feedback.dropped === void 0 ? {} : { dropped: feedback.dropped }
+		}
+	});
+};
+function buildTail(first, second, ...rest) {
+	const options = callForm(first, second, rest);
+	if (options === void 0) return Promise.reject(/* @__PURE__ */ new Error("buildTail takes buildTail(base, options?) or the deprecated buildTail(fixFirst, base, green?, options?); this call fits neither"));
+	const [base, form] = options;
+	return tail((escalations, report) => humanReview(base, escalations, {
+		...form,
+		report
+	}), {
+		...form,
+		triage: true
+	});
+}
+const isOptionalBoolean = (value) => value == null || typeof value === "boolean";
+const legacyForm = (fixFirst, base, green, options) => isOptionalBoolean(fixFirst) && isOptionalBoolean(green) && isOptionalObject(options) ? [base, {
+	...options,
+	fixFirst: fixFirst ?? void 0,
+	green: green ?? void 0
+}] : void 0;
+const currentForm = (base, options, third, fourth) => isOptionalObject(options) && third == null && fourth == null ? [base, options ?? {}] : void 0;
+const callForm = (first, second, [third, fourth, ...extra]) => {
+	if (extra.some((value) => value != null)) return void 0;
+	if (typeof second === "string") return legacyForm(first, second, third, fourth);
+	if (typeof first === "string") return currentForm(first, second, third, fourth);
+};
+/**
+* Undo the human's review-round code edits. A path changed since the human
+* left it is not overwritten; requireRevert names it instead.
+*/
+const reUnwind = async (feedback) => {
+	const { base, restoreFrom, edited } = feedback;
+	await run("re-unwind", restoreScript(base, {
+		restore: edited.filter((c) => c.status !== "added").map((c) => c.path),
+		remove: edited.filter((c) => c.status === "added").map((c) => c.path)
+	}, restoreFrom), {
+		label: "Re-unwinding your review edit",
+		file: REVIEW,
+		base
+	});
+	requireRevert(edited, base);
+};
+//#endregion
+export { reUnwind as i, humanReview as n, isCode as r, buildTail as t };

package/dist/chunks/{steering-oCDdQlpP.mjs → steering-D4LUQ-av.mjs}

@@ -13349,8 +13349,8 @@ const eolOf = (content) => content.includes("\r\n") ? "\r\n" : "\n";
 const PREFIX_RE$1 = /^(H|A):\s*/;
 const lineOf = (node, which) => toLspPosition(node.position[which]).line;
 /** The item's own blocks joined — never the item node's span, which can run past its last line into the next bullet's marker. */
-const itemText = (content, item) => item.children.map((child) => sourceText(content, child)).join(" ").trim();
-const prefixOf = (content, item) => PREFIX_RE$1.exec(itemText(content, item));
+const itemText$1 = (content, item) => item.children.map((child) => sourceText(content, child)).join(" ").trim();
+const prefixOf = (content, item) => PREFIX_RE$1.exec(itemText$1(content, item));
 /** A thread is a definition whose body OPENS with a list whose first item carries a prefix — anything else stays a one-shot footnote. */
 const isThreadBody = (content, children) => {
 	const first = children[0];
@@ -13370,7 +13370,7 @@ const entryOf = (content, item, previous, report) => {
 		return;
 	}
 	const author = match[1] === "H" ? "me" : "agent";
-	const text = itemText(content, item).slice(match[0].length).trim();
+	const text = itemText$1(content, item).slice(match[0].length).trim();
 	if (text === "") report(`empty "${match[1]}:" entry — write your own words there`, start, end);
 	if (previous === void 0 && author === "agent") report(`the agent never starts a thread — the first entry must be "H:"`, start, end);
 	else if (previous === author) report(`two consecutive "${match[1]}:" entries — entries must alternate`, start, end);
@@ -15086,6 +15086,9 @@ const qaDescriptor = {
 };
 //#endregion
 //#region src/steering/review.ts
+const ANSWER_LEAD = "Tick exactly one:";
+const ANSWER_FIX = "fix as suggested";
+const ANSWER_WONT_FIX = "won't fix";
 /**
 * The canonical sample. Every detail here is load-bearing for the formatter
 * round-trip: both footnote bodies exceed 80 characters so a reflow actually
@@ -15352,16 +15355,42 @@ const parseHunk = (content, lines, title, item) => {
 		errors: [hunkSecondPointerFinding(content, lines, item, token, sourceLine, title, file), hunkLineWithoutRangeFinding(content, item, token, sourceLine, title, file)].filter((e) => e !== void 0)
 	};
 };
+const itemText = (content, item) => item.children.map((c) => sourceText(content, c)).join(" ").replace(/^\[[ xX]\]\s*/, "").trim();
+/**
+* The task list right after the `Tick exactly one:` paragraph, with that
+* paragraph's index. Read by position, never by label, so an edited label or
+* a free text opening with `./path` is still an answer, not a pointer. Any
+* count but three boxes is kept, and reads as unanswered.
+*/
+const answerListOf = (content, body) => {
+	const lead = body.findIndex((n, i) => n.type === "paragraph" && sourceText(content, n) === "Tick exactly one:" && body[i + 1]?.type === "list" && body[i + 1].children.every((item) => item.checked != null));
+	if (lead === -1) return void 0;
+	const list = body[lead + 1];
+	const last = list.children.length - 1;
+	return {
+		lead,
+		list,
+		options: list.children.map((item, i) => {
+			const text = itemText(content, item);
+			return {
+				checked: item.checked === true,
+				text: i === last && text.toLowerCase() === "_your answer_".toLowerCase() ? "" : text
+			};
+		})
+	};
+};
 /** Splits one chunk's body nodes into its file pointers (hunk pointers are task items, collected recursively at ANY nesting depth via `taskItems` — a nested hunk is the same kind of hunk as a top-level one) and description prose. The description is the chunk's own leading run and never a node that contains a hunk pointer: it stops at the first node whose `taskItems` include a real pointer (at any depth — a blockquote wrapping a pointer list stops it just as a top-level list would). Every node kind in what's left before that point contributes — a `footnoteDefinition` is the one exception, excluded by `blockNodesOfRun` itself (it's a note, never document content). */
 const parseChunkBody = (content, lines, title, body) => {
-	const firstPointerIndex = body.findIndex((n) => taskItems(n).some((item) => hasPointerToken(content, item)));
-	const leadingRun = firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex);
+	const answer = answerListOf(content, body);
+	const isAnswer = (n) => answer !== void 0 && (n === answer.list || n === body[answer.lead]);
+	const firstPointerIndex = body.findIndex((n) => !isAnswer(n) && taskItems(n).some((item) => hasPointerToken(content, item)));
+	const leadingRun = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter((n) => !isAnswer(n));
 	const descriptionNodes = blockNodesOfRun(content, leadingRun);
 	const descriptionInline = collapseImages(blockRunInline(content, leadingRun));
 	const description = leadingRun.filter((n) => n.type !== "footnoteDefinition").map((n) => sourceText(content, n)).join(" ").trim();
 	const files = [];
 	const errors = [];
-	for (const item of body.flatMap((n) => taskItems(n))) {
+	for (const item of body.filter((n) => !isAnswer(n)).flatMap((n) => taskItems(n))) {
 		const parsed = parseHunk(content, lines, title, item);
 		if (!parsed) continue;
 		files.push(parsed.file);
@@ -15372,7 +15401,9 @@ const parseChunkBody = (content, lines, title, body) => {
 		descriptionNodes,
 		descriptionInline,
 		files,
-		errors
+		errors,
+		...answer === void 0 ? {} : { answers: answer.options },
+		boxed: body.some((n) => !isAnswer(n) && taskItems(n).length > 0)
 	};
 };
 /** Splits the tree's top-level nodes into consecutive `##` chunk blocks — a `## ` line found only inside a fence never becomes a heading node at all, so it's never mistaken for a chunk. */
@@ -15408,9 +15439,9 @@ const parseChangesets = (tree, content, lines) => {
 	const errors = [];
 	for (const { heading, headingLine, body } of splitChunks(tree)) {
 		const title = headingText$1(content, heading);
-		const { description, descriptionNodes, descriptionInline, files, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
+		const { description, descriptionNodes, descriptionInline, files, answers, boxed, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
 		errors.push(...bodyErrors);
-		if (files.length === 0 && body.some((n) => taskItems(n).length > 0)) errors.push({
+		if (files.length === 0 && boxed) errors.push({
 			message: `Chunk "${title}" has no file pointers`,
 			line: headingLine,
 			range: nodeRange(heading)
@@ -15421,7 +15452,8 @@ const parseChangesets = (tree, content, lines) => {
 			descriptionNodes,
 			descriptionInline,
 			files,
-			headingLine
+			headingLine,
+			...answers === void 0 ? {} : { answers }
 		});
 	}
 	if (changesets.length === 0) errors.push({ message: "REVIEW.md has no '##' chunks" });
@@ -15502,7 +15534,9 @@ const isHunkPointerItem = (content, item) => {
 * clear, so a caller can skip the write and leave the mtime untouched.
 */
 const reviewClearTicks = (content) => {
-	const offsets = taskItems(parseMarkdown(content)).filter((item) => item.checked === true && isHunkPointerItem(content, item)).map((item) => checkboxOffset(content, item)).filter((o) => o !== void 0).sort((a, b) => a - b);
+	const tree = parseMarkdown(content);
+	const answers = new Set(splitChunks(tree).flatMap(({ body }) => answerListOf(content, body)?.list.children ?? []));
+	const offsets = taskItems(tree).filter((item) => item.checked === true && !answers.has(item) && isHunkPointerItem(content, item)).map((item) => checkboxOffset(content, item)).filter((o) => o !== void 0).sort((a, b) => a - b);
 	if (offsets.length === 0) return content;
 	let result = "";
 	let cursor = 0;
@@ -15936,6 +15970,55 @@ const reviewRisks = (content) => parseReviewDoc(content).changesets.flatMap((chu
 	id: `risk-${i + 1}`,
 	...r
 }));
+const CHOICES = [
+	"fix",
+	"wontfix",
+	"answer"
+];
+const decisionOf = (chunk) => {
+	if (chunk.answers?.length !== 3) return void 0;
+	const ticked = chunk.answers.flatMap((o, i) => o.checked ? [i] : []);
+	if (ticked.length !== 1) return void 0;
+	const i = ticked[0];
+	const text = i === 2 ? chunk.answers[2].text : "";
+	if (i === 2 && text === "") return void 0;
+	return {
+		anchor: chunk.title,
+		body: chunk.description,
+		choice: CHOICES[i],
+		text
+	};
+};
+/**
+* Notes whose answer boxes do not hold exactly one tick (a ticked free-text
+* slot filled in), with their 1-based heading line and why; and, given the
+* file `before` the edit, every note whose boxes were deleted.
+*/
+const unansweredNotes = (content, before) => {
+	const now = parseReviewDoc(content).changesets;
+	const boxed = new Set(now.filter((c) => c.answers !== void 0).map((c) => c.title));
+	const removed = (before === void 0 ? [] : parseReviewDoc(before).changesets).filter((c) => c.answers !== void 0 && !boxed.has(c.title)).map((c) => ({
+		title: c.title,
+		line: 0,
+		reason: "its answer boxes were deleted — restore them"
+	}));
+	return [...now.filter((c) => c.answers !== void 0 && decisionOf(c) === void 0).map((c) => ({
+		title: c.title,
+		line: c.headingLine + 1,
+		reason: c.answers.length === 3 ? "tick exactly one box" : `it has ${c.answers.length} boxes — restore the three gtd wrote`
+	})), ...removed];
+};
+/** Every answer in `after` that `before` did not already hold for the same note, in document order. */
+const reviewDecisions = (before, after) => {
+	const prior = new Map(parseReviewDoc(before).changesets.map((c) => [c.title, c]));
+	return parseReviewDoc(after).changesets.flatMap((chunk) => {
+		const decision = decisionOf(chunk);
+		if (decision === void 0) return [];
+		const was = prior.get(chunk.title);
+		const old = was === void 0 ? void 0 : decisionOf(was);
+		return old?.choice === decision.choice && old.text === decision.text ? [] : [decision];
+	});
+};
 //#endregion
 //#region src/steering/Edits.ts
 /** Splices `edits` into `content`, sorted last-to-first so an earlier range's offset is never invalidated by a later edit. Positions are 0-based line/character over `\n`-split lines. */
@@ -16304,4 +16387,4 @@ const viewOf = (format, content) => ({
 /** Every OPEN thread — last entry is the agent's — as `{ name, line, firstMe }` (0-based line). `[]` for a format with no thread concept. */
 const openThreads = (format, content) => format.openThreads?.(content) ?? [];
 //#endregion
-export { headingSections as C, headingSectionBodies as S, openThreadFindings as _, unansweredQuestions as a, parseThreadsWithFindings as b, stripCodeThreads as c, reviewNotes as d, reviewRisks as f, THREAD_REPLY_ACTION_TITLE as g, FOOTNOTE_ACTION_TITLE as h, steeringFormatOrFreeForm as i, freeFormFormat as l, isAnswered as m, openThreads as n, viewOf as o, FREE_TEXT_PLACEHOLDER as p, steeringFormatFor as r, parseCodeThreads as s, BUILT_IN_MODE_NAMES as t, applySteeringEdits as u, parseFootnotes as v, formatFinding as w, getParseCount as x, parseThreads as y };
+export { parseFootnotes as C, headingSectionBodies as D, getParseCount as E, headingSections as O, openThreadFindings as S, parseThreadsWithFindings as T, unansweredNotes as _, unansweredQuestions as a, FOOTNOTE_ACTION_TITLE as b, stripCodeThreads as c, ANSWER_FIX as d, ANSWER_LEAD as f, reviewRisks as g, reviewNotes as h, steeringFormatOrFreeForm as i, formatFinding as k, freeFormFormat as l, reviewDecisions as m, openThreads as n, viewOf as o, ANSWER_WONT_FIX as p, steeringFormatFor as r, parseCodeThreads as s, BUILT_IN_MODE_NAMES as t, applySteeringEdits as u, FREE_TEXT_PLACEHOLDER as v, parseThreads as w, THREAD_REPLY_ACTION_TITLE as x, isAnswered as y };

package/dist/chunks/{tail-D2o2h5cc.mjs → tail-5w5mxGTq.mjs}

@@ -1,6 +1,6 @@
 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 fixCheck, D as reviewMissing, O as reviewQuality, T as fixRisks, X as handOffAwaitReviewMessage, at as qualityTriageMessage, d as guarded, f as healthy, h as QUALITY, it as qualityFindingsFile, k as reviewing, l as escalation, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-D7MNY9QJ.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-DJk_6-ju.mjs";
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
 	notes: [],
@@ -217,7 +217,7 @@ const runTail = (finish, options) => scope("build", async () => {
 	return finish(escalations, NO_FINDINGS);
 });
 /**
-* The review and fix workflows' human review since `base`: a sign-off closes
+* 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.
 */
@@ -237,7 +237,7 @@ 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 review and fix workflows run: ends at the hand-off review since `base`. */
+/** 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), {
 	fixFirst,
 	guard