@pmelab/gtd 51.0.1 → 52.0.0

package/dist/chunks/{steering-DtUVUz9l.mjs → steering-CLhu8C7q.mjs}

@@ -15396,8 +15396,8 @@ const splitSeverity = (content, run) => {
 	};
 };
 /** 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 answer = answerListOf(content, body);
+const parseChunkBody = (content, lines, title, body, answerable) => {
+	const answer = answerable ? answerListOf(content, body) : void 0;
 	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 run = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter((n) => !isAnswer(n));
@@ -15419,45 +15419,78 @@ const parseChunkBody = (content, lines, title, body) => {
 		descriptionInline,
 		files,
 		errors,
-		...answer === void 0 ? {} : { answers: answer.options },
+		...answer === void 0 ? {} : {
+			answers: answer.options,
+			answerLine: toLspPosition(body[answer.lead].position.start).line
+		},
 		...severity === void 0 ? {} : { severity },
 		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. */
-const splitChunks = (tree) => {
-	const blocks = [];
-	let i = 0;
-	while (i < tree.children.length) {
-		const node = tree.children[i];
-		if (node.type !== "heading" || node.depth !== 2) {
-			i += 1;
-			continue;
-		}
-		const heading = node;
-		const headingLine = toLspPosition(heading.position.start).line;
-		i += 1;
-		const body = [];
-		while (i < tree.children.length) {
-			const next = tree.children[i];
-			if (next.type === "heading" && next.depth <= 2) break;
-			body.push(next);
-			i += 1;
+/** The `## ` headings gtd groups the review's chunks under; any other `## ` is a chunk of its own. */
+const REVIEW_SECTIONS = {
+	findings: "Findings",
+	walkthrough: "Walkthrough"
+};
+const sectionOf = (content, node) => {
+	if (node.type !== "heading" || node.depth !== 2) return void 0;
+	const text = headingText$1(content, node);
+	return Object.keys(REVIEW_SECTIONS).find((s) => REVIEW_SECTIONS[s] === text);
+};
+/** The nodes after `from` up to the next heading at `depth` or shallower. */
+const bodyFrom = (children, from, depth) => {
+	const end = children.findIndex((n, i) => i >= from && n.type === "heading" && n.depth <= depth);
+	return children.slice(from, end === -1 ? void 0 : end);
+};
+/**
+* Splits the tree's top-level nodes into chunk blocks — a `## ` line found only
+* inside a fence never becomes a heading node at all. A document with a
+* `## Findings` or `## Walkthrough` heading nests `### ` chunks under them;
+* one without is the flat layout, every `## ` a chunk.
+*/
+const splitChunks = (tree, content) => {
+	const sectioned = tree.children.some((n) => sectionOf(content, n) !== void 0);
+	const chunks = [];
+	const sections = [];
+	let section;
+	tree.children.forEach((node, i) => {
+		if (node.type !== "heading") return;
+		const headingLine = toLspPosition(node.position.start).line;
+		if (sectioned && node.depth <= 2) {
+			const s = sectionOf(content, node);
+			section = s === void 0 ? void 0 : {
+				heading: node,
+				headingLine,
+				section: s,
+				body: []
+			};
+			if (section !== void 0) {
+				sections.push(section);
+				return;
+			}
 		}
-		blocks.push({
-			heading,
+		const depth = section === void 0 ? 2 : 3;
+		if (node.depth !== depth) return;
+		const body = bodyFrom(tree.children, i + 1, depth);
+		chunks.push({
+			heading: node,
 			headingLine,
-			body
+			body,
+			...section && { section: section.section }
 		});
-	}
-	return blocks;
+		section?.body.push(node, ...body);
+	});
+	return {
+		chunks,
+		sections
+	};
 };
 const parseChangesets = (tree, content, lines) => {
 	const changesets = [];
 	const errors = [];
-	for (const { heading, headingLine, body } of splitChunks(tree)) {
+	for (const { heading, headingLine, body, section } of splitChunks(tree, content).chunks) {
 		const title = headingText$1(content, heading);
-		const { description, descriptionNodes, descriptionInline, files, answers, severity, boxed, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
+		const { description, descriptionNodes, descriptionInline, files, answers, answerLine, severity, boxed, errors: bodyErrors } = parseChunkBody(content, lines, title, body, section !== "walkthrough");
 		errors.push(...bodyErrors);
 		if (files.length === 0 && boxed) errors.push({
 			message: `Chunk "${title}" has no file pointers`,
@@ -15471,8 +15504,12 @@ const parseChangesets = (tree, content, lines) => {
 			descriptionInline,
 			files,
 			headingLine,
-			...answers === void 0 ? {} : { answers },
-			...severity === void 0 ? {} : { severity }
+			...answers === void 0 ? {} : {
+				answers,
+				answerLine
+			},
+			...severity === void 0 ? {} : { severity },
+			...section === void 0 ? {} : { section }
 		});
 	}
 	if (changesets.length === 0) errors.push({ message: "REVIEW.md has no '##' chunks" });
@@ -15554,7 +15591,7 @@ const isHunkPointerItem = (content, item) => {
 */
 const reviewClearTicks = (content) => {
 	const tree = parseMarkdown(content);
-	const answers = new Set(splitChunks(tree).flatMap(({ body }) => answerListOf(content, body)?.list.children ?? []));
+	const answers = new Set(splitChunks(tree, content).chunks.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 = "";
@@ -15591,42 +15628,80 @@ const toggleFilePointer = (content, line) => {
 const chunkEndLines = (content) => {
 	const tree = parseMarkdown(content);
 	const map = /* @__PURE__ */ new Map();
-	for (const block of splitChunks(tree)) map.set(block.headingLine, blockEndLine(block));
+	for (const block of splitChunks(tree, content).chunks) map.set(block.headingLine, blockEndLine(block));
 	return map;
 };
+const CHOICE_NAMES = {
+	fix: ANSWER_FIX,
+	wontfix: ANSWER_WONT_FIX,
+	answer: ""
+};
+/** A finding's decision as an outline node of its own; none for a chunk with no answer boxes. */
+const decisionNodes = (lines, chunk, end) => {
+	if (chunk.answerLine === void 0) return [];
+	const d = decisionOf(chunk);
+	return [{
+		name: `Decision: ${d === void 0 ? "open" : CHOICE_NAMES[d.choice] || d.text}`,
+		range: spanRange(lines, chunk.answerLine, Math.max(chunk.answerLine, end)),
+		selectionRange: lineRange(lines, chunk.answerLine)
+	}];
+};
+const isOpenChunk = (chunk, markers) => chunk.files.some((file) => !file.checked) || markers > 0 || chunk.answers !== void 0 && decisionOf(chunk) === void 0;
 /**
-* Document outline for `.gtd/REVIEW.md`: the headlines of chunks (the
-* user-facing "work packages") that still carry at least one unchecked hunk
-* — the outline is the list of packages left to review — PLUS any chunk
-* that carries at least one footnote, even when every hunk in it is ticked:
-* `reviewOutline` otherwise drops a fully-checked chunk, which would make a
-* human's own comment vanish the moment they tick the last box. A chunk's
-* footnotes are `leaf: true` children; a chunk with none has no children.
+* Document outline for `.gtd/REVIEW.md`: the chunks still left to review — an
+* unchecked hunk, a footnote (so a human's comment never vanishes with the
+* last tick) or an open decision. A finding's decision is a node of its own.
+* In the sectioned layout `Findings` and `Walkthrough` are containers, and
+* every other `## ` (`Fixed automatically`, …) stays listed.
 */
 const reviewOutline = (content) => {
 	const { changesets } = parseReviewDoc(content);
+	const { sections } = splitChunks(parseMarkdown(content), content);
 	const { markers, definitions } = parseFootnotes(content);
 	const definitionByName = new Map(definitions.map((d) => [d.name, d.body]));
 	const lines = content.split(/\r?\n/);
 	const endLines = chunkEndLines(content);
 	const threads = threadOutlineNodes(content);
 	const nested = /* @__PURE__ */ new Set();
-	return [...changesets.map((chunk) => {
+	const chunkNodes = changesets.flatMap((chunk) => {
 		const start = chunk.headingLine;
 		const end = Math.max(start, endLines.get(start) ?? start);
 		const checkedCount = chunk.files.filter((file) => file.checked).length;
 		const chunkMarkers = markers.filter((m) => m.line >= start && m.line <= end);
 		const chunkThreads = threads.filter((t) => t.markerLine !== void 0 && t.markerLine >= start && t.markerLine <= end).map((t) => t.node);
 		chunkThreads.forEach((n) => nested.add(n));
-		const children = [...chunkMarkers.map((m) => footnoteLeaf(lines, definitionByName, m)), ...chunkThreads];
-		return {
-			name: `${chunk.title} (${checkedCount}/${chunk.files.length})`,
+		const children = [
+			...decisionNodes(lines, chunk, end),
+			...chunkMarkers.map((m) => footnoteLeaf(lines, definitionByName, m)),
+			...chunkThreads
+		];
+		if (!(sections.length > 0 && chunk.section === void 0) && !isOpenChunk(chunk, chunkMarkers.length)) return [];
+		const node = {
+			name: chunk.files.length === 0 ? chunk.title : `${chunk.title} (${checkedCount}/${chunk.files.length})`,
 			range: spanRange(lines, start, end),
 			selectionRange: lineRange(lines, start),
-			...children.length > 0 ? { children } : {},
-			unchecked: checkedCount < chunk.files.length || chunkMarkers.length > 0
+			...children.length > 0 ? { children } : {}
 		};
-	}).filter((node) => node.unchecked).map(({ unchecked: _unchecked, ...node }) => node), ...threads.map((t) => t.node).filter((n) => !nested.has(n))];
+		return [{
+			line: start,
+			section: chunk.section,
+			node
+		}];
+	});
+	const containers = sections.map((section) => ({
+		line: section.headingLine,
+		section: void 0,
+		node: {
+			name: REVIEW_SECTIONS[section.section],
+			range: spanRange(lines, section.headingLine, blockEndLine(section)),
+			selectionRange: lineRange(lines, section.headingLine),
+			children: chunkNodes.filter((c) => c.section === section.section && c.line > section.headingLine).filter((c) => {
+				const next = sections.find((o) => o.headingLine > section.headingLine);
+				return next === void 0 || c.line < next.headingLine;
+			}).map((c) => c.node)
+		}
+	}));
+	return [...[...chunkNodes.filter((c) => c.section === void 0), ...containers].sort((a, b) => a.line - b.line).map((c) => c.node), ...threads.map((t) => t.node).filter((n) => !nested.has(n))];
 };
 /**
 * The target state a whole-chunk toggle drives every hunk to: `true` (check
@@ -15678,6 +15753,7 @@ const reviewActions = (content, range) => {
 	const tree = parseMarkdown(content);
 	const lines = content.split(/\r?\n/);
 	const cursorLine = range.start.line;
+	const endLines = chunkEndLines(content);
 	const actions = [...threadReplyActions(content, range.start)];
 	changesets.forEach((chunk, i) => {
 		const hunk = chunk.files.find((file) => cursorLine >= file.sourceLine && cursorLine <= file.endLine);
@@ -15688,7 +15764,7 @@ const reviewActions = (content, range) => {
 				edits: [edit]
 			});
 		}
-		const chunkEnd = Math.max(chunk.headingLine, (changesets[i + 1]?.headingLine ?? lines.length) - 1);
+		const chunkEnd = chunk.section === void 0 ? Math.max(chunk.headingLine, (changesets[i + 1]?.headingLine ?? lines.length) - 1) : endLines.get(chunk.headingLine) ?? chunk.headingLine;
 		if (chunk.files.length > 0 && cursorLine >= chunk.headingLine && cursorLine <= chunkEnd) {
 			const edits = toggleChunkEdits(content, chunk.headingLine);
 			if (edits.length > 0) {
@@ -15756,7 +15832,7 @@ const hunkLinkFor = (content, item) => {
 const reviewDocumentLinks = (content) => {
 	const tree = parseMarkdown(content);
 	const links = [];
-	for (const block of splitChunks(tree)) for (const item of block.body.flatMap((n) => taskItems(n))) {
+	for (const block of splitChunks(tree, content).chunks) for (const item of block.body.flatMap((n) => taskItems(n))) {
 		const link = hunkLinkFor(content, item);
 		if (link) links.push(link);
 	}
@@ -15778,6 +15854,19 @@ const reviewView = (content) => {
 				kind: "chunk",
 				index: chunkIndex
 			},
+			...chunk.section === void 0 ? {} : { group: REVIEW_SECTIONS[chunk.section] },
+			...chunk.answers === void 0 ? {} : {
+				answered: decisionOf(chunk) !== void 0,
+				decision: chunk.answers.map((option, index) => ({
+					title: option.text,
+					checked: option.checked,
+					anchor: {
+						kind: "option",
+						questionIndex: chunkIndex,
+						index
+					}
+				}))
+			},
 			...noteAt(chunk.headingLine),
 			children: chunk.files.map((file, index) => ({
 				title: pointerDisplay(file),
@@ -15875,8 +15964,66 @@ const setFileTickEdits = (content, files, checked) => {
 	}
 	return edits;
 };
-/** A `hunk` anchor sets one tick; a `chunk` anchor sets every hunk beneath it to the SAME target state — never `toggleChunkEdits`'s majority-flip heuristic, since the caller already knows the state it wants. */
+/**
+* A finding's answer boxes are radio: ticking one unticks the others, and
+* `text` replaces the ticked box's label in the same edit set — the phone's
+* free-text answer, normalized as `qa`'s is.
+*/
+const decisionEdits = (content, chunkIndex, index, opts) => {
+	const items = answerItemsOf(content, chunkIndex);
+	const target = items[index];
+	if (target === void 0) return {
+		ok: false,
+		reason: "anchor-not-found"
+	};
+	const checked = opts.checked ?? true;
+	const ticks = items.flatMap((item) => {
+		const want = item === target ? checked : !checked && item.checked === true;
+		return item.checked === true === want ? [] : tickEdit(content, item, want);
+	});
+	const text = opts.text === void 0 ? [] : labelEdit(content, target, opts.text);
+	return {
+		ok: true,
+		edits: [...ticks, ...text]
+	};
+};
+/** A finding's answer boxes; none for a walkthrough chunk or a stale index. */
+const answerItemsOf = (content, chunkIndex) => {
+	const chunk = splitChunks(parseMarkdown(content), content).chunks[chunkIndex];
+	if (chunk === void 0 || chunk.section === "walkthrough") return [];
+	return answerListOf(content, chunk.body)?.list.children ?? [];
+};
+const tickEdit = (content, item, checked) => {
+	const offset = checkboxOffset(content, item);
+	if (offset === void 0) return [];
+	const start = toLspPositionFromOffset(content, offset);
+	return [{
+		range: {
+			start,
+			end: {
+				...start,
+				character: start.character + 1
+			}
+		},
+		newText: checked ? "x" : " "
+	}];
+};
+/** Replaces a box's label, from after its marker to the end of its first paragraph. */
+const labelEdit = (content, item, text) => {
+	const from = firstParagraphContentOffset(item);
+	const to = item.children.find((c) => c.type === "paragraph")?.position?.end.offset;
+	if (from === void 0 || to === void 0) return [];
+	return [{
+		range: {
+			start: toLspPositionFromOffset(content, from),
+			end: toLspPositionFromOffset(content, to)
+		},
+		newText: normalizeFreeTextAnswer(text)
+	}];
+};
+/** A `hunk` anchor sets one tick; a `chunk` anchor sets every hunk beneath it to the SAME target state — never `toggleChunkEdits`'s majority-flip heuristic, since the caller already knows the state it wants. An `option` anchor is a finding's decision. */
 const reviewApply = (content, anchor, opts) => {
+	if (anchor.kind === "option") return decisionEdits(content, anchor.questionIndex, anchor.index, opts);
 	const { changesets } = parseReviewDoc(content);
 	const checked = opts.checked ?? true;
 	if (anchor.kind === "hunk") {
@@ -16043,11 +16190,12 @@ const reviewDecisions = (before, after) => {
 		return old?.choice === decision.choice && old.text === decision.text ? [] : [decision];
 	});
 };
-/** Each `##` chunk in document order: its title, 0-based heading line and how many hunk pointers it holds. */
+/** Each chunk in document order: its title, 0-based heading line and how many hunk pointers it holds. */
 const reviewChunks = (content) => parseReviewDoc(content).changesets.map((c) => ({
 	title: c.title,
 	line: c.headingLine,
 	pointers: c.files.length,
+	...c.section === void 0 ? {} : { section: c.section },
 	...c.severity === void 0 ? {} : { severityLine: c.severity.line },
 	files: c.files.map((f) => ({
 		path: f.path,
@@ -16055,6 +16203,68 @@ const reviewChunks = (content) => parseReviewDoc(content).changesets.map((c) =>
 		...f.rangeEnd === void 0 ? {} : { rangeEnd: f.rangeEnd }
 	}))
 }));
+/** The `## Findings` / `## Walkthrough` headings in `content`, with their 0-based lines. */
+const reviewSections = (content) => splitChunks(parseMarkdown(content), content).sections.map((s) => ({
+	section: s.section,
+	line: s.headingLine
+}));
+const isBlankLine = (line) => line !== void 0 && line.trim() === "";
+/** How many lines a chunk's heading takes: two for a setext heading and its underline. */
+const headingSize = ({ heading, headingLine }) => toLspPosition(heading.position.end).line - headingLine + 1;
+/** \`block\` with its heading an ATX \`### \` on one line, and every heading in its body one level deeper. */
+const demoted = (chunk, block) => {
+	const out = [...block];
+	for (const node of chunk.body) {
+		if (node.type !== "heading" || node.depth < 3 || node.depth > 5) continue;
+		const at = toLspPosition(node.position.start).line - chunk.headingLine;
+		out[at] = out[at].replace(/^( {0,3})#/, "$1##");
+	}
+	const size = headingSize(chunk);
+	return [size > 1 ? `### ${out[0].trim()}` : out[0].replace(/^ {0,3}##/, "###"), ...out.slice(size)];
+};
+/** A chunk's \`size\` heading lines, then its body with the blank lines around it trimmed. */
+const chunkText = (block, size) => {
+	const rest = block.slice(size);
+	while (rest.length > 0 && isBlankLine(rest[0])) rest.shift();
+	while (rest.length > 0 && isBlankLine(rest.at(-1))) rest.pop();
+	const heading = block.slice(0, size).join("\n");
+	return rest.length === 0 ? heading : `${heading}\n\n${rest.join("\n")}`;
+};
+/**
+* A flat review regrouped: every chunk with answer boxes under `## Findings`
+* and every chunk titled in `walkthrough` under `## Walkthrough`, each in its
+* current order and one heading level deeper. Any other chunk stays a `## ` of
+* its own, before the sections when it came before them, after otherwise. An
+* already sectioned review comes back unchanged.
+*/
+const sectionedReview = (content, walkthrough) => {
+	const tree = parseMarkdown(content);
+	const { chunks, sections } = splitChunks(tree, content);
+	if (sections.length > 0 || chunks.length === 0) return content;
+	const { changesets } = parseReviewDoc(content);
+	const lines = content.split("\n");
+	const sectionOfChunk = (i) => changesets[i].answers !== void 0 ? "findings" : walkthrough.has(changesets[i].title) ? "walkthrough" : void 0;
+	const text = (i, demote) => {
+		const chunk = chunks[i];
+		const block = lines.slice(chunk.headingLine, chunks[i + 1]?.headingLine ?? lines.length);
+		return chunkText(demote ? demoted(chunk, block) : block, demote ? 1 : headingSize(chunk));
+	};
+	const grouped = chunks.map((_, i) => sectionOfChunk(i));
+	const first = grouped.findIndex((g) => g !== void 0);
+	if (first === -1) return content;
+	const others = (keep) => chunks.flatMap((_, i) => grouped[i] === void 0 && keep(i) ? [text(i, false)] : []);
+	const section = (s) => {
+		const members = chunks.flatMap((_, i) => grouped[i] === s ? [text(i, true)] : []);
+		return members.length === 0 ? [] : [`## ${REVIEW_SECTIONS[s]}`, ...members];
+	};
+	return `${[
+		lines.slice(0, chunks[0].headingLine).join("\n").trim(),
+		...others((i) => i < first),
+		...section("findings"),
+		...section("walkthrough"),
+		...others((i) => i > first)
+	].filter((p) => p !== "").join("\n\n")}\n`;
+};
 //#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. */
@@ -16423,4 +16633,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 A, THREAD_REPLY_ACTION_TITLE as C, parseThreadsWithFindings as D, parseThreads as E, getParseCount as O, FOOTNOTE_ACTION_TITLE as S, parseFootnotes as T, reviewRisks as _, unansweredQuestions as a, FREE_TEXT_PLACEHOLDER as b, stripCodeThreads as c, ANSWER_FIX as d, ANSWER_LEAD as f, reviewNotes as g, reviewDecisions as h, steeringFormatOrFreeForm as i, formatFinding as j, headingSectionBodies as k, freeFormFormat as l, reviewChunks 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, severityLine as v, openThreadFindings as w, isAnswered as x, unansweredNotes as y };
+export { parseThreadsWithFindings as A, FREE_TEXT_PLACEHOLDER as C, openThreadFindings as D, THREAD_REPLY_ACTION_TITLE as E, headingSectionBodies as M, headingSections as N, parseFootnotes as O, formatFinding as P, unansweredNotes as S, FOOTNOTE_ACTION_TITLE as T, reviewNotes as _, unansweredQuestions as a, sectionedReview as b, stripCodeThreads as c, ANSWER_FIX as d, ANSWER_LEAD as f, reviewDecisions as g, reviewChunks as h, steeringFormatOrFreeForm as i, getParseCount as j, parseThreads as k, freeFormFormat as l, REVIEW_SECTIONS 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, reviewRisks as v, isAnswered as w, severityLine as x, reviewSections as y };

package/dist/chunks/{tail-CX6Pdsql.mjs → tail-I1-vVq0P.mjs}

@@ -1,6 +1,6 @@
 import { answered, head, judge, mark, numeric, read, refuse, removeScript, run, scope, sectionBodies, showScript, vars, writeScript } from "../flows.mjs";
 import { lensEntriesOf, lensOf, qualityLap, reviewToHandOff } from "../workflow-kit.mjs";
-import { A as reviewMissing, D as fixQuality, M as reviewing, O as fixRisks, Pt as withLapFindings, S as awaitReview, T as fixCheck, X as handOffAwaitReviewMessage, ct as qualityFindingsFile, d as healthy, h as QUALITY, j as reviewQuality, lt as qualityTriageMessage, u as guarded, y as REVIEW } from "./reserved-CUkk9XgL.mjs";
+import { A as reviewMissing, D as fixQuality, M as reviewing, Mt as withLapFindings, O as fixRisks, S as awaitReview, T as fixCheck, ct as qualityTriageMessage, d as healthy, h as QUALITY, j as reviewQuality, q as handOffAwaitReviewMessage, st as qualityFindingsFile, u as guarded, y as REVIEW } from "./reserved-D0MKVFFa.mjs";
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
 	notes: [],