@pmelab/gtd 44.0.0 → 45.1.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 = [
@@ -17083,6 +17197,11 @@ const testFileGlobs = [
 	"**/__tests__/**"
 ];
 const defaultFlagRegistry = "src/flags/index.ts";
+/** The `tests` workflow's own process settings: where it looks for skipped tests, and how a skip reads. */
+const testsDefaults = {
+	testFiles: testFileGlobs.join(", "),
+	skipPattern: "^\\s*(?:(?:describe|context|suite|it|test|specify)\\.(?:skip|todo)\\b|x(?:describe|context|it|test|specify)\\s*\\(|(?:@\\S+\\s+)*@(?:skip|ignore)(?:\\s|$))"
+};
 /** Process settings. */
 const defaults = {
 	reviewBase: "",
@@ -17091,6 +17210,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 +17470,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 +17514,7 @@ const SUMMARY_TITLES = [
 	"Weakened scenarios",
 	"Fixed from your notes",
 	"Fixed automatically",
+	"Standards added",
 	"Dropped as noise",
 	"Nothing to note"
 ];
@@ -17410,7 +17534,9 @@ const composedReview = (base, report) => {
 		return name;
 	};
 	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 answerBoxes = ([fix, wontFix] = [ANSWER_FIX, ANSWER_WONT_FIX]) => `${ANSWER_LEAD}\n\n- [ ] ${fix}\n- [ ] ${wontFix}\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 +17545,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")}`)],
-		...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}`)),
+		...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(n.answers)}`)),
 		...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 +25747,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 +31755,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 +31888,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 +31923,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 +32123,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 +38170,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,
@@ -38104,6 +38233,24 @@ const flagShipped = (flow, name) => defineWorkflow(standardSchemaV1(FlagOptions,
 		base: void 0
 	};
 });
+const TestsOptions = Struct({
+	...ShippedOptions.fields,
+	testFiles: setting$1,
+	skipPattern: setting$1
+});
+const testsShipped = (flow) => defineWorkflow(standardSchemaV1(TestsOptions, {
+	onExcessProperty: "error",
+	errors: "all"
+}), ({ contextLimit, ...options }) => ({
+	flow: limited(flow, contextLimit),
+	defaults: over({
+		...defaults,
+		...testsDefaults
+	}, options),
+	envDefaults: over(envDefaults, options),
+	doors: { tests: {} },
+	base: void 0
+}));
 //#endregion
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
@@ -38112,7 +38259,7 @@ const NO_FINDINGS = {
 	noise: []
 };
 const UNTITLED = "Quality findings";
