@pmelab/gtd 44.0.0 → 45.0.0

package/dist/workflows.mjs

@@ -16773,11 +16773,17 @@ const decisionNote = (d, id, text) => ({
 	forced: /^!(\s|$)/.test(text)
 });
 /** One `Gtd-Mark` value per line: a control character would make mark() throw on every replay. */
-const oneLine = (text) => text.replace(/[\s\x00-\x1f\x7f-\x9f\u2028\u2029]+/g, " ").trim() || "untitled";
+const oneLine$1 = (text) => text.replace(/[\s\x00-\x1f\x7f-\x9f\u2028\u2029]+/g, " ").trim() || "untitled";
 /** Tell the policy, and mark each won't-fix on the gate's commit. */
 const record$2 = (p, decisions) => {
 	p.decided?.(decisions);
-	for (const d of decisions) if (d.choice === "wontfix") mark("wontfix", oneLine(d.anchor));
+	for (const d of decisions) if (d.choice === "wontfix") mark("wontfix", oneLine$1(d.anchor));
+};
+const routed = (p, answers) => answers.filter((d) => p.settles?.(d) !== true);
+/** Record the routed answers on the gate's commit, then hand every answer to `learn`. */
+const recordAndLearn = async (p, decisions, answers) => {
+	record$2(p, decisions);
+	if (answers.length > 0 && p.learn !== void 0) await p.learn(answers);
 };
 /**
 * Judge every note, then run each verdict's route: answers, then nit fixes,
@@ -16785,8 +16791,8 @@ const record$2 = (p, decisions) => {
 * unjudged, an own answer is judged like a note, and a won't-fix is dropped
 * with a `Gtd-Mark` on the gate's commit.
 */
-const routeNotes = async (p, notes, r, decisions = []) => {
-	record$2(p, decisions);
+const routeNotes = async (p, notes, r, decisions = [], answers = decisions) => {
+	await recordAndLearn(p, decisions, answers);
 	const of = (c) => decisions.filter((d) => d.choice === c);
 	const fixes = of("fix").map((d, i) => decisionNote(d, `fix-${i + 1}`, d.body));
 	const judged = [...notes, ...of("answer").map((d, i) => decisionNote(d, `answer-${i + 1}`, d.text))];
@@ -16840,9 +16846,8 @@ const settledAfter = (p, collectedAt) => ({
 	folded: collectedAt !== void 0 && read(p.feedback) !== void 0,
 	settled: collectedAt !== void 0 && changesSince(collectedAt).every((c) => !isCodeEdit(p, c)) && !notedSince(p, collectedAt)
 });
-const finishNotes = async (p, before, decisions, reopened, ctx) => {
-	const notes = reviewNotes(before ?? "", read(p.file) ?? "");
-	if (notes.length + decisions.length > 0) return routeNotes(p, notes, ctx, decisions);
+const finishNotes = async (p, notes, answers, reopened, ctx) => {
+	if (notes.length + answers.length > 0) return routeNotes(p, notes, ctx, routed(p, answers), answers);
 	if (reopened) return ctx.unfolded();
 	await ctx.close();
 	return ctx.outcome(await collect(p, p.captures.notes(ctx.round), "notes"));
@@ -16857,6 +16862,7 @@ const decisionsSince = (p, since) => {
 	const after = read(p.file) ?? "";
 	return reviewDecisions(since.get(p.file)?.before ?? after, after);
 };
+const notesSince = (p, since) => reviewNotes(since.get(p.file)?.before ?? "", read(p.file) ?? "");
 const finish = async (p, reviewed, collectedAt) => {
 	const round = head$1();
 	const since = changesSince(reviewed);
@@ -16877,23 +16883,29 @@ const finish = async (p, reviewed, collectedAt) => {
 		settled,
 		folded
 	});
-	const decisions = decisionsSince(p, since);
-	if (settled && !reopened && decisions.length === 0 || edited.length === 0 && !noted) return unfolded();
+	const answers = decisionsSince(p, since);
+	if (settled && !reopened && answers.length === 0 || edited.length === 0 && !noted) return unfolded();
+	const notes = notesSince(p, since);
 	if (edited.length > 0) {
-		record$2(p, decisions);
+		await recordAndLearn(p, routed(p, answers), answers);
 		await close();
 		return outcome(await collect(p, p.captures.edits(round, reopened ? reviewed : void 0), "edits", {
 			notes: [],
 			paths: edited.map((c) => c.path)
 		}));
 	}
-	return finishNotes(p, since.get(p.file)?.before, decisions, reopened, {
+	return finishNotes(p, notes, answers, reopened, {
 		round,
 		close,
 		outcome,
 		unfolded
 	});
 };
+/** A sign-off while something waits on the human writes the review again instead. */
+const unlessPending = (p, result) => "verdict" in result && result.verdict === "signoff" && p.pending?.() === true ? {
+	next: "rereview",
+	carry: void 0
+} : result;
 /** Write the review; if it marks risks, fix them, keep green, and write it again — once, so the re-review's own risks reach the human unfixed. */
 const reviewOnce = async (p, base, carry) => {
 	await p.reviewing(base, carry);
@@ -16919,7 +16931,7 @@ const review$1 = async (base, p) => {
 		for (;;) {
 			collectedAt = await converse(p, base, reviewed, collectedAt);
 			if (collectedAt === "missing") break;
-			const result = await finish(p, reviewed, collectedAt);
+			const result = unlessPending(p, await finish(p, reviewed, collectedAt));
 			if (!("next" in result)) return result;
 			if (result.next === "rereview") {
 				carry = result.carry;
@@ -17072,6 +17084,108 @@ const requireFlag = (workflow, registryPath, name, defaultOn) => {
 	if (entry.defaultOn !== defaultOn) return refuse(defaultOn ? `gtd: ${workflow}: flag "${name}" is not default-on — roll it out first` : `gtd: ${workflow}: flag "${name}" is already default-on`);
 };
 //#endregion
+//#region src/workflows/shared/standards.ts
+const STANDARDS = ".gtd/STANDARDS.md";
+const UNDECIDED = "Undecided";
+const oneLine = (text) => text.replace(/[\s\x00-\x1f\x7f-\x9f\u2028\u2029]+/g, " ").trim();
+const ITEM$1 = /^(?:[-*+]|\d+[.)])\s+(.*)$/;
+const CONTRADICTS = /^\s+[-*+]\s+contradicts:\s*(.*)$/i;
+const wrapped = (item, line) => {
+	const olds = item.olds;
+	if (olds !== void 0 && olds.length > 0) olds[olds.length - 1] += ` ${line.trim()}`;
+	else item.text += ` ${line.trim()}`;
+};
+/** What tells two standards apart: not the emphasis or spacing a formatter may rewrite. */
+const standardKey = (text) => oneLine(text.replace(/[*_`\\]/g, "")).toLowerCase();
+const toStandards = (items) => {
+	const seen = /* @__PURE__ */ new Set();
+	const fresh = (text) => {
+		const key = standardKey(text);
+		if (key === "" || seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	};
+	const decided = items.filter((i) => i.olds === void 0).map((i) => oneLine(i.text));
+	const undecided = items.flatMap((i) => i.olds === void 0 ? [] : [{
+		text: oneLine(i.text),
+		olds: i.olds.map(oneLine).filter((o) => o !== "")
+	}]);
+	return {
+		decided: decided.filter(fresh),
+		undecided: undecided.filter((c) => fresh(c.text))
+	};
+};
+/**
+* Every top-level bullet is one standard, those under `## Undecided` waiting
+* on the human; a hand-edited file may group the rest under any heading.
+*/
+const parseStandards = (text) => {
+	const items = [];
+	let pending = false;
+	let last;
+	for (const line of text.split("\n")) {
+		const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+		const item = ITEM$1.exec(line);
+		const old = CONTRADICTS.exec(line);
+		if (heading !== null) {
+			pending = heading[1].length > 1 && heading[2].trim() === UNDECIDED;
+			last = void 0;
+		} else if (item !== null) {
+			last = pending ? {
+				text: item[1],
+				olds: []
+			} : { text: item[1] };
+			items.push(last);
+		} else if (old !== null && last?.olds !== void 0) last.olds.push(old[1]);
+		else if (/^\s+\S/.test(line) && last !== void 0) wrapped(last, line);
+		else if (line.trim() !== "") last = void 0;
+	}
+	return toStandards(items);
+};
+const renderStandards = ({ decided, undecided }) => {
+	return `${[
+		"# Standards",
+		"Kept from your review answers for every agent turn. One standard per bullet.",
+		...decided.length === 0 ? [] : [decided.map((s) => `- ${s}`).join("\n")],
+		...undecided.length === 0 ? [] : [`## ${UNDECIDED}`, undecided.map((c) => [`- ${c.text}`, ...c.olds.map((o) => `  - contradicts: ${o}`)].join("\n")).join("\n")]
+	].join("\n\n")}\n`;
+};
+const hash$1 = (raw) => {
+	const text = standardKey(raw);
+	let h = 2166136261;
+	for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 16777619);
+	return (h >>> 0).toString(16).padStart(8, "0");
+};
+const CONFLICT_TITLE = /^Standard conflict ([0-9a-f]{8})$/;
+const conflictTitle = (c) => `Standard conflict ${hash$1(c.text)}`;
+const conflictFor = (standards, title) => {
+	const id = CONFLICT_TITLE.exec(title)?.[1];
+	return id === void 0 ? void 0 : standards.undecided.find((c) => hash$1(c.text) === id);
+};
+const isConflictTitle = (title) => CONFLICT_TITLE.test(title);
+const KEEP_NEW = "keep the new one (drop the old)";
+const KEEP_OLD = "keep the old one (discard the new)";
+/** A conflict's chunk body; its three boxes read as fix / won't fix / own answer by position. */
+const conflictBody = (c) => [...c.olds.length === 0 ? [`A standard learned from your answers contradicted ones another answer since replaced in \`${STANDARDS}\`. Keep it, discard it, or reword it.`, `New: ${c.text}`] : [
+	`A standard learned from your answers contradicts ${c.olds.length === 1 ? "one" : "some"} already in \`${STANDARDS}\`. Your own answer replaces both with its wording.`,
+	`New: ${c.text}`,
+	`Old:\n\n${c.olds.map((o) => `- ${o}`).join("\n")}`
+], `${ANSWER_LEAD}\n\n- [ ] ${KEEP_NEW}\n- [ ] ${KEEP_OLD}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`].join("\n\n");
+/** What every agent turn is told while `.gtd/STANDARDS.md` holds decided standards. */
+const standardsBlock = (text) => {
+	const { decided } = parseStandards(text ?? "");
+	if (decided.length === 0) return "";
+	return `## Standards
+
+\`${STANDARDS}\` holds the standards the human set in earlier reviews.
+Follow every one in what you write. Reviewing, never raise a finding a
+standard rules out — a \`Won't fix:\` standard is a finding the human
+rejected, so never raise it or one like it again — and raise breaking a
+standard as a finding.
+
+${decided.map((s) => `- ${s}`).join("\n")}`;
+};
+//#endregion
 //#region src/workflows/shared/vars.ts
 /** The refactor guard's fixed list, and `seamAllow`'s default minus `.gtd/**`. */
 const testFileGlobs = [
@@ -17091,6 +17205,7 @@ const defaults = {
 	reviewNoteActionable: "0.7",
 	reviewSeverityMinP: "0.7",
 	qualityTriageMinP: "0.7",
+	standardMinP: "0.8",
 	refactorFlagPattern: "\\bGTD_FLAG_\\w+",
 	seamAllow: [...testFileGlobs, ".gtd/**"].join(", "),
 	flagMode: "true",
@@ -17350,8 +17465,11 @@ const withSkills = (skills, prompt) => {
 };
 /** An `agent()` step whose prompt opens with the preamble naming its scope's skills, then its restricted file access. */
 const agentWithSkills = (name, prompt, options = {}) => {
-	const access = accessPreamble(accessFor(name, options.file));
-	const body = access === "" ? prompt : `${access}\n\n${prompt}`;
+	const body = [
+		accessPreamble(accessFor(name, options.file)),
+		prompt,
+		standardsBlock(read(STANDARDS))
+	].filter((part) => part !== "").join("\n\n");
 	return agent(name, withSkills(skillsFor(name).join(", "), body), options);
 };
 const unwindFailure = (commit) => `gtd could not unwind ${commit} out of your working tree.`;
@@ -17391,6 +17509,7 @@ const SUMMARY_TITLES = [
 	"Weakened scenarios",
 	"Fixed from your notes",
 	"Fixed automatically",
+	"Standards added",
 	"Dropped as noise",
 	"Nothing to note"
 ];
@@ -17411,6 +17530,8 @@ const composedReview = (base, report) => {
 	};
 	const chunk = (title, body) => `## ${title}\n\n${body.trim()}`;
 	const answerBoxes = `${ANSWER_LEAD}\n\n- [ ] ${ANSWER_FIX}\n- [ ] ${ANSWER_WONT_FIX}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`;
+	const conflicts = (report.standards?.undecided ?? []).map((c) => chunk(unique(conflictTitle(c)), conflictBody(c)));
+	const added = report.standards?.added ?? [];
 	const notes = report.notes.map((n) => ({
 		...n,
 		title: unique(n.title)
@@ -17419,8 +17540,10 @@ const composedReview = (base, report) => {
 	const chunks = [
 		...report.nitFix === void 0 ? [] : [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")}`)],
+		...conflicts,
 		...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"))],
+		...added.length === 0 ? [] : [chunk("Standards added", `Learned from your answers and kept in \`${STANDARDS}\`:\n\n${added.map((s) => `- ${s}`).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.")];
@@ -25619,9 +25742,9 @@ const HashMapProto = {
 		return new HashMapIterator(this, (k, v) => [k, v]);
 	},
 	[symbol$1]() {
-		let hash$1 = hash(HashMapSymbolKey);
-		for (const item of this) hash$1 ^= pipe(hash(item[0]), combine$5(hash(item[1])));
-		return cached(this, hash$1);
+		let hash$2 = hash(HashMapSymbolKey);
+		for (const item of this) hash$2 ^= pipe(hash(item[0]), combine$5(hash(item[1])));
+		return cached(this, hash$2);
 	},
 	[symbol](that) {
 		if (isHashMap(that)) {
@@ -31627,7 +31750,7 @@ const gauge$1 = (count) => new GaugeState(count);
 /** @internal */
 const histogram$2 = (options) => new HistogramState(options.buckets, options.count, options.min, options.max, options.sum);
 /** @internal */
-const summary$2 = (options) => new SummaryState(options.error, options.quantiles, options.count, options.min, options.max, options.sum);
+const summary$3 = (options) => new SummaryState(options.error, options.quantiles, options.count, options.min, options.max, options.sum);
 /** @internal */
 const isCounterState = (u) => hasProperty(u, CounterStateTypeId);
 /**
@@ -31760,7 +31883,7 @@ const histogram$1 = (key) => {
 	});
 };
 /** @internal */
-const summary$1 = (key) => {
+const summary$2 = (key) => {
 	const { error, maxAge, maxSize, quantiles } = key.keyType;
 	const sortedQuantiles = pipe(quantiles, sort(Order$1));
 	const values = allocate(maxSize);
@@ -31795,7 +31918,7 @@ const summary$1 = (key) => {
 		sum = sum + value;
 	};
 	return make$5({
-		get: () => summary$2({
+		get: () => summary$3({
 			error,
 			quantiles: snapshot(Date.now()),
 			count,
@@ -31995,7 +32118,7 @@ var MetricRegistryImpl = class {
 	getSummary(key) {
 		let value = pipe(this.map, get$1(key), getOrUndefined);
 		if (value == null) {
-			const summary = summary$1(key);
+			const summary = summary$2(key);
 			if (!pipe(this.map, has(key))) pipe(this.map, set(key, summary));
 			value = summary;
 		}
@@ -38042,6 +38165,7 @@ const ShippedOptions = Struct({
 	reviewNoteActionable: setting$1,
 	reviewSeverityMinP: setting$1,
 	qualityTriageMinP: setting$1,
+	standardMinP: setting$1,
 	refactorFlagPattern: setting$1,
 	seamAllow: setting$1,
 	sliceMaxCriteria: setting$1,
@@ -38600,6 +38724,158 @@ const design = (base, guard) => scope("design", async () => {
 	} while (await noteGate(REQUIREMENTS, answerProductQuestions));
 });
 //#endregion
+//#region src/workflows/shared/learn.ts
+const SUMMARY_MAX = 200;
+const BANNER = /^_(?:The fixer left this unresolved\.|A fix turn removed this while renaming another finding — check whether it was fixed\.|No detail given\.)_\s*/;
+const summary$1 = (body) => {
+	const text = oneLine(body).replace(BANNER, "");
+	return text.length > SUMMARY_MAX ? `${text.slice(0, SUMMARY_MAX - 1)}…` : text;
+};
+/** The standard a won't-fix or an own answer would make; a fix states none. */
+const candidateOf = (d) => {
+	const anchor = oneLine(d.anchor);
+	if (d.choice === "wontfix") {
+		const why = summary$1(d.body);
+		return [{
+			decision: d,
+			text: `Won't fix: ${anchor}${why === "" ? "" : ` — ${why}`}`
+		}];
+	}
+	if (d.choice === "answer") return [{
+		decision: d,
+		text: `${oneLine(d.text)} (re: ${anchor})`
+	}];
+	return [];
+};
+const without = (list, drop) => {
+	const keys = new Set(drop.map(standardKey));
+	return list.filter((s) => !keys.has(standardKey(s)));
+};
+const adding = (list, text) => list.some((s) => standardKey(s) === standardKey(text)) ? [...list] : [...list, text];
+/**
+* Keep the new one, keep the old one, or replace both with the human's own
+* wording. Another open conflict stops naming a replaced standard: the human
+* never judged it against the replacement, so keeping it must not drop that.
+*/
+const resolve = (standards, d) => {
+	const c = conflictFor(standards, d.anchor);
+	if (c === void 0) return standards;
+	const others = standards.undecided.filter((u) => u !== c);
+	if (d.choice === "wontfix") return {
+		decided: standards.decided,
+		undecided: others
+	};
+	const kept = d.choice === "fix" ? c.text : oneLine(d.text);
+	const undecided = others.map((u) => ({
+		text: u.text,
+		olds: without(u.olds, c.olds)
+	}));
+	return {
+		decided: adding(without(standards.decided, c.olds), kept),
+		undecided
+	};
+};
+const contradicts = (i, id, other) => ({
+	id: `standard-${i}.contradicts-${id}`,
+	primitive: "noul",
+	instructions: `Does the "Standard:" line of evidence "standard-${i}" contradict ${other}?`,
+	criteria: "yes: following one breaks the other. no: both can be followed — they are compatible or unrelated."
+});
+const questionsFor = (i, anchor, decided) => [
+	{
+		id: `standard-${i}`,
+		primitive: "noul",
+		instructions: `Is the human's answer to review note "${anchor}" (evidence "standard-${i}") a reusable standard for this codebase — a rule later changes and reviews should follow — rather than a call about this one note? Its "Standard:" line is the wording gtd would keep.`,
+		criteria: "yes: it states a rule or preference that applies beyond this note. no: it is specific to this note, a one-off call, or unclear."
+	},
+	...decided.map((_, k) => contradicts(i, `${k + 1}`, `kept standard ${k + 1} (evidence "kept-${k + 1}")`)),
+	...Array.from({ length: i - 1 }, (_, j) => contradicts(i, `new-${j + 1}`, `the "Standard:" line of evidence "standard-${j + 1}"`))
+];
+const evidenceOf = (c) => [
+	`Note: ${c.decision.anchor}`,
+	`Reviewer's text: ${c.decision.body}`,
+	`Human's answer: ${c.decision.choice === "wontfix" ? "won't fix" : c.decision.text}`,
+	`Standard: ${c.text}`
+].join("\n");
+/**
+* One judge rest over every candidate. Only a confident `yes` on uncut
+* evidence makes a standard; a contradiction the judge does not confidently
+* rule out goes to the human instead of overwriting what they decided before.
+* A cut kept standard leaves the round unlearned: raise `judgeBudgetBytes`.
+*/
+const judged = async (candidates, decided, minP) => {
+	const { answers, truncated } = await judge("review.standards.judge", {
+		questions: candidates.flatMap((c, i) => questionsFor(i + 1, c.decision.anchor, decided)),
+		evidence: Object.fromEntries([...candidates.map((c, i) => [`standard-${i + 1}`, evidenceOf(c)]), ...decided.map((s, k) => [`kept-${k + 1}`, s])]),
+		message: "Judging whether your answers are standards to keep: run `gtd judge run`, or land without a verdict, which keeps none.",
+		label: "Learning your standards"
+	});
+	const ruledOut = (i, id) => answered(answers[`standard-${i}.contradicts-${id}`], "no", minP);
+	const added = [];
+	const raised = [];
+	candidates.forEach((c, n) => {
+		const i = n + 1;
+		if (truncated.includes(`standard-${i}`)) return;
+		if (decided.some((_, k) => truncated.includes(`kept-${k + 1}`))) return;
+		if (!answered(answers[`standard-${i}`], "yes", minP)) return;
+		const olds = [...decided.filter((_, k) => !ruledOut(i, `${k + 1}`)), ...added.filter((a) => !ruledOut(i, `new-${a.i}`)).map((a) => a.text)];
+		if (olds.length === 0) added.push({
+			i,
+			text: c.text
+		});
+		else raised.push({
+			text: c.text,
+			olds
+		});
+	});
+	return {
+		added: added.map((a) => a.text),
+		raised
+	};
+};
+/**
+* Settles every answer to a standard conflict, then learns standards from
+* the won't-fix ticks and own answers: kept in `.gtd/STANDARDS.md`, a
+* contradicting one as a new conflict note in `.gtd/REVIEW.md`.
+*/
+const learnStandards = async (decisions) => {
+	const before = parseStandards(read(".gtd/STANDARDS.md") ?? "");
+	const rest = decisions.filter((d) => !isConflictTitle(d.anchor));
+	const settled = decisions.filter((d) => isConflictTitle(d.anchor)).reduce(resolve, before);
+	const known = new Set([...settled.decided, ...settled.undecided.map((c) => c.text)].map(standardKey));
+	const candidates = rest.flatMap(candidateOf).filter((c) => {
+		const key = standardKey(c.text);
+		if (known.has(key)) return false;
+		known.add(key);
+		return true;
+	});
+	const minP = numeric(vars.standardMinP, Infinity);
+	const { added, raised } = candidates.length === 0 || !Number.isFinite(minP) ? {
+		added: [],
+		raised: []
+	} : await judged(candidates, settled.decided, minP);
+	const after = {
+		decided: [...settled.decided, ...added],
+		undecided: [...settled.undecided, ...raised]
+	};
+	if (renderStandards(after) !== renderStandards(before)) await run("review.standards.recording", writeScript(STANDARDS, renderStandards(after)), { label: "Recording your standards" });
+	if (raised.length > 0) {
+		const chunks = raised.map((c) => `## ${conflictTitle(c)}\n\n${conflictBody(c)}`);
+		await run("review.standards.raising", writeScript(REVIEW, `${(read(".gtd/REVIEW.md") ?? "").trimEnd()}\n\n${chunks.join("\n\n")}\n`), {
+			label: "Asking about a contradicting standard",
+			file: REVIEW
+		});
+	}
+};
+const settlesStandard = (d) => isConflictTitle(d.anchor);
+const standardsPending = () => parseStandards(read(".gtd/STANDARDS.md") ?? "").undecided.length > 0;
+const standardsAddedSince = (base) => {
+	const change = changesSince(base).get(STANDARDS);
+	if (change === void 0) return [];
+	const was = new Set(parseStandards(change.before ?? "").decided);
+	return parseStandards(change.after ?? "").decided.filter((s) => !was.has(s));
+};
+//#endregion
 //#region src/workflows/shared/review.ts
 const VERDICTS = [
 	"edit",
@@ -38730,7 +39006,11 @@ const composing = (base, report, carry, nitFix, answered = /* @__PURE__ */ new S
 	...report,
 	weakened: removedAssertions(changesSince(base)),
 	nitFix,
-	answered
+	answered,
+	standards: {
+		added: standardsAddedSince(base),
+		undecided: parseStandards(read(".gtd/STANDARDS.md") ?? "").undecided
+	}
 }), [QUALITY]) : showScript(carry, REVIEW, REVIEW), {
 	label: "Composing the review",
 	file: REVIEW,
@@ -38775,6 +39055,9 @@ const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 		collecting: feedback.collecting,
 		triage: triage$1(severities),
 		decided: (decisions) => decisions.forEach((d) => answered.add(d.anchor)),
+		settles: settlesStandard,
+		learn: learnStandards,
+		pending: standardsPending,
 		answerQuestions: answerReviewQuestions,
 		fixNits: async (notes) => {
 			await guarded((n) => fixNits(n, fixAccess, rules), guard)(notes);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "44.0.0",
+  "version": "45.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/workflow-kit/review.test.ts

@@ -199,8 +199,12 @@ const driveRound = async (
     /** Nothing but thread edits lands after the in-gate collecting turn. */
     settled?: boolean
     noDropped?: boolean
+    learn?: ReviewPolicy["learn"]
+    settles?: ReviewPolicy["settles"]
+    pending?: () => boolean
   } = {},
 ) => {
+  let reviews = 0
   const triaged: string[][] = []
   const captured: string[] = []
   const editRanges: (string | undefined)[] = []
@@ -211,9 +215,15 @@ const driveRound = async (
     file: "r.md",
     feedback: "f.md",
     isCode: (path: string) => path.endsWith(".ts"),
-    reviewing: async () => void (state.files["r.md"] = before),
+    reviewing: async () => {
+      reviews++
+      state.files["r.md"] = before
+    },
     fixRisks: async () => {},
     keepGreen: async () => {},
+    learn: opts.learn,
+    settles: opts.settles,
+    pending: opts.pending,
     awaitReview: async () => {
       awaits++
       if (awaits > 2 || (awaits > 1 && opts.inGate === undefined)) throw new Error("stop")
@@ -270,7 +280,7 @@ const driveRound = async (
     },
   } as unknown as ReviewPolicy
   const result = await review("base", p).catch((e: Error) => e)
-  return { result, triaged, dropped, captured, rounds, editRanges }
+  return { result, triaged, dropped, captured, rounds, editRanges, reviews }
 }
 
 describe("a one-shot footnote is a note, a thread footnote is not", () => {
@@ -561,6 +571,74 @@ describe("a note's answer boxes", () => {
   })
 })
 
+describe("learning from the answers", () => {
+  const boxes = (wont: string, own = "_your answer_"): string =>
+    doc(
+      POINTER,
+      "",
+      "## Rounding",
+      "",
+      "Should subtract round?",
+      "",
+      "Tick exactly one:",
+      "",
+      "- [ ] fix as suggested",
+      `- [${wont}] won't fix`,
+      `- [${own === "_your answer_" ? " " : "x"}] ${own}`,
+    )
+
+  it("learn reads every answer once it is marked, before any is routed", async () => {
+    const seen: ReviewDecision[][] = []
+    let marked: string[] = []
+    const r = await driveRound(boxes(" "), boxes("x"), {
+      learn: async (ds) => {
+        seen.push([...ds])
+        marked = [...state.marks]
+      },
+    })
+    expect(seen).toEqual([[expect.objectContaining({ anchor: "Rounding", choice: "wontfix" })]])
+    expect(marked).toEqual(["wontfix=Rounding"])
+    expect(r.result).toEqual({ verdict: "signoff" })
+  })
+
+  it("an answer the policy settles is learned from, never marked, routed or collected", async () => {
+    const seen: ReviewDecision[][] = []
+    const r = await driveRound(boxes(" "), boxes("x"), {
+      settles: () => true,
+      learn: async (ds) => void seen.push([...ds]),
+    })
+    expect(seen).toHaveLength(1)
+    expect(state.marks).toEqual([])
+    expect(r.triaged).toEqual([])
+    expect(r.rounds).toEqual([])
+    expect(r.result).toEqual({ verdict: "signoff" })
+  })
+
+  it("a hand-edit round learns from its answers too", async () => {
+    const seen: ReviewDecision[][] = []
+    await driveRound(boxes(" "), boxes("x"), {
+      handEdit: true,
+      learn: async (ds) => void seen.push([...ds]),
+    })
+    expect(seen).toHaveLength(1)
+  })
+
+  it("learn is not asked when no note was answered", async () => {
+    let asked = false
+    await driveRound(boxes(" "), `${boxes(" ")}\n\nstray prose`, {
+      silent: true,
+      learn: async () => void (asked = true),
+    })
+    expect(asked).toBe(false)
+  })
+
+  it("a sign-off while something is pending writes the review again", async () => {
+    const r = await driveRound(boxes(" "), boxes("x"), { pending: () => true })
+    expect(r.reviews).toBe(2)
+    expect((r.result as Error).message).toBe("stop")
+  })
+})
+
 describe("deleted answer boxes", () => {
   it("are refused even when a reply turn landed them", async () => {
     const withBoxes = doc(