@pmelab/gtd 41.0.0 → 42.0.0

package/src/workflows/shared/text.ts

@@ -90,6 +90,117 @@ What each change does next (then run \`gtd land\`):
 - **Continue** — having undone the sketch by hand, check the test baseline is green and start triage (**start-gate.check**).
 `
 
+export const qualityTriageMessage = (): string =>
+  `Judging each quality finding. Run \`gtd judge answer\` and pipe a
+\`mechanical\`/\`noise\`/\`design\` verdict per finding ID — or land without a
+verdict, which hands every finding to the review as a note.
+`
+
+/** \`.gtd/QUALITY.md\` holding only \`findings\`, one \`## \` chunk each. */
+export const qualityFindingsFile = (
+  findings: readonly { readonly title: string; readonly body: string }[],
+): string =>
+  `# Quality\n\n${findings.map((f) => `## ${f.title}\n\n${f.body}`.trim()).join("\n\n")}\n`
+
+export interface ComposedReview {
+  readonly notes: readonly {
+    readonly title: string
+    readonly body: string
+    readonly unresolved?: true
+    /** A fix turn removed its chunk while renaming another. */
+    readonly unclear?: true
+  }[]
+  readonly fixed: readonly { readonly title: string; readonly commit: string }[]
+  readonly noise: readonly { readonly title: string; readonly p: number }[]
+  /** `Then` lines a `.feature` file at the review base no longer carries. */
+  readonly weakened?: readonly RemovedAssertions[]
+  /** The commit that fixed the human's nits, on the review that follows it. */
+  readonly nitFix?: string | undefined
+}
+
+const SUMMARY_TITLES = [
+  "Weakened scenarios",
+  "Fixed from your notes",
+  "Fixed automatically",
+  "Dropped as noise",
+  "Nothing to note",
+]
+
+// A lens body is pasted as prose: a task box would read as a broken hunk pointer, or a `Risk:` one.
+const unboxed = (body: string): string =>
+  body.replace(/^(\s*(?:>\s*)*(?:[-*+]|\d+[.)])\s+)\[[ xX]\]\s?/gm, "$1")
+
+const short = (hash: string): string => hash.slice(0, 7)
+
+/**
+ * \`.gtd/REVIEW.md\` as gtd writes it: one chunk per note, then the fixed and
+ * noise lists, with no tick boxes. Chunk titles are made unique — notes are
+ * matched to their chunk by title.
+ */
+export const composedReview = (base: string, report: ComposedReview): string => {
+  // Summary titles are taken first, so no note can claim one.
+  const used = new Set(SUMMARY_TITLES)
+  const unique = (title: string): string => {
+    let name = title
+    for (let n = 2; used.has(name); n++) name = `${title} (${n})`
+    used.add(name)
+    return name
+  }
+  const chunk = (title: string, body: string): string => `## ${title}\n\n${body.trim()}`
+  const weakened = (report.weakened ?? []).flatMap(({ path, lines }) =>
+    lines.map((a) => `- ${path} — ${a.scenario} — ${a.line}`),
+  )
+  const chunks = [
+    ...(report.nitFix === undefined
+      ? []
+      : [
+          chunk(
+            "Fixed from your notes",
+            `Your nits were fixed in ${short(report.nitFix)}; the list below is from before.`,
+          ),
+        ]),
+    ...(weakened.length === 0
+      ? []
+      : [
+          chunk(
+            "Weakened scenarios",
+            `These scenarios lost an assertion the review base had:\n\n${weakened.join("\n")}`,
+          ),
+        ]),
+    ...report.notes.map((n) =>
+      chunk(
+        unique(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._",
+      ),
+    ),
+    ...(report.fixed.length === 0
+      ? []
+      : [
+          chunk(
+            "Fixed automatically",
+            report.fixed.map((f) => `- ${f.title} (${short(f.commit)})`).join("\n"),
+          ),
+        ]),
+    ...(report.noise.length === 0
+      ? []
+      : [chunk("Dropped as noise", report.noise.map((f) => `- ${f.title} (p=${f.p})`).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`
+}
+
 export const qualityUnresolvedMessage = (): string =>
   `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
@@ -488,8 +599,10 @@ ${agentConduct}`
 export const buildFixQualityPrompt = (rules?: string): string =>
   `${stateFileRules}
 - Read \`.gtd/QUALITY.md\` — one \`## \` chunk per finding a quality
-  dimension wrote. Merge duplicate findings across dimensions
-  FIRST, then fix every finding in every chunk, blocking or not
+  dimension wrote. Fix every finding in every chunk, blocking or not;
+  where dimensions repeat one, fix the shared cause once
+- Delete each finding's \`## \` chunk once it is resolved; never
+  rename, merge or reword a chunk you leave
 - When findings conflict, missing test signal beats line count —
   a test is never deleted to satisfy a simplification finding
 - Delete \`.gtd/QUALITY.md\` once every finding is resolved
@@ -541,9 +654,9 @@ export const buildQualityReviewingPrompt = (
   behaviour removed — decide that by reasoning, never by running a
   mutation-testing tool. A test that pins a bug is a finding, not
   praise
-- APPEND every finding you have, blocking or not, as a \`## \`
-  chunk to \`.gtd/QUALITY.md\` — never overwrite what an earlier
-  dimension already wrote there
+- APPEND every finding you have, blocking or not, as its own
+  \`## <one-line title>\` chunk to \`.gtd/QUALITY.md\` — one finding per
+  chunk, never overwrite what an earlier dimension already wrote there
 - Write nothing only when this lens found nothing at all — then a
   clean turn IS this dimension's approval
 ${
@@ -563,12 +676,12 @@ export const reviewerSystem = (): string =>
 ${agentConduct}`
 
 export const buildReviewAwaitReviewMessage = (base: string): string =>
-  `\`.gtd/REVIEW.md\` holds the review record for the process — one
-\`- [ ]\` checkbox per reviewable item, grouped into chunks. Tick a box
-(\`- [x]\`) as you review each hunk; ticking only records that you've read
-it, it is not sign-off. Ticks are read-progress only: landing clears
-every box back to \`- [ ]\` on disk and nothing records which hunks
-you read — there is no persisted trail of it.
+  `\`.gtd/REVIEW.md\` holds what the quality lenses left for you: one chunk
+per finding that needs your judgement — it questions a criterion or the
+approach, or the fixer could not resolve it — then, for reference only, what
+was **fixed automatically** (with the fixing commit) and what was **dropped
+as noise**. Nothing there needs an answer; disagreeing with a fix or a drop
+means writing a note of your own.
 
 Review the diff yourself, with whatever tool you like — gtd checks
 nothing out and touches no ref; \`gtd base\` prints this same hash any
@@ -579,8 +692,8 @@ working tree:
 When you've been through the whole diff, run \`gtd land\`:
 
 - **Sign off** — leave no comment — no note in
-  \`.gtd/REVIEW.md\`, no code edit — to close the process,
-  whatever the boxes say. Every turn commit stays on the
+  \`.gtd/REVIEW.md\`, no code edit — to close the process.
+  Every turn commit stays on the
   branch; run \`gtd summary\` afterward for a closing-message
   prompt.
 - **Ask a question** — start a thread (\`- H: <question>\`) on a

package/src/workflows/shared/vars.ts

@@ -23,6 +23,7 @@ export const defaults: Readonly<Record<string, string>> = {
   judgeIdenticalMinP: "0.7",
   reviewNoteActionable: "0.7",
   reviewSeverityMinP: "0.7",
+  qualityTriageMinP: "0.7",
   refactorFlagPattern: "\\bGTD_FLAG_\\w+",
   seamAllow: [...testFileGlobs, ".gtd/**"].join(", "),
   flagMode: "true",

package/dist/chunks/tail-lY1UmJrU.mjs

@@ -1,112 +0,0 @@
-import { read, refuse, removeScript, run, scope, showScript, vars } 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, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, k as reviewing, l as escalation, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-Ch4LLrEj.mjs";
-//#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 { lens, model } = lensOf(entry);
-	return reviewQuality(lens, base, model);
-}, 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)
-});
-/** `.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",
-	base: round
-});
-/** Refuses while a reviewer's notes still await `gtd door fix`. */
-const refusePendingHandOff = () => {
-	if (read(".gtd/REVIEW.orig.md") !== void 0) refuse(`gtd: ${REVIEW_ORIG} is a pending hand-off — run \`gtd door fix\`, or remove ${REVIEW} and ${REVIEW_ORIG}.`);
-};
-function tail(first, second, ...rest) {
-	const form = tailForm(first, second, rest);
-	if (form === void 0) return Promise.reject(/* @__PURE__ */ new Error("tail takes tail(finish, options?) or the deprecated tail(fixFirst, finish, green?, guard?, lenses?, guardRests?, lensBase?, rules?); this call fits neither"));
-	const [finish, options] = form;
-	return runTail(finish, options);
-}
-const isOptionalObject = (value) => value == null || typeof value === "object" && !Array.isArray(value) && typeof value.then !== "function";
-const tailForm = (first, second, rest) => {
-	if (typeof second === "function" && typeof first !== "function") {
-		const [green, guard, lenses, guardRests, lensBase, rules] = rest;
-		return [second, {
-			fixFirst: first,
-			green,
-			guard,
-			lenses,
-			guardRests,
-			lensBase,
-			rules
-		}];
-	}
-	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 guardRests = options.guardRests === void 0 ? true : options.guardRests;
-	const escalations = { rounds: 0 };
-	const fix = () => fixCheck(rules);
-	const repair = async () => {
-		await guarded(fix, guard)();
-		await healthy(fix, {
-			fixesSoFar: 1,
-			escalations,
-			guard,
-			guardRests,
-			rules
-		});
-	};
-	if (options.fixFirst) await repair();
-	else if (!options.green) await healthy(fix, {
-		escalations,
-		guard,
-		guardRests,
-		rules
-	});
-	if (await qualityLap(guard, lenses, lensBase) === "findings") if (await fixQualityFindings(escalations, guard, guardRests, rules)) await healthy(fix, {
-		escalations,
-		guard,
-		guardRests,
-		rules
-	});
-	else await repair();
-	return finish(escalations);
-});
-/**
-* The review and fix workflows' 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, {
-	file: REVIEW,
-	reviewing: guarded((b, carry) => reviewing(b, carry), 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."
-});
-/** The tail the review and fix workflows run: ends at the hand-off review since `base`. */
-const handOffTail = (fixFirst, base, guard) => tail((escalations) => handOffReview(base, escalations, guard), {
-	fixFirst,
-	guard
-});
-//#endregion
-export { refusePendingHandOff as a, isOptionalObject as i, closeReview as n, tail as o, handOffTail as r, REVIEW_ORIG as t };