@pmelab/gtd 44.0.0 → 45.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "44.0.0",
+  "version": "45.0.0",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -564,6 +564,22 @@ noted in steps 3 and 4 below.
    `gtd judge answer` / conservative-default shape as step 3's own judged
    points.
 
+   **The review learns your taste.** Each won't-fix and each own answer is a
+   candidate standard. A judge (`build.review.standards.judge`) asks whether it
+   is reusable beyond this note; at `standardMinP` (`0.8`) or above it is kept
+   in `.gtd/STANDARDS.md` with no question asked, and the next review lists it
+   under `## Standards added`. Every later agent turn — the lenses, the naive
+   pass, the build, every fix — is handed the kept standards, so a finding you
+   rejected once is not raised again and a rule you wrote is followed, in this
+   process and every later one. One the judge does not confidently rule out
+   contradicting a standard already kept is not applied: it waits under
+   `## Undecided` and becomes a `## Standard conflict <id>` note in the review,
+   with its own three boxes — **keep the new one (drop the old)**, **keep the
+   old one (discard the new)**, or **your own wording**, which replaces both —
+   and the review does not sign off until it is answered. `.gtd/STANDARDS.md` is
+   committed and yours to edit; gtd rewrites it as one bullet per standard when
+   it learns.
+
 You never talk to it. Every exchange is a file in `.gtd/` that you edit in your
 own editor, and every answer you give is a commit. Your test suite is the gate
 throughout: a red baseline stops the process before it starts, and a red build

package/dist/chunks/{reserved-DJk_6-ju.mjs → reserved-ty1mtlnS.mjs}