-const below = (section) => section.split("\n").slice(1).join("\n").trim();
+const below$1 = (section) => section.split("\n").slice(1).join("\n").trim();
 const strayProse = (text, sections) => sections.reduce((rest, body) => rest.replace(body, "\n"), text).split("\n").filter((line) => !/^#\s/.test(line)).join("\n").trim();
 /** The findings in `text`, one per `## ` section, in file order, numbered `Q<n>`. */
 const findingsOf = (text) => {
@@ -38123,7 +38270,7 @@ const findingsOf = (text) => {
 		body: stray
 	}], ...sections.map((s) => ({
 		title: s.title,
-		body: below(s.body)
+		body: below$1(s.body)
 	}))].map((f, i) => ({
 		id: `Q${i + 1}`,
 		...f
@@ -38600,6 +38747,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 +39029,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,
@@ -38745,7 +39048,7 @@ const composing = (base, report, carry, nitFix, answered = /* @__PURE__ */ new S
 * praise dropped.
 */
 const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
-	const { guard, guardRests, fixAccess, rules } = options;
+	const { guard, guardRests, fixAccess, rules, awaitMessage } = options;
 	const feedback = options.feedback ?? {
 		file: ".gtd/REQUIREMENTS.md",
 		collecting,
@@ -38770,11 +39073,14 @@ const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 			guardRests,
 			rules
 		}),
-		awaitReview: (b) => awaitReview(b),
+		awaitReview: (b) => awaitReview(b, awaitMessage?.(b)),
 		reviewMissing,
 		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);
@@ -38827,6 +39133,17 @@ const callForm = (first, second, [third, fourth, ...extra]) => {
 	if (typeof second === "string") return legacyForm(first, second, third, fourth);
 	if (typeof first === "string") return currentForm(first, second, third, fourth);
 };
+/** 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" });
+};
 /**
 * Undo the human's review-round code edits. A path changed since the human
 * left it is not overwritten; requireRevert names it instead.
@@ -39840,6 +40157,8 @@ const skills = (vars) => {
 		design: ["spec-driven-development", "planning-and-task-breakdown"],
 		notes: ["incremental-implementation", "code-simplification"],
 		feedback: ["test-driven-development", "incremental-implementation"],
+		tests: ["test-audit", "test-driven-development"],
+		"tests.health": ["debugging-and-error-recovery"],
 		...build,
 		...Object.fromEntries(Object.entries(build).map(([name, list]) => [`refactor.${name}`, list])),
 		refactor: ["ponytail"],
@@ -39873,17 +40192,6 @@ 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" });
-};
 /**
 * The feature's review of everything since `reviewBase` — a green gate, the
 * triaged quality lap, then the human review — with no design phase: a
@@ -40017,6 +40325,191 @@ const cleanupFlow = async () => {
 };
 const cleanup = flagShipped(cleanupFlow, "cleanup");
 //#endregion
+//#region src/workflows/tests/tests.ts
+const TESTS = ".gtd/TESTS.md";
+const RETIRE = ".gtd/RETIRE.md";
+/** The first two answer boxes of a deletion proposal; the third stays the human's own answer. */
+const RETIRE_ANSWERS = ["delete it", "keep it skipped"];
+testsDefaults.skipPattern;
+/** `skipPattern` as a per-line expression; refuses one that is blank, invalid, or matches every line. */
+const skipExpression = (pattern) => {
+	if (pattern.trim() === "") return refuse("gtd: skipPattern must not be blank");
+	let expression;
+	try {
+		expression = new RegExp(pattern);
+	} catch (error) {
+		return refuse(`gtd: skipPattern is not a valid regular expression: ${String(error)}`);
+	}
+	if (expression.test("")) return refuse("gtd: skipPattern must not match the empty string");
+	return expression;
+};
+/** Every line of `files` the expression calls skipped, in file then line order. */
+const skipsIn = (files, expression) => files.flatMap(({ path, text }) => text.split("\n").flatMap((line, i) => expression.test(line) ? [{
+	path,
+	line: i + 1,
+	text: line.trim()
+}] : []));
+const testPaths = () => {
+	const globs = (vars.testFiles ?? testsDefaults.testFiles).split(",").map((g) => g.trim()).filter((g) => g !== "");
+	return [...new Set(globs.flatMap((g) => glob(g)))].filter(isCode$1).sort();
+};
+const scan = (paths, expression) => skipsIn(paths.map((path) => ({
+	path,
+	text: read(path) ?? ""
+})), expression);
+/** A section title as a repository path: backticks and a leading `./` dropped. */
+const pathOf = (title) => title.replace(/`/g, "").trim().replace(/^\.\//, "");
+const below = (section) => section.split("\n").slice(1).join("\n").trim();
+const sweepingPrompt = (skips) => `Sweep this repository's tests for ones to revive.
+
+Skipped tests gtd found:
+
+${skips.length === 0 ? "- none" : skips.map((s) => `- ${s.path}:${s.line} — ${s.text}`).join("\n")}
+
+- Audit every test in the repository with the test-audit skill — the whole
+  suite, not a recent change
+- Write \`${TESTS}\`: \`# Tests\`, then one \`## <path>\` section per test file
+  that needs work — every file listed above, and each file the audit found
+  worth rewriting — saying which tests are skipped and what the audit found
+- Change nothing else; write nothing when there is nothing to do
+- Leave everything uncommitted and finish your turn`;
+const rewritingPrompt = (path, found) => `Rewrite the tests in \`${path}\` until none is skipped and the suite is green.
+
+What the sweep found:
+
+${found || "_Nothing more than the skipped tests._"}
+
+- Unskip every skipped test in the file and make it pass, rewriting it where
+  it rotted, and fix what the audit found
+- A test that is obsolete — what it tests is gone, or another test already
+  covers it — stays skipped: never delete it. Propose its deletion in
+  \`${RETIRE}\` instead: a \`## <title>\` section naming \`${path}\`, the test,
+  and why it should go. A person decides. Propose a line gtd misread as
+  skipped (fixture text, a comment) the same way, saying so
+- Delete no test file
+- Leave everything uncommitted and finish your turn`;
+const gateMessage = () => `The test baseline is red — gtd will not revive skipped tests on a broken suite.
+\`.gtd/FEEDBACK.md\` holds the failing output.
+
+What each change does next (then run \`gtd land\`):
+- **Retry check** — edit the code and/or \`.gtd/FEEDBACK.md\` to fix the failing tests (**tests-gate.check**).
+`;
+const awaitMessage = (base) => `\`.gtd/REVIEW.md\` holds one chunk per test the sweep would delete. Each ends in
+three boxes — tick exactly one: \`delete it\` (the test is deleted, then the
+suite runs), \`keep it skipped\` (dropped, recorded in the commit), or write your
+own answer over \`_your answer_\` and tick it (judged like a note). Every
+landing here is refused until each proposal holds exactly one tick. An agent
+turn that deleted a test file was refused; check the diff for tests removed
+inside a file.
+
+Review the revived tests yourself:
+
+    git diff ${base}
+
+Then run \`gtd land\`. A note or code edit of your own is read as feedback and
+built before you review again.
+`;
+/** A proposal's own text, made a request the nit fixer acts on once the human ticks `delete it`. */
+const proposals = (text) => sectionBodies(text).map((s, i) => ({
+	id: `R${i + 1}`,
+	title: s.title,
+	body: `Delete this skipped test.\n\n${below(s.body)}`,
+	answers: RETIRE_ANSWERS
+}));
+/** Sections of `text` that name `path` as a whole token — a trailing full stop still counts. */
+const naming = (text, path) => {
+	const token = new RegExp(`(?<![\\w./-])${path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w/-])`);
+	return sectionBodies(text).filter((s) => token.test(s.body.replace(/(^|[^\w.])\.\//g, "$1"))).length;
+};
+/** Refuses a test file a turn deleted, and a skip left in the file being rewritten that `.gtd/RETIRE.md` does not name. */
+const guardFor = (known, expression, path) => () => {
+	const deleted = changes().filter((c) => c.status === "deleted" && known.has(c.path)).map((c) => c.path);
+	if (deleted.length > 0) refuse(`gtd land: tests: ${deleted.join(", ")} deleted — a test goes only once a person ticks "delete it" at the review`);
+	if (path === void 0) return;
+	const left = scan([path], expression).slice(naming(read(RETIRE) ?? "", path));
+	if (left.length > 0) refuse(`gtd land: tests: ${left.map((s) => `${s.path}:${s.line}`).join(", ")} still skipped — revive it, or propose its deletion in ${RETIRE}`);
+};
+/** The sweep's packages, refused when it changed more than its plan or the plan misses a file. */
+const planned = (skips, known) => {
+	const strays = changes().filter((c) => c.path !== TESTS);
+	if (strays.length > 0) refuse(`gtd land: tests: the sweep changed ${strays.map((c) => c.path).join(", ")} — it writes only ${TESTS}`);
+	const packages = sectionBodies(read(TESTS) ?? "").map((s) => ({
+		path: pathOf(s.title),
+		found: below(s.body)
+	}));
+	const missing = [...packages.filter((p) => !known.has(p.path)).map((p) => `"${p.path}" is no test file`), ...[...new Set(skips.map((s) => s.path))].filter((path) => !packages.some((p) => p.path === path)).map((path) => `${path} has no section`)];
+	if (missing.length > 0) refuse(`gtd land: tests: in ${TESTS}, ${missing.join("; ")}`);
+	return packages;
+};
+/**
+* Revive or retire skipped tests: a sweep plans one package per test file, each
+* is rewritten until unskipped and green, and what an agent calls obsolete
+* reaches the human review as a deletion proposal only a person can tick.
+*/
+const testsFlow = async () => {
+	refusePendingHandOff();
+	for (const file of [
+		REQUIREMENTS,
+		TESTS,
+		RETIRE
+	]) if (read(file) !== void 0) refuse(`gtd: ${file} is left over — finish or remove it first.`);
+	const expression = skipExpression(vars.skipPattern ?? testsDefaults.skipPattern);
+	await gate("tests-gate", gateMessage());
+	const base = start();
+	const known = new Set(testPaths());
+	const guard = guardFor(known, expression);
+	const report = await scope("tests", async () => {
+		const skips = scan([...known], expression);
+		await agentWithSkills("sweeping", sweepingPrompt(skips), {
+			label: "Sweeping the tests",
+			file: TESTS,
+			model: coder(),
+			system: finisherSystem(),
+			allowEmpty: true
+		});
+		guard();
+		const packages = planned(skips, known);
+		for (const { path, found } of packages) {
+			const guarded = guardFor(known, expression, path);
+			await agentWithSkills("rewriting", rewritingPrompt(path, found), {
+				label: `Rewriting ${path}`,
+				file: RETIRE,
+				model: coder(),
+				system: finisherSystem(),
+				allowEmpty: true
+			});
+			guarded();
+			if (!changes().some((c) => isCode$1(c.path))) continue;
+			await healthy(() => fixCheck(), {
+				guard: guarded,
+				guardRests: false
+			});
+		}
+		const retired = proposals(read(RETIRE) ?? "");
+		if (read(TESTS) !== void 0 || read(RETIRE) !== void 0) await run("closing", removeScript([TESTS, RETIRE]), { label: "Closing the sweep" });
+		const changed = changesSince(base).paths.some(isCode$1);
+		return retired.length === 0 && !changed ? void 0 : {
+			notes: retired,
+			fixed: [],
+			noise: []
+		};
+	});
+	if (report === void 0) return;
+	let outcome = await tail((escalations) => humanReview(base, escalations, {
+		report,
+		awaitMessage: report.notes.length > 0 ? awaitMessage : void 0
+	}), {
+		lenses: [],
+		green: true
+	});
+	while (outcome.verdict === "feedback") {
+		await reUnwind(outcome);
+		await fixFeedback();
+		outcome = await tail((escalations) => humanReview(base, escalations), { lenses: [] });
+	}
+};
+const tests = testsShipped(testsFlow);
+//#endregion
 //#region src/workflows/index.ts
 var workflows_default = feature;
 /**
@@ -40026,4 +40519,4 @@ var workflows_default = feature;
 */
 const doors = {};
 //#endregion
-export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, HANDOFF, QUALITY, REFACTOR, REFACTOR_NOTE, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, SLICES, ShippedOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeOut, closeReview, coder, collecting, criteriaOf, criterionIds, workflows_default as default, defaults, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, implementing, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, recheck, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, tail, threads, triage, unstableIds, unwind };
+export { COMMENT, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, HANDOFF, QUALITY, REFACTOR, REFACTOR_NOTE, REFACTOR_PACKAGE, REQUIREMENTS, REVIEW, REVIEW_ORIG, SLICES, ShippedOptions, TestsOptions, acceptanceFault, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, awaitReview, base, baseline, buildFeature, buildTail, builtInLenses, cleanup, cleanupFlow, closeOut, closeReview, coder, collecting, criteriaOf, criterionIds, workflows_default as default, defaults, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, implementing, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, recheck, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, requireStableIds, requireTestCallSitesOnly, requireWithin, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewedRefactor, reviewing, rollout, rolloutFlow, seamBuild, skills, skipDesign, sliceCap, sliceCriteria, sliceIds, slicesOf, slicing, statedCriteria, steering, summary, tail, tests, testsFlow, threads, triage, unstableIds, unwind };