@pmelab/gtd 43.0.0 → 45.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "43.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
@@ -588,24 +604,28 @@ the agent may overturn the answer. See
 for its `ui:` settings.
 
 The bundled workflows are named `feature` (the ordinary start above), `review`
-and `fix`. They are independent: `review` and `fix` never plan, and they meet
-only in `.gtd/REVIEW.md`. Each brings its own door. This command:
+and `fix`. `review` and `fix` never plan. Each brings its own door. This
+command:
 
 ```bash
 gtd door review <commitish>
 ```
 
-starts a pure review of everything from `<commitish>` to HEAD. It goes straight
-to the quality lap and a review, with no planning and no building; unlike
-`feature`, its lap fixes every finding and a reviewer turn
-(`build.review.reviewing`) writes `.gtd/REVIEW.md`, risks and all. Sign off and
-it closes. Leave notes and the process ends with `.gtd/REVIEW.md` (and the
-reviewer's original, `.gtd/REVIEW.orig.md`) left for `gtd door fix`. Until `fix`
-consumes them, starting `feature` or `review` is refused; remove both files to
-abandon the hand-off. `gtd door fix` fixes those notes and every `Risk:` in one
-turn, then asks for your review of the fix. With no review waiting, it repairs a
-red baseline as its own reviewed commit instead. `gtd doors` lists the doors of
-the workflows your `gtd.config.ts` exports, plus any it adds.
+starts a review of everything from `<commitish>` to HEAD — the same review a
+`feature` process ends with, minus planning and building. A green gate, then the
+quality lenses: mechanical findings are fixed, noise is dropped, and the rest
+become notes in `.gtd/REVIEW.md`, one tick box each. Tick `fix as suggested` or
+write your own answer and the process fixes it in place — your own answers that
+ask for a change are collected into `.gtd/REQUIREMENTS.md` and built by one
+`feedback.fixing` turn, with no design phase and no criteria — under the health
+loop, then asks for your review again. Sign off (or tick `won't fix`) and it
+closes; nothing is left behind. A note asking for new behaviour belongs in a
+`feature` process: tick `won't fix` and start one. `gtd door fix` repairs a red
+baseline as its own reviewed commit; a note at its review is left in
+`.gtd/REVIEW.md` (beside the reviewer's original, `.gtd/REVIEW.orig.md`) for the
+next `gtd door fix`, and until that runs, starting `feature` or `review` is
+refused — remove both files to abandon the hand-off. `gtd doors` lists the doors
+of the workflows your `gtd.config.ts` exports, plus any it adds.
 `gtd --workflow <name>` starts any workflow by name.
 
 The workflow itself is a plain async TypeScript function, and the

package/dist/chunks/{reserved-COEMFEpy.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.")];
@@ -978,6 +1089,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.
 
@@ -1606,6 +1726,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),
@@ -1726,6 +1876,7 @@ const ShippedOptions = Struct({
 	reviewNoteActionable: setting,
 	reviewSeverityMinP: setting,
 	qualityTriageMinP: setting,
+	standardMinP: setting,
 	refactorFlagPattern: setting,
 	seamAllow: setting,
 	sliceMaxCriteria: setting,
@@ -1802,6 +1953,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"],
@@ -1834,4 +1986,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { naivePassPrompt as $, agentWithSkills as A, coverageQuestion as B, fixCheck as C, envDefaults as Ct, reviewMissing as D, flipProblems as Dt, planner as E, flagReferences as Et, builderSystem as F, designTriagePrompt as G, criterionLine as H, clearCriteriaMessage as I, handOffAwaitReviewMessage as J, finisherSystem as K, clearCriteriaQuestion as L, buildReviewCollectingPrompt as M, buildReviewFixNitsPrompt as N, reviewQuality as O, registryEntry as Ot, buildReviewTriageMessage as P, naiveApplyFailure as Q, composedReview as R, coder as S, defaults as St, fixRisks as T, flagMentions as Tt, designGateAnswerMessage as U, coveringPrompt as V, designSystem as W, implementBuildingPrompt as X, idleMessage as Y, implementFixPrompt as Z, REFACTOR_NOTE as _, slicingPrompt as _t, flagModeOn as a, refactorBuildingPrompt as at, SLICES as b, unwindFailedMessage as bt, baseline as c, refactorNotePrompt as ct, guarded as d, reviewEditsCapture as dt, normaliseCriteriaScript as et, healthy as f, reviewGateBlockedMessage as ft, REFACTOR as g, seamSteerMessage as gt, QUALITY as h, seamByHandMessage as ht, skills as i, qualityUnresolvedMessage as it, buildReviewAnswerQuestionsPrompt as j, reviewing as k, requireFlag as kt, escalation as l, refactorRules as lt, HANDOFF as m, reviewerSystem as mt, summary as n, qualityFindingsFile as nt, flagShipped as o, refactorDroppedRefusal as ot, FEEDBACK as p, reviewNotesCapture as pt, fixReviewNotesPrompt as q, access as r, qualityTriageMessage as rt, shipped as s, refactorFixPrompt as st, steering as t, oversizedMessage as tt, gate as u, reviewEditNotesCapture as ut, REQUIREMENTS as v, startGateBlockedMessage as vt, fixQuality as w, testFileGlobs as wt, awaitReview as x, unwindFailure as xt, REVIEW as y, uncoveredMessage as yt, coverageMessage 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 };