@@ -113,6 +113,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 = /^(?:[-*+]|\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.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 = (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(c.text)}`;
+const conflictFor = (standards, title) => {
+	const id = CONFLICT_TITLE.exec(title)?.[1];
+	return id === void 0 ? void 0 : standards.undecided.find((c) => hash(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 = [
@@ -132,6 +234,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",
@@ -391,8 +494,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.`;
@@ -432,6 +538,7 @@ const SUMMARY_TITLES = [
 	"Weakened scenarios",
 	"Fixed from your notes",
 	"Fixed automatically",
+	"Standards added",
 	"Dropped as noise",
 	"Nothing to note"
 ];
@@ -452,6 +559,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)
@@ -460,8 +569,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.")];
@@ -1765,6 +1876,7 @@ const ShippedOptions = Struct({
 	reviewNoteActionable: setting,
 	reviewSeverityMinP: setting,
 	qualityTriageMinP: setting,
+	standardMinP: setting,
 	refactorFlagPattern: setting,
 	seamAllow: setting,
 	sliceMaxCriteria: setting,
@@ -1874,4 +1986,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { naiveApplyFailure as $, reviewMissing as A, registryEntry as At, coverageMessage as B, coder as C, unwindFailure as Ct, fixQuality as D, flagMentions as Dt, fixNits as E, testFileGlobs as Et, buildReviewTriageMessage as F, designSystem as G, coveringPrompt as H, builderSystem as I, fixReviewNotesPrompt as J, designTriagePrompt as K, clearCriteriaMessage as L, reviewing as M, agentWithSkills as N, fixRisks as O, flagReferences as Ot, buildReviewCollectingPrompt as P, implementFixPrompt as Q, clearCriteriaQuestion as R, awaitReview as S, unwindFailedMessage as St, fixCheck as T, envDefaults as Tt, criterionLine as U, coverageQuestion as V, designGateAnswerMessage as W, idleMessage as X, handOffAwaitReviewMessage as Y, implementBuildingPrompt as Z, REFACTOR_NOTE as _, seamByHandMessage as _t, flagModeOn as a, qualityUnresolvedMessage as at, SLICES as b, startGateBlockedMessage as bt, baseline as c, refactorFixPrompt as ct, guarded as d, reviewEditNotesCapture as dt, naivePassPrompt as et, healthy as f, reviewEditsCapture as ft, REFACTOR as g, reviewerSystem as gt, QUALITY as h, reviewNotesCapture as ht, skills as i, qualityTriageMessage as it, reviewQuality as j, requireFlag as jt, planner as k, flipProblems as kt, escalation as l, refactorNotePrompt as lt, HANDOFF as m, reviewGateBlockedMessage as mt, summary as n, oversizedMessage as nt, flagShipped as o, refactorBuildingPrompt as ot, FEEDBACK as p, reviewFeedbackFixPrompt as pt, finisherSystem as q, access as r, qualityFindingsFile as rt, shipped as s, refactorDroppedRefusal as st, steering as t, normaliseCriteriaScript as tt, gate as u, refactorRules as ut, REQUIREMENTS as v, seamSteerMessage as vt, collecting as w, defaults as wt, answerReviewQuestions as x, uncoveredMessage as xt, REVIEW as y, slicingPrompt as yt, composedReview as z };
+export { naiveApplyFailure as $, reviewMissing as A, conflictTitle as At, coverageMessage as B, requireFlag as Bt, coder as C, unwindFailure as Ct, fixQuality as D, STANDARDS as Dt, fixNits as E, testFileGlobs as Et, buildReviewTriageMessage as F, standardKey as Ft, designSystem as G, coveringPrompt as H, builderSystem as I, flagMentions as It, fixReviewNotesPrompt as J, designTriagePrompt as K, clearCriteriaMessage as L, flagReferences as Lt, reviewing as M, oneLine as Mt, agentWithSkills as N, parseStandards as Nt, fixRisks as O, conflictBody as Ot, buildReviewCollectingPrompt as P, renderStandards as Pt, implementFixPrompt as Q, clearCriteriaQuestion as R, flipProblems as Rt, awaitReview as S, unwindFailedMessage as St, fixCheck as T, envDefaults as Tt, criterionLine as U, coverageQuestion as V, designGateAnswerMessage as W, idleMessage as X, handOffAwaitReviewMessage as Y, implementBuildingPrompt as Z, REFACTOR_NOTE as _, seamByHandMessage as _t, flagModeOn as a, qualityUnresolvedMessage as at, SLICES as b, startGateBlockedMessage as bt, baseline as c, refactorFixPrompt as ct, guarded as d, reviewEditNotesCapture as dt, naivePassPrompt as et, healthy as f, reviewEditsCapture as ft, REFACTOR as g, reviewerSystem as gt, QUALITY as h, reviewNotesCapture as ht, skills as i, qualityTriageMessage as it, reviewQuality as j, isConflictTitle as jt, planner as k, conflictFor as kt, escalation as l, refactorNotePrompt as lt, HANDOFF as m, reviewGateBlockedMessage as mt, summary as n, oversizedMessage as nt, flagShipped as o, refactorBuildingPrompt as ot, FEEDBACK as p, reviewFeedbackFixPrompt as pt, finisherSystem as q, access as r, qualityFindingsFile as rt, shipped as s, refactorDroppedRefusal as st, steering as t, normaliseCriteriaScript as tt, gate as u, refactorRules as ut, REQUIREMENTS as v, seamSteerMessage as vt, collecting as w, defaults as wt, answerReviewQuestions as x, uncoveredMessage as xt, REVIEW as y, slicingPrompt as yt, composedReview as z, registryEntry as zt };

package/dist/chunks/{review-X7Jfz0dY.mjs → review-BmoH-9im.mjs}

@@ -1,7 +1,159 @@
-import { answered, changesSince, head, judge, numeric, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
+import { answered, changesSince, head, judge, numeric, read, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
 import { removedAssertions, review } from "../workflow-kit.mjs";
-import { A as reviewMissing, E as fixNits, F as buildReviewTriageMessage, O as fixRisks, S as awaitReview, T as fixCheck, d as guarded, dt as reviewEditNotesCapture, f as healthy, ft as reviewEditsCapture, h as QUALITY, ht as reviewNotesCapture, w as collecting, x as answerReviewQuestions, y as REVIEW, z as composedReview } from "./reserved-DJk_6-ju.mjs";
-import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-5w5mxGTq.mjs";
+import { A as reviewMissing, At as conflictTitle, Dt as STANDARDS, E as fixNits, F as buildReviewTriageMessage, Ft as standardKey, Mt as oneLine, Nt as parseStandards, O as fixRisks, Ot as conflictBody, Pt as renderStandards, S as awaitReview, T as fixCheck, d as guarded, dt as reviewEditNotesCapture, f as healthy, ft as reviewEditsCapture, h as QUALITY, ht as reviewNotesCapture, jt as isConflictTitle, kt as conflictFor, w as collecting, x as answerReviewQuestions, y as REVIEW, z as composedReview } from "./reserved-ty1mtlnS.mjs";
+import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-CM3sVoAb.mjs";
+//#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 = (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(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",
@@ -132,7 +284,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,
@@ -177,6 +333,9 @@ const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 		collecting: feedback.collecting,
 		triage: triage(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/dist/chunks/{tail-5w5mxGTq.mjs → tail-CM3sVoAb.mjs}

@@ -1,6 +1,6 @@
 import { answered, head, judge, mark, numeric, read, refuse, removeScript, run, scope, sectionBodies, showScript, vars, writeScript } from "../flows.mjs";
 import { fixFindings, lensEntriesOf, lensOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
-import { A as reviewMissing, D as fixQuality, M as reviewing, O as fixRisks, S as awaitReview, T as fixCheck, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, it as qualityTriageMessage, j as reviewQuality, l as escalation, rt as qualityFindingsFile, y as REVIEW } from "./reserved-DJk_6-ju.mjs";
+import { A as reviewMissing, D as fixQuality, M as reviewing, O as fixRisks, S as awaitReview, T as fixCheck, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, it as qualityTriageMessage, j as reviewQuality, l as escalation, rt as qualityFindingsFile, y as REVIEW } from "./reserved-ty1mtlnS.mjs";
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
 	notes: [],

package/dist/workflow-kit.mjs

@@ -233,14 +233,20 @@ const record = (p, decisions) => {
 	p.decided?.(decisions);
 	for (const d of decisions) if (d.choice === "wontfix") mark("wontfix", oneLine(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(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,
 * then the edits' lap. Of the human's `decisions`, a fix joins the nit batch
 * 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(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))];
@@ -294,9 +300,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"));
@@ -311,6 +316,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();
 	const since = changesSince(reviewed);
@@ -331,23 +337,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(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);
@@ -373,7 +385,7 @@ const review = 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;

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { At as registryEntry, C as coder, Ot as flagReferences, Tt as envDefaults, i as skills, jt as requireFlag, n as summary, o as flagShipped, r as access, t as steering, wt as defaults } from "../chunks/reserved-DJk_6-ju.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-5w5mxGTq.mjs";
+import { Bt as requireFlag, C as coder, Lt as flagReferences, Tt as envDefaults, i as skills, n as summary, o as flagShipped, r as access, t as steering, wt as defaults, zt as registryEntry } from "../chunks/reserved-ty1mtlnS.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-CM3sVoAb.mjs";
 //#region src/workflows/cleanup/cleanup.ts
 const removingPrompt = (name, registry) => `Clean up the release flag "${name}", which is default-on: delete its entry in ${registry}, and remove every \`GTD_FLAG_${name.toUpperCase()}\` check from the shipped sources. Keep the flag-on path; delete code only the off path reached, including tests that pin the off path.`;
 const cleanupFlow = async () => {

package/dist/workflows/feature.mjs

@@ -1,8 +1,8 @@
 import { agent, answered, applyScript, changes, changesSince, check, codeChanges, env, hasThreadFor, head, human, judge, judgeDiffShape, kept, mark, matches, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireThreadsClosed, revertScript, run, scope, slice, start, vars, wrote } from "../flows.mjs";
 import { lensEntriesOf } from "../workflow-kit.mjs";
-import { $ as naiveApplyFailure, B as coverageMessage, C as coder, Ct as unwindFailure, E as fixNits, Et as testFileGlobs, G as designSystem, H as coveringPrompt, I as builderSystem, K as designTriagePrompt, L as clearCriteriaMessage, N as agentWithSkills, P as buildReviewCollectingPrompt, Q as implementFixPrompt, R as clearCriteriaQuestion, St as unwindFailedMessage, T as fixCheck, Tt as envDefaults, U as criterionLine, V as coverageQuestion, W as designGateAnswerMessage, X as idleMessage, Z as implementBuildingPrompt, _ as REFACTOR_NOTE, _t as seamByHandMessage, a as flagModeOn, at as qualityUnresolvedMessage, b as SLICES, bt as startGateBlockedMessage, ct as refactorFixPrompt, et as naivePassPrompt, f as healthy, g as REFACTOR, gt as reviewerSystem, h as QUALITY, i as skills, k as planner, lt as refactorNotePrompt, m as HANDOFF, n as summary, nt as oversizedMessage, ot as refactorBuildingPrompt, p as FEEDBACK, r as access, s as shipped, st as refactorDroppedRefusal, t as steering, tt as normaliseCriteriaScript, u as gate, ut as refactorRules, v as REQUIREMENTS, vt as seamSteerMessage, w as collecting, wt as defaults, x as answerReviewQuestions, xt as uncoveredMessage, yt as slicingPrompt } from "../chunks/reserved-DJk_6-ju.mjs";
-import { a as refusePendingHandOff, o as tail } from "../chunks/tail-5w5mxGTq.mjs";
-import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-X7Jfz0dY.mjs";
+import { $ as naiveApplyFailure, B as coverageMessage, C as coder, Ct as unwindFailure, E as fixNits, Et as testFileGlobs, G as designSystem, H as coveringPrompt, I as builderSystem, K as designTriagePrompt, L as clearCriteriaMessage, N as agentWithSkills, P as buildReviewCollectingPrompt, Q as implementFixPrompt, R as clearCriteriaQuestion, St as unwindFailedMessage, T as fixCheck, Tt as envDefaults, U as criterionLine, V as coverageQuestion, W as designGateAnswerMessage, X as idleMessage, Z as implementBuildingPrompt, _ as REFACTOR_NOTE, _t as seamByHandMessage, a as flagModeOn, at as qualityUnresolvedMessage, b as SLICES, bt as startGateBlockedMessage, ct as refactorFixPrompt, et as naivePassPrompt, f as healthy, g as REFACTOR, gt as reviewerSystem, h as QUALITY, i as skills, k as planner, lt as refactorNotePrompt, m as HANDOFF, n as summary, nt as oversizedMessage, ot as refactorBuildingPrompt, p as FEEDBACK, r as access, s as shipped, st as refactorDroppedRefusal, t as steering, tt as normaliseCriteriaScript, u as gate, ut as refactorRules, v as REQUIREMENTS, vt as seamSteerMessage, w as collecting, wt as defaults, x as answerReviewQuestions, xt as uncoveredMessage, yt as slicingPrompt } from "../chunks/reserved-ty1mtlnS.mjs";
+import { a as refusePendingHandOff, o as tail } from "../chunks/tail-CM3sVoAb.mjs";
+import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-BmoH-9im.mjs";
 import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {

package/dist/workflows/fix.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, scope, start } from "../flows.mjs";
 import { g as reviewRisks, h as reviewNotes } from "../chunks/steering-D4LUQ-av.mjs";
-import { C as coder, J as fixReviewNotesPrompt, N as agentWithSkills, Tt as envDefaults, c as baseline, i as skills, n as summary, q as finisherSystem, r as access, s as shipped, t as steering, wt as defaults, y as REVIEW } from "../chunks/reserved-DJk_6-ju.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-5w5mxGTq.mjs";
+import { C as coder, J as fixReviewNotesPrompt, N as agentWithSkills, Tt as envDefaults, c as baseline, i as skills, n as summary, q as finisherSystem, r as access, s as shipped, t as steering, wt as defaults, y as REVIEW } from "../chunks/reserved-ty1mtlnS.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-CM3sVoAb.mjs";
 //#region src/workflows/fix/fix.ts
 /**
 * Fix every note a human left in a handed-off `.gtd/REVIEW.md` and every

package/dist/workflows/review.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, start } from "../flows.mjs";
-import { C as coder, N as agentWithSkills, Tt as envDefaults, i as skills, mt as reviewGateBlockedMessage, n as summary, pt as reviewFeedbackFixPrompt, q as finisherSystem, r as access, s as shipped, t as steering, u as gate, v as REQUIREMENTS, wt as defaults } from "../chunks/reserved-DJk_6-ju.mjs";
-import { a as refusePendingHandOff } from "../chunks/tail-5w5mxGTq.mjs";
-import { i as reUnwind, t as buildTail } from "../chunks/review-X7Jfz0dY.mjs";
+import { C as coder, N as agentWithSkills, Tt as envDefaults, i as skills, mt as reviewGateBlockedMessage, n as summary, pt as reviewFeedbackFixPrompt, q as finisherSystem, r as access, s as shipped, t as steering, u as gate, v as REQUIREMENTS, wt as defaults } from "../chunks/reserved-ty1mtlnS.mjs";
+import { a as refusePendingHandOff } from "../chunks/tail-CM3sVoAb.mjs";
+import { i as reUnwind, t as buildTail } from "../chunks/review-BmoH-9im.mjs";
 //#region src/workflows/review/review.ts
 /** Build the concerns a review round collected into `.gtd/REQUIREMENTS.md`, then remove it. */
 const fixFeedback = async () => {

package/dist/workflows/rollout.mjs

@@ -1,5 +1,5 @@
 import { agent, changesSince, glob, head, mark, read, refuse, removeScript, run, scope, vars } from "../flows.mjs";
-import { C as coder, Dt as flagMentions, Tt as envDefaults, i as skills, jt as requireFlag, kt as flipProblems, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, wt as defaults } from "../chunks/reserved-DJk_6-ju.mjs";
+import { Bt as requireFlag, C as coder, It as flagMentions, Rt as flipProblems, Tt as envDefaults, i as skills, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, wt as defaults } from "../chunks/reserved-ty1mtlnS.mjs";
 //#region src/workflows/rollout/rollout.ts
 const flippingPrompt = (name, registry) => `Roll out the release flag "${name}": in ${registry}, set \`defaultOn: true\` on its entry. Change nothing else — no other entry, no other field, no other file, no comments.`;
 const suiteBlockedMessage = () => "The suite is red after the rollout. Fix it by hand — a rollout may only touch the flag's registry entry — then land.";