@pmelab/gtd 28.2.0 → 29.1.0

package/dist/chunks/{tail-B2SER2Ih.mjs → tail-C6YBG5zh.mjs}

@@ -1,6 +1,6 @@
 import { read, refuse, removeScript, run, scope, showScript, vars } from "../flows.mjs";
 import { fixFindings, lensesOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
-import { C as reviewMissing, T as reviewing, U as handOffAwaitReviewMessage, _ as awaitReview, b as fixQuality, c as escalation, d as healthy, g as REVIEW, m as QUALITY, u as guarded, w as reviewQuality, x as fixRisks, y as fixCheck } from "./reserved-DeBS4Ymh.mjs";
+import { E as reviewing, S as fixRisks, T as reviewQuality, W as handOffAwaitReviewMessage, _ as REVIEW, b as fixCheck, c as escalation, d as healthy, m as QUALITY, u as guarded, v as awaitReview, w as reviewMissing, x as fixQuality } from "./reserved-DoHUII2D.mjs";
 //#region src/workflows/shared/tail.ts
 /** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
 const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
@@ -9,13 +9,13 @@ const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
 * finding to `.gtd/QUALITY.md`. Resolves `"findings"` when that file
 * has any.
 */
-const qualityLap = (guard) => qualityLap$1(lensesOf(vars.qualityReviews ?? ""), guarded(reviewQuality, guard), QUALITY);
+const qualityLap = (guard, lenses, base) => qualityLap$1(lenses ?? lensesOf(vars.qualityReviews ?? ""), guarded((lens) => reviewQuality(lens, base), guard), QUALITY);
 /** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
-const fixQualityFindings = (escalations, guard) => fixFindings({
-	fix: guarded(fixQuality, guard),
+const fixQualityFindings = (escalations, guard, guardRests = true, rules) => fixFindings({
+	fix: guarded(() => fixQuality(rules), guard),
 	findings: QUALITY,
 	cap: 3,
-	escalate: () => escalation(escalations, guard)
+	escalate: () => escalation(escalations, guard, guardRests, rules)
 });
 /** `.gtd/REVIEW.md` removed at the end of a round at commit `round`. */
 const closeReview = (round) => run("review.closing", removeScript([REVIEW, REVIEW_ORIG]), {
@@ -30,26 +30,33 @@ const refusePendingHandOff = () => {
 * The build tail: fix (when entered red), keep green, the quality lap, then
 * `finish` — the human review, as the calling workflow runs it. `green`: the
 * caller just left the full suite green (the package loop), so no run opens it.
+* `guardRests: false` leaves the escalation's human rests unguarded.
 */
-const tail = (fixFirst, finish, green = false, guard) => scope("build", async () => {
+const tail = (fixFirst, finish, green = false, guard, lenses, guardRests = true, lensBase, rules) => scope("build", async () => {
 	const escalations = { rounds: 0 };
-	const fix = fixCheck;
+	const fix = () => fixCheck(rules);
 	const repair = async () => {
 		await guarded(fix, guard)();
 		await healthy(fix, {
 			fixesSoFar: 1,
 			escalations,
-			guard
+			guard,
+			guardRests,
+			rules
 		});
 	};
 	if (fixFirst) await repair();
 	else if (!green) await healthy(fix, {
 		escalations,
-		guard
+		guard,
+		guardRests,
+		rules
 	});
-	if (await qualityLap(guard) === "findings") if (await fixQualityFindings(escalations, guard)) await healthy(fix, {
+	if (await qualityLap(guard, lenses, lensBase) === "findings") if (await fixQualityFindings(escalations, guard, guardRests, rules)) await healthy(fix, {
 		escalations,
-		guard
+		guard,
+		guardRests,
+		rules
 	});
 	else await repair();
 	return finish(escalations);
@@ -61,7 +68,7 @@ const tail = (fixFirst, finish, green = false, guard) => scope("build", async ()
 */
 const handOffReview = (base, escalations, guard) => reviewToHandOff(base, {
 	file: REVIEW,
-	reviewing: guarded(reviewing, guard),
+	reviewing: guarded((b, carry) => reviewing(b, carry), guard),
 	fixRisks: guarded(fixRisks, guard),
 	keepGreen: () => healthy(fixCheck, {
 		escalations,

package/dist/testkit.mjs

@@ -13726,7 +13726,8 @@ const testRepo = (options) => {
 			throw new Error(`the process did not rest within ${maxBeats} beats`);
 		},
 		subjects: () => repo.commitHistory().map(({ message }) => message.split("\n")[0] ?? ""),
-		messages: () => repo.commitHistory().map(({ message }) => message)
+		messages: () => repo.commitHistory().map(({ message }) => message),
+		hashes: () => repo.commitHistory().map(({ hash }) => hash)
 	};
 	return self;
 };

package/dist/workflow-kit.mjs

@@ -1,5 +1,5 @@
 import { changes, changesSince, hasThreadFor, head, read, refuse, requireReplies, requireThreadsClosed, scope } from "./flows.mjs";
-import { c as stripCodeThreads, d as reviewNotes, f as reviewRisks } from "./chunks/steering-DVILanVf.mjs";
+import { c as stripCodeThreads, d as reviewNotes, f as reviewRisks, y as parseThreads } from "./chunks/steering-DVILanVf.mjs";
 //#region src/workflow-kit/health.ts
 /** Hand a red suite that repeated attempts could not fix to a person, until `limit` rounds are spent. */
 const escalation = async (count, steps) => {
@@ -122,14 +122,28 @@ const removedAssertions = (changes) => changes.filter((c) => c.path.endsWith(".f
 }).filter((r) => r.lines.length > 0);
 //#endregion
 //#region src/workflow-kit/review.ts
-const collect = async (p, capture) => {
-	await p.collecting(capture);
+const collect = async (p, capture, round, requested) => {
+	await p.collecting(capture, round);
 	if (read(p.feedback) !== void 0) return "feedback";
-	if (changes().length === 0) return "signoff";
+	if (changes().length === 0) {
+		if (p.refusals.dropped !== void 0 && requested !== void 0 && requested.notes.length + requested.paths.length > 0) return refuse(p.refusals.dropped(requested));
+		return "signoff";
+	}
 	return refuse(p.refusals.unmatched);
 };
-/** A review with ticks, footnote markers and thread definitions removed: what is left is line notes. */
-const notesOf = (text) => text.replace(/^\[\^[^\]]+\]:[^\n]*(\n(?: {2,}|\t)[^\n]*|\n(?=\s*\n(?: {2,}|\t)))*/gm, "").replace(/\[\^[^\]]+\]/g, "").replace(/\[x\]/gi, "[ ]").replace(/\s+/g, " ").trim();
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* A review with ticks and THREAD footnotes (definition plus markers) removed:
+* what is left is line notes and one-shot footnotes, which the triage judges.
+*/
+const notesOf = (text) => {
+	let out = text;
+	for (const { name } of parseThreads(text)) {
+		const n = escapeRe(name);
+		out = out.replace(new RegExp(`^\\[\\^${n}\\]:[^\\n]*(\\n(?: {2,}|\\t)[^\\n]*|\\n(?=\\s*\\n(?: {2,}|\\t)))*`, "gim"), "").replace(new RegExp(`\\[\\^${n}\\]`, "gi"), "");
+	}
+	return out.replace(/\[x\]/gi, "[ ]").replace(/\s+/g, " ").trim();
+};
 /**
 * The human gate and its reply rounds: a question gets an answer inside
 * the review file and rests at the gate again, without a lap. Resolves the
@@ -147,7 +161,7 @@ const converse = async (p, base, collectedBefore) => {
 		}
 		requireThreadsClosed(p.file);
 		if (!hasThreadFor("agent", p.file)) return collectedAt;
-		await p.collecting(p.captures.edits(head()));
+		await p.collecting(p.captures.edits(head()), "reply");
 		collectedAt = head();
 		requireReplies(p.file);
 		if (!hasThreadFor("human", p.file)) return collectedAt;
@@ -176,7 +190,10 @@ const routeNotes = async (p, notes, r) => {
 	if (deferred.length > 0) await p.defer(deferred);
 	if (edits.length > 0) {
 		await r.close();
-		return r.outcome(await collect(p, p.captures.editNotes(r.round, edits, answeredAt)));
+		return r.outcome(await collect(p, p.captures.editNotes(r.round, edits, answeredAt), "triaged", {
+			notes: edits,
+			paths: []
+		}));
 	}
 	if (nits.length > 0) {
 		await r.close();
@@ -207,34 +224,47 @@ 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, reopened, ctx) => {
+	const notes = reviewNotes(before, read(p.file) ?? "");
+	if (notes.length > 0) return routeNotes(p, notes, ctx);
+	if (reopened) return ctx.unfolded();
+	await ctx.close();
+	return ctx.outcome(await collect(p, p.captures.notes(ctx.round), "notes"));
+};
+const toOutcome = (verdict, rest) => verdict === "signoff" ? { verdict } : {
+	verdict,
+	...rest
+};
+const isReopened = (p, r) => r.settled && !r.folded && p.refusals.dropped !== void 0;
 const finish = async (p, reviewed, collectedAt) => {
 	const round = head();
 	const since = changesSince(reviewed);
 	const edited = since.filter((c) => isCodeEdit(p, c));
-	const baselineText = since.get(p.file)?.before ?? "";
-	const record = read(p.file) ?? "";
 	const { folded, settled } = afterCollect(p, collectedAt);
 	const noted = since.some((c) => c.path === p.file);
 	const close = () => p.close(round);
-	const outcome = (verdict) => verdict === "signoff" ? { verdict } : {
-		verdict,
+	const outcome = (verdict) => toOutcome(verdict, {
 		base: round,
 		restoreFrom: reviewed,
 		edited
-	};
+	});
 	const unfolded = async () => {
 		await close();
 		return outcome(folded ? "feedback" : "signoff");
 	};
-	const collectWith = async (capture) => {
+	const reopened = isReopened(p, {
+		settled,
+		folded
+	});
+	if (settled && !reopened || edited.length === 0 && !noted) return unfolded();
+	if (edited.length > 0) {
 		await close();
-		return outcome(await collect(p, capture));
-	};
-	if (settled || edited.length === 0 && !noted) return unfolded();
-	if (edited.length > 0) return collectWith(p.captures.edits(round));
-	const notes = reviewNotes(baselineText, record);
-	if (notes.length === 0) return collectWith(p.captures.notes(round));
-	return routeNotes(p, notes, {
+		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 ?? "", reopened, {
 		round,
 		close,
 		outcome,

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { a as flagShipped, ct as defaults, dt as flagReferences, i as skills, lt as envDefaults, mt as requireFlag, n as summary, pt as registryEntry, r as access, t as steering, v as coder } from "../chunks/reserved-DeBS4Ymh.mjs";
-import { i as refusePendingHandOff, r as handOffTail } from "../chunks/tail-B2SER2Ih.mjs";
+import { _t as registryEntry, a as flagShipped, dt as defaults, ft as envDefaults, ht as flagReferences, i as skills, n as summary, r as access, t as steering, vt as requireFlag, y as coder } from "../chunks/reserved-DoHUII2D.mjs";
+import { i as refusePendingHandOff, r as handOffTail } from "../chunks/tail-C6YBG5zh.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 () => {