@pmelab/gtd 43.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);
@@ -16909,7 +16921,7 @@ const reviewOnce = async (p, base, carry) => {
 * another lap, questions are answered in place, nits fixed in one batch,
 * praise dropped.
 */
-const review$2 = async (base, p) => {
+const review$1 = async (base, p) => {
 	let carry;
 	for (;;) {
 		await reviewOnce(p, base, carry);
@@ -16919,7 +16931,7 @@ const review$2 = 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.")];
@@ -17937,6 +18060,15 @@ ${notes.length === 0 ? "(none)\n" : notesCapture(notes)}
 The reviewer's risks are:
 
 ${risks.length === 0 ? "(none)\n" : notesCapture(risks)}`;
+const reviewFeedbackFixPrompt = () => `${stateFileRules}
+- Read \`.gtd/REQUIREMENTS.md\` — the concerns the human's review asked for,
+  one \`## \` heading each, in build order
+- Build every concern in this one turn; an answered question is context,
+  not a concern
+- Where a change is behavioural, add a test that fails without it
+- Leave \`.gtd/REQUIREMENTS.md\` untouched — the next step removes it
+- Leave everything uncommitted and finish your turn
+`;
 const buildReviewReviewMissingMessage = (commit) => `The review round committed no \`.gtd/REVIEW.md\` (at ${commit}), so there is
 nothing to sign off on.
 
@@ -18565,6 +18697,36 @@ const awaitReview = (base, message = buildReviewAwaitReviewMessage(base)) => hum
 	base,
 	acceptClean: true
 });
+/** Answer every `question` note inline in `.gtd/REVIEW.md`. */
+const answerReviewQuestions = (notes) => agentWithSkills("review.answer-review-questions", buildReviewAnswerQuestionsPrompt(notes), {
+	label: "Answering your questions",
+	file: REVIEW,
+	mode: "review",
+	model: planner(),
+	system: reviewerSystem()
+});
+/** Fix every `nit` note in one turn. */
+const fixNits = (notes, access, rules) => {
+	const fixing = (name) => agentWithSkills(name, buildReviewFixNitsPrompt(notes, rules), {
+		label: "Fixing your nits",
+		file: REVIEW,
+		model: planner(),
+		system: reviewerSystem()
+	});
+	return access === void 0 ? fixing("review.fix.nits.fixing") : scope({
+		name: "review.fix.nits",
+		access
+	}, () => fixing("fixing"));
+};
+/** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
+const collecting = (capture, round) => agentWithSkills("review.collecting", buildReviewCollectingPrompt(capture, void 0, round), {
+	label: "Collecting your feedback",
+	file: REQUIREMENTS,
+	mode: "qa",
+	model: planner(),
+	system: reviewerSystem(),
+	allowEmpty: true
+});
 /** The round at commit `round` left no `.gtd/REVIEW.md`. */
 const reviewMissing = (round) => human("review.review-missing", {
 	message: buildReviewReviewMissingMessage(round),
@@ -25580,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)) {
@@ -31588,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);
 /**
@@ -31721,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);
@@ -31756,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,
@@ -31956,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;
 		}
@@ -38003,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,
@@ -38282,7 +38445,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.
 */
@@ -38302,7 +38465,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
@@ -38524,36 +38687,6 @@ const answerProductQuestions = () => human("gate.answer", {
 	mode: "qa",
 	acceptClean: true
 });
-/** Answer every `question` note inline in `.gtd/REVIEW.md`. */
-const answerReviewQuestions = (notes) => agentWithSkills("review.answer-review-questions", buildReviewAnswerQuestionsPrompt(notes), {
-	label: "Answering your questions",
-	file: REVIEW,
-	mode: "review",
-	model: planner(),
-	system: reviewerSystem()
-});
-/** Fix every `nit` note in one turn. */
-const fixNits = (notes, access, rules) => {
-	const fixing = (name) => agentWithSkills(name, buildReviewFixNitsPrompt(notes, rules), {
-		label: "Fixing your nits",
-		file: REVIEW,
-		model: planner(),
-		system: reviewerSystem()
-	});
-	return access === void 0 ? fixing("review.fix.nits.fixing") : scope({
-		name: "review.fix.nits",
-		access
-	}, () => fixing("fixing"));
-};
-/** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
-const collecting = (capture, round) => agentWithSkills("review.collecting", buildReviewCollectingPrompt(capture, void 0, round), {
-	label: "Collecting your feedback",
-	file: REQUIREMENTS,
-	mode: "qa",
-	model: planner(),
-	system: reviewerSystem(),
-	allowEmpty: true
-});
 /** Turn the refactor review round `capture` describes into `.gtd/REFACTOR.md`, or change nothing. */
 const refactorCollecting = (capture, round, strays) => agentWithSkills("review.collecting", buildReviewCollectingPrompt(capture, {
 	strays,
@@ -38591,7 +38724,159 @@ const design = (base, guard) => scope("design", async () => {
 	} while (await noteGate(REQUIREMENTS, answerProductQuestions));
 });
 //#endregion
-//#region src/workflows/feature/review.ts
+//#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",
 	"question",
@@ -38721,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,
@@ -38731,10 +39020,11 @@ const composing = (base, report, carry, nitFix, answered = /* @__PURE__ */ new S
 * 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 go to another planning lap, questions
-* are answered in place, nits fixed in one batch, praise dropped.
+* 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 review$1 = (base, escalations = { rounds: 0 }, options = {}) => {
+const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 	const { guard, guardRests, fixAccess, rules } = options;
 	const feedback = options.feedback ?? {
 		file: ".gtd/REQUIREMENTS.md",
@@ -38744,7 +39034,7 @@ const review$1 = (base, escalations = { rounds: 0 }, options = {}) => {
 	const severities = /* @__PURE__ */ new Map();
 	let nitFix;
 	const answered = /* @__PURE__ */ new Set();
-	return review$2(base, {
+	return review$1(base, {
 		file: REVIEW,
 		feedback: feedback.file,
 		isCode: isCode$1,
@@ -38765,6 +39055,9 @@ const review$1 = (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);
@@ -38797,7 +39090,7 @@ 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) => review$1(base, escalations, {
+	return tail((escalations, report) => humanReview(base, escalations, {
 		...form,
 		report
 	}), {
@@ -39750,7 +40043,7 @@ const settleQuality = async () => {
 	if (rested) await healthy(() => fixCheck());
 };
 /** The triaged quality lap, then the human review since `base`. */
-const reviewedTail = (base, lensBase) => tail((escalations, report) => review$1(base, escalations, { report }), {
+const reviewedTail = (base, lensBase) => tail((escalations, report) => humanReview(base, escalations, { report }), {
 	green: true,
 	lensBase,
 	triage: true
@@ -39829,6 +40122,7 @@ const skills = (vars) => {
 	return {
 		design: ["spec-driven-development", "planning-and-task-breakdown"],
 		notes: ["incremental-implementation", "code-simplification"],
+		feedback: ["test-driven-development", "incremental-implementation"],
 		...build,
 		...Object.fromEntries(Object.entries(build).map(([name, list]) => [`refactor.${name}`, list])),
 		refactor: ["ponytail"],
@@ -39862,15 +40156,34 @@ const steering = {
 };
 //#endregion
 //#region src/workflows/review/review.ts
+/** Build the concerns a review round collected into `.gtd/REQUIREMENTS.md`, then remove it. */
+const fixFeedback = async () => {
+	await agentWithSkills("feedback.fixing", reviewFeedbackFixPrompt(), {
+		label: "Fixing your review feedback",
+		file: REQUIREMENTS,
+		model: coder(),
+		system: finisherSystem(),
+		allowEmpty: true
+	});
+	await run("feedback.closing", removeScript([REQUIREMENTS]), { label: "Closing the feedback" });
+};
 /**
-* Pure review of everything since `reviewBase`: a green gate, the quality
-* lap, then the human review. A note ends the process with `.gtd/REVIEW.md`
-* left for `fix`; it never re-plans.
+* The feature's review of everything since `reviewBase` — a green gate, the
+* triaged quality lap, then the human review — with no design phase: a
+* review that asks for changes is fixed in place and reviewed again, until
+* sign-off.
 */
 const reviewFlow = async () => {
 	refusePendingHandOff();
+	if (read(".gtd/REQUIREMENTS.md") !== void 0) refuse(`gtd: ${REQUIREMENTS} is left over — finish or remove it before a review.`);
 	await gate("review-gate", reviewGateBlockedMessage());
-	await handOffTail(false, start());
+	const base = start();
+	let outcome = await buildTail(base, { green: true });
+	while (outcome.verdict === "feedback") {
+		await reUnwind(outcome);
+		await fixFeedback();
+		outcome = await buildTail(base, { lensBase: outcome.base });
+	}
 };
 const review = shipped(reviewFlow, { review: {
 	args: [{