@pmelab/gtd 41.0.0 → 43.0.0

package/src/workflows/shared/text.ts

@@ -12,6 +12,12 @@ import {
   type JudgeQuestion,
   type SummaryContext,
 } from "../../flows/index.js"
+import {
+  ANSWER_FIX,
+  ANSWER_LEAD,
+  ANSWER_WONT_FIX,
+  FREE_TEXT_PLACEHOLDER,
+} from "../../steering/index.js"
 import { escapeRegExp } from "./registry.js"
 import { defaultFlagRegistry } from "./vars.js"
 import type { CollectRound, RemovedAssertions, Requested } from "../../workflow-kit/index.js"
@@ -90,6 +96,126 @@ 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
+  /** Titles of notes the human already answered, left out. */
+  readonly answered?: ReadonlySet<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, each ending in its
+ * answer boxes, then the fixed and noise lists. Chunk titles are made unique —
+ * notes and answers 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()}`
+  // The lead-in line keeps a body that ends in a list from absorbing the boxes.
+  const answerBoxes = `${ANSWER_LEAD}\n\n- [ ] ${ANSWER_FIX}\n- [ ] ${ANSWER_WONT_FIX}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`
+  const notes = report.notes
+    .map((n) => ({ ...n, title: unique(n.title) }))
+    .filter((n) => report.answered?.has(n.title) !== true)
+  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 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")}`,
+          ),
+        ]),
+    ...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}`,
+      ),
+    ),
+    ...(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
@@ -177,10 +303,6 @@ ${stateFileRules}
 ${footnoteFoldIn}${codeThreadReplies()}
 - The only state file this turn touches is \`.gtd/REQUIREMENTS.md\`
   — no other files for notes or output
-- Lines of a \`## Deferred review notes\` section of \`.gtd/TODO.md\`
-  that the start diff does not touch are parked by review, never folded;
-  the human's edits to such a line (or its removal) are input like any
-  other part of the start diff
 - \`.gtd/TODO.md\` is the likely home of the sketch that started
   this process — the human's input, folded into the concerns
   below like any other part of the start diff; never a state
@@ -488,8 +610,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 +665,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 +687,16 @@ 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**. Each finding chunk ends in three boxes — tick exactly one:
+\`fix as suggested\` (fixed in the nit batch below), \`won't fix\` (dropped,
+recorded in the commit), or write your own answer over \`_your answer_\` and
+tick it (judged like a note). Every landing here is refused until each
+finding holds exactly one tick. The fixed and noise lists need no 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
@@ -578,9 +706,9 @@ working tree:
     git diff ${base}
 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
+- **Sign off** — answer every finding, leave no other comment — no note
+  in \`.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
@@ -781,34 +909,6 @@ const wrapItem = (item: string): string[] => {
   return [...out, line]
 }
 
-/** Appends one section of `notes` to `.gtd/TODO.md`, wrapped the way oxfmt writes it; an existing file is only ever appended to. */
-export const deferNotesScript = (notes: readonly NoteInput[], round: string): string => {
-  const lines = [
-    `## Deferred review notes (${round.slice(0, 7)})`,
-    "",
-    ...notes.flatMap((n) => wrapItem(`- ${noteHead(n)}: ${n.text.replace(/\s+/g, " ")}`)),
-  ]
-  return `mkdir -p .gtd
-if [ -s .gtd/TODO.md ]; then
-  [ -z "$(tail -c1 .gtd/TODO.md)" ] || printf '\\n' >> .gtd/TODO.md
-  printf '\\n' >> .gtd/TODO.md
-fi
-printf '%s\\n' ${lines.map(quote).join(" ")} >> .gtd/TODO.md
-`
-}
-
-/** The gate right after a deferral: landing clean signs off without these notes. */
-export const buildReviewAwaitAfterDeferMessage = (
-  base: string,
-  deferred: readonly NoteInput[],
-): string =>
-  `${buildReviewAwaitReviewMessage(base)}
-Deferred to \`.gtd/TODO.md\` just now, NOT acted on in this process — landing
-clean signs off without them:
-
-${deferred.map((n) => `- ${noteHead(n)}: ${n.text.replace(/\s*\n\s*/g, " ")}`).join("\n")}
-`
-
 export const buildReviewTriageMessage = (): string =>
   `Judging each note the human added to \`.gtd/REVIEW.md\` (a line note, a
 footnote, or prose under a chunk) with one verdict: \`edit\` (a change
@@ -819,12 +919,14 @@ default; a skipped judgment never dismisses a note).
 
 Also judge each note's severity, one id per note: \`note-<n>.security\`,
 \`note-<n>.reversibility\`, \`note-<n>.blastRadius\` and
-\`note-<n>.newConcept\`.
+\`note-<n>.newConcept\`. An own answer under a finding's boxes is judged
+the same way, keyed \`answer-<n>\`.
 `
 const closedFold = (round: CollectRound, target: string): string =>
   round === "edits"
     ? `- Fold every hand-edit and every note the human left that round into
-  \`${target}\`
+  \`${target}\` — a note ticked \`fix as suggested\` or answered in its
+  own words included; one ticked \`won't fix\` is dropped
 `
     : round === "notes"
       ? `- Fold each note that asks for a change into \`${target}\`
@@ -841,6 +943,7 @@ export const buildReviewCollectingPrompt = (
     /** `"reply"` is the in-gate reply turn; any other round is closed and folds what that round left. */
     readonly round: CollectRound
   },
+  round?: CollectRound,
 ): string => {
   const target = refactor ? ".gtd/REFACTOR.md" : ".gtd/REQUIREMENTS.md"
   const fence = refactor
@@ -925,12 +1028,20 @@ ${closedFold(refactor.round, target)}`
     : `- This turn writes \`${target}\` (the folded concerns) and
   replies inside \`.gtd/REVIEW.md\` (thread replies only; the file stays
   in the tree) — you classify, you do not build
-- Fold every concluded thread, ticked answer and hand-edit — and each
-  \`edit\` note the capture lists, no other note — into
-  \`${target}\` and delete the folded threads from
-  \`.gtd/REVIEW.md\`; append one \`- A:\` reply to each thread
-  whose last entry is a \`- H:\` question
+- Fold every concluded thread and hand-edit — and each \`edit\` note
+  the capture lists, no other note — into \`${target}\` and
+  delete the folded threads from \`.gtd/REVIEW.md\`; append one \`- A:\`
+  reply to each thread whose last entry is a \`- H:\` question
+${
+  round === "edits"
+    ? `- A hand-edit round routes no answer box itself: fold each note
+  ticked \`fix as suggested\` or answered in its own words, too; drop one
+  ticked \`won't fix\`
+`
+    : `- Never fold a note's ticked answer box the capture does not list: gtd
+  routes those itself
 `
+}`
 }- When the capture names an answering commit, carry each answered
   question into \`${target}\`'s \`## Answered Questions\` as
   \`### <the note>\` plus its answer — the lap replaces \`.gtd/REVIEW.md\`

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 };