@pmelab/gtd 44.0.0 → 45.1.0

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 { Et as envDefaults, Ht as requireFlag, Tt as defaults, Vt as registryEntry, i as skills, n as summary, o as flagShipped, r as access, t as steering, w as coder, zt as flagReferences } from "../chunks/reserved-ulcSkND6.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-BW030xz_.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 implementFixPrompt, A as planner, Ct as unwindFailedMessage, D as fixNits, Dt as testFileGlobs, E as fixCheck, Et as envDefaults, F as buildReviewCollectingPrompt, G as designGateAnswerMessage, H as coverageQuestion, K as designSystem, L as builderSystem, P as agentWithSkills, Q as implementBuildingPrompt, R as clearCriteriaMessage, S as answerReviewQuestions, St as uncoveredMessage, T as collecting, Tt as defaults, U as coveringPrompt, V as coverageMessage, W as criterionLine, Z as idleMessage, _ as REFACTOR, _t as reviewerSystem, a as flagModeOn, bt as slicingPrompt, ct as refactorDroppedRefusal, d as gate, dt as refactorRules, et as naiveApplyFailure, g as QUALITY, h as HANDOFF, i as skills, lt as refactorFixPrompt, m as FEEDBACK, n as summary, nt as normaliseCriteriaScript, ot as qualityUnresolvedMessage, p as healthy, q as designTriagePrompt, r as access, rt as oversizedMessage, s as shipped, st as refactorBuildingPrompt, t as steering, tt as naivePassPrompt, ut as refactorNotePrompt, v as REFACTOR_NOTE, vt as seamByHandMessage, w as coder, wt as unwindFailure, x as SLICES, xt as startGateBlockedMessage, y as REQUIREMENTS, yt as seamSteerMessage, z as clearCriteriaQuestion } from "../chunks/reserved-ulcSkND6.mjs";
+import { a as refusePendingHandOff, o as tail } from "../chunks/tail-BW030xz_.mjs";
+import { a as reUnwind, i as isCode$1, r as humanReview, t as buildTail } from "../chunks/review-Da2ndnB1.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 { Et as envDefaults, J as finisherSystem, P as agentWithSkills, Tt as defaults, Y as fixReviewNotesPrompt, b as REVIEW, i as skills, l as baseline, n as summary, r as access, s as shipped, t as steering, w as coder } from "../chunks/reserved-ulcSkND6.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-BW030xz_.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,19 +1,8 @@
-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 { read, refuse, start } from "../flows.mjs";
+import { Et as envDefaults, Tt as defaults, d as gate, ht as reviewGateBlockedMessage, i as skills, n as summary, r as access, s as shipped, t as steering, y as REQUIREMENTS } from "../chunks/reserved-ulcSkND6.mjs";
+import { a as refusePendingHandOff } from "../chunks/tail-BW030xz_.mjs";
+import { a as reUnwind, n as fixFeedback, t as buildTail } from "../chunks/review-Da2ndnB1.mjs";
 //#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

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 flipProblems, Et as envDefaults, Ht as requireFlag, Rt as flagMentions, Tt as defaults, d as gate, i as skills, m as FEEDBACK, n as summary, o as flagShipped, r as access, t as steering, w as coder } from "../chunks/reserved-ulcSkND6.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.";

package/dist/workflows/tests.mjs

@@ -0,0 +1,193 @@
+import { changes, changesSince, glob, read, refuse, removeScript, run, scope, sectionBodies, start, vars } from "../flows.mjs";
+import { E as fixCheck, Et as envDefaults, J as finisherSystem, Ot as testsDefaults, P as agentWithSkills, Tt as defaults, c as testsShipped, d as gate, i as skills, n as summary, p as healthy, r as access, t as steering, w as coder, y as REQUIREMENTS } from "../chunks/reserved-ulcSkND6.mjs";
+import { a as refusePendingHandOff, o as tail } from "../chunks/tail-BW030xz_.mjs";
+import { a as reUnwind, i as isCode, n as fixFeedback, r as humanReview } from "../chunks/review-Da2ndnB1.mjs";
+//#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).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(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);
+		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/tests/index.ts
+var tests_default = tests;
+//#endregion
+export { access, tests_default as default, defaults, envDefaults, skills, steering, summary, tests, testsFlow };