@pmelab/gtd 38.2.0 → 39.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "38.2.0",
+  "version": "39.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

@@ -213,9 +213,10 @@ Label: Checking the baseline
 ```
 
 A green suite leaves the tree clean, so the process moves on to triage. A red
-suite instead writes `.gtd/FEEDBACK.md`, and the process goes to
-`start-gate.blocked` — same two commands, different outcome, decided entirely by
-what the beat left in the tree.
+suite instead writes `.gtd/FEEDBACK.md`; the process runs it once more at
+`start-gate.recheck`, and only a second red goes to `start-gate.blocked` — same
+two commands, different outcome, decided entirely by what the beat left in the
+tree.
 
 Land the green one, and the beat after it belongs to an agent.
 
@@ -508,7 +509,10 @@ you open the `review` door.
    as-is, handing that document to the next fix turn as its instruction. Two
    such rounds with no fix is the terminal stop: the last analysis stays on disk
    instead of a third being written, and editing it is what gets the next
-   attempt anywhere new.
+   attempt anywhere new. Before any escalation or red-baseline stop the suite
+   runs once more; a pass there continues without you and is recorded as
+   `Gtd-Mark: flaky=<check>` (see
+   [Re-check before a person](docs/configuration.md#re-check-before-a-person)).
 
 4. **You review — the refactor, or on request.** The feature workflow asks for
    one review only on `refactor-first`: of the refactor slice, before the
@@ -745,6 +749,9 @@ it never replays and a config changed since is no refusal:
 - **findings** — the net count of `## ` findings each quality-lap lens added to
   `.gtd/QUALITY.md`, keyed by the lap's lens path (`build.quality.correctness`,
   `refactor.build.quality.correctness`, …)
+- **flaky** — red checks that passed on their re-check (`Gtd-Mark: flaky=…`),
+  keyed by the re-check's full step name (`start-gate.recheck`,
+  `build.health.recheck`, …)
 
 `--json` prints `{ processes, total }`; `--json=total.refactorFirstRate` prints
 one value. Model, phase and lens keys may hold dots a path cannot reach: select

package/dist/chunks/{reserved-C3PgP7XB.mjs → reserved-B6tTYjeb.mjs}

@@ -1,4 +1,4 @@
-import { accessFor, agent, answered, changesSince, check, codeThreads, defineWorkflow, displayPath, env, head, human, judge, numeric, quote, read, refuse, scope, skillsFor, start, vars } from "../flows.mjs";
+import { accessFor, agent, answered, changesSince, check, codeThreads, defineWorkflow, displayPath, env, head, human, judge, mark, numeric, quote, read, refuse, scope, skillsFor, start, vars } from "../flows.mjs";
 import { escalation as escalation$1, gate as gate$1, healthy as healthy$1, lensScopes, lensesOf, removedAssertions } from "../workflow-kit.mjs";
 import { c as String$, g as standardSchemaV1, h as optionalWith, l as Struct, n as Boolean$, s as Number$ } from "./Schema-C6fLlQzx.mjs";
 //#region src/workflows/shared/registry.ts
@@ -1580,6 +1580,19 @@ const baseline = (name, label = "Checking the baseline") => check(name, env.test
 	report: FEEDBACK,
 	label
 });
+/**
+* Re-run a red check as step `name` before a person sees it. Green records
+* `Gtd-Mark: flaky=<red>` on the re-check's landing and resolves `true`.
+*/
+const recheck = async (name, red, options = {}) => {
+	const green = await check(name, env.testCommand ?? "", {
+		...options,
+		report: FEEDBACK,
+		label: "Re-running checks"
+	});
+	if (green) mark("flaky", red);
+	return green;
+};
 const escalationSteps = (rules) => ({
 	limit: 2,
 	describe: () => describeEscalation(rules),
@@ -1630,15 +1643,17 @@ const sameFailure = async (previous, current) => {
 	});
 	return comparable && truncated.length === 0 && answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity));
 };
+const healthSweep = (options) => [ESCALATION, ...options.sweepOnGreen ?? []];
 const runSuite = (options) => check("health.check", env.testCommand ?? "", {
 	report: FEEDBACK,
 	label: "Running checks",
-	sweepOnGreen: [ESCALATION, ...options.sweepOnGreen ?? []]
+	sweepOnGreen: healthSweep(options)
 });
 /**
 * Loop until the suite is green: check, and on red run `fix` — escalating
 * first once `FIX_CAP` fixes are spent, or a judge calls the failure
-* identical to the previous round's.
+* identical to the previous round's. An escalation re-runs the suite once
+* first; a green re-run ends the loop.
 */
 const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	check: () => runSuite(options),
@@ -1647,14 +1662,16 @@ const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	fixesSoFar: options.fixesSoFar ?? 0,
 	sameFailure,
 	escalations: options.escalations ?? { rounds: 0 },
+	recheck: () => recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),
 	escalation: guardedSteps(options.guard, options.describeGuard, options.guardRests, options.rules)
 });
 /**
-* Hold the process at `<name>.blocked` until the suite is green. `guard` runs
+* Hold the process at `<name>.blocked` until the suite is green, re-running a
+* red check once as `<name>.recheck` before resting. `guard` runs
 * after each `blocked` landing only — never after a check, whose refusal would
 * re-run the same script forever.
 */
-const gate = (name, message, guard) => gate$1(name, () => baseline("check"), guarded(() => human("blocked", {
+const gate = (name, message, guard) => gate$1(name, async () => await baseline("check") || recheck("recheck", `${name}.check`), guarded(() => human("blocked", {
 	message,
 	label: "Baseline is red",
 	file: FEEDBACK

package/dist/chunks/{tail-Bkxki2nK.mjs → tail-_CZTP7Hu.mjs}

@@ -1,6 +1,6 @@
 import { read, refuse, removeScript, run, scope, showScript, vars } from "../flows.mjs";
 import { fixFindings, lensEntriesOf, lensOf, qualityLap as qualityLap$1, reviewToHandOff } from "../workflow-kit.mjs";
-import { C as fixCheck, D as reviewMissing, O as reviewQuality, T as fixRisks, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, k as reviewing, l as escalation, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-C3PgP7XB.mjs";
+import { C as fixCheck, D as reviewMissing, O as reviewQuality, T as fixRisks, Y as handOffAwaitReviewMessage, d as guarded, f as healthy, h as QUALITY, k as reviewing, l as escalation, w as fixQuality, x as awaitReview, y as REVIEW } from "./reserved-B6tTYjeb.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";

package/dist/gtd.bundle.mjs

@@ -41406,7 +41406,8 @@ const emptyTally = () => ({
 		naive: 0,
 		rebuild: 0
 	},
-	byLens: record()
+	byLens: record(),
+	flaky: record()
 });
 const sum = (record) => Object.values(record).reduce((a, b) => a + b, 0);
 const finish = (t) => ({
@@ -41426,6 +41427,10 @@ const finish = (t) => ({
 	findings: {
 		total: sum(t.byLens),
 		byLens: t.byLens
+	},
+	flaky: {
+		total: sum(t.flaky),
+		byStep: t.flaky
 	}
 });
 const tallyCost = (t, open, costs, phase) => {
@@ -41482,6 +41487,7 @@ const processMetrics = (commits) => {
 		if (subject.actor === "agent" && CONTINUE.test(at)) add(t.continuations, at.replace(CONTINUE, "$1"), 1);
 		const lens = LENS.exec(at)?.[1];
 		if (lens !== void 0 && commit.findings > 0) add(t.byLens, lens, commit.findings);
+		if (message.marks.some((m) => m.name === "flaky")) add(t.flaky, at, 1);
 		tallyDecision(t, open, at, subject.to);
 	}
 	return finish(t);
@@ -41496,6 +41502,7 @@ const totalMetrics = (all) => {
 		t.doubleWork.naive += m.cost.doubleWork.naive;
 		t.doubleWork.rebuild += m.cost.doubleWork.rebuild;
 		for (const [k, v] of Object.entries(m.findings.byLens)) add(t.byLens, k, v);
+		for (const [k, v] of Object.entries(m.flaky.byStep)) add(t.flaky, k, v);
 	}
 	return {
 		processes: all.length,
@@ -41533,7 +41540,8 @@ const line = (label, m) => {
 		`${label}: ${slices.decided} slices, ${slices.rebuilt} rebuilt (refactor-first ${percent}), ${slices.refactored} refactored`,
 		`${continued} continuations${continued > 0 ? ` (${listed(m.continuations)})` : ""}`,
 		`cost ${cost.total} (${listed(cost.byPhase)}; by model ${listed(cost.byModel) || "-"}), double work ${cost.doubleWork.total}`,
-		`${m.findings.total} findings${m.findings.total > 0 ? ` (${listed(m.findings.byLens)})` : ""}`
+		`${m.findings.total} findings${m.findings.total > 0 ? ` (${listed(m.findings.byLens)})` : ""}`,
+		`${m.flaky.total} flaky${m.flaky.total > 0 ? ` (${listed(m.flaky.byStep)})` : ""}`
 	].join("; ");
 };
 const runHistoryMetricsCommand = (refs, json, out) => gen(function* () {
@@ -42943,9 +42951,10 @@ const COMMAND_ROWS = [
 			"Report how the kept processes went: slices whose naive pass",
 			"landed or was rebuilt (the refactor-first rate), continuations",
 			"per phase, Gtd-Cost by model and phase with the double work of",
-			"a rebuild, and quality-lap findings per lens — per process and",
-			"in total. Each <ref> is read as by history show, but a branch",
-			"name means every process kept from it; none means every ref.",
+			"a rebuild, quality-lap findings per lens, and red checks that",
+			"passed on their re-check — per process and in total. Each <ref>",
+			"is read as by history show, but a branch name means every",
+			"process kept from it; none means every ref.",
 			"Reads commit subjects and trailers, never replays, so a",
 			"changed config is no refusal. --json prints { processes, total",
 			"} as one document; writes nothing"

package/dist/testkit.mjs

@@ -10327,7 +10327,8 @@ const emptyTally = () => ({
 		naive: 0,
 		rebuild: 0
 	},
-	byLens: record()
+	byLens: record(),
+	flaky: record()
 });
 const sum = (record) => Object.values(record).reduce((a, b) => a + b, 0);
 const finish = (t) => ({
@@ -10347,6 +10348,10 @@ const finish = (t) => ({
 	findings: {
 		total: sum(t.byLens),
 		byLens: t.byLens
+	},
+	flaky: {
+		total: sum(t.flaky),
+		byStep: t.flaky
 	}
 });
 const tallyCost = (t, open, costs, phase) => {
@@ -10403,6 +10408,7 @@ const processMetrics = (commits) => {
 		if (subject.actor === "agent" && CONTINUE.test(at)) add(t.continuations, at.replace(CONTINUE, "$1"), 1);
 		const lens = LENS.exec(at)?.[1];
 		if (lens !== void 0 && commit.findings > 0) add(t.byLens, lens, commit.findings);
+		if (message.marks.some((m) => m.name === "flaky")) add(t.flaky, at, 1);
 		tallyDecision(t, open, at, subject.to);
 	}
 	return finish(t);
@@ -10417,6 +10423,7 @@ const totalMetrics = (all) => {
 		t.doubleWork.naive += m.cost.doubleWork.naive;
 		t.doubleWork.rebuild += m.cost.doubleWork.rebuild;
 		for (const [k, v] of Object.entries(m.findings.byLens)) add(t.byLens, k, v);
+		for (const [k, v] of Object.entries(m.flaky.byStep)) add(t.flaky, k, v);
 	}
 	return {
 		processes: all.length,
@@ -10454,7 +10461,8 @@ const line = (label, m) => {
 		`${label}: ${slices.decided} slices, ${slices.rebuilt} rebuilt (refactor-first ${percent}), ${slices.refactored} refactored`,
 		`${continued} continuations${continued > 0 ? ` (${listed(m.continuations)})` : ""}`,
 		`cost ${cost.total} (${listed(cost.byPhase)}; by model ${listed(cost.byModel) || "-"}), double work ${cost.doubleWork.total}`,
-		`${m.findings.total} findings${m.findings.total > 0 ? ` (${listed(m.findings.byLens)})` : ""}`
+		`${m.findings.total} findings${m.findings.total > 0 ? ` (${listed(m.findings.byLens)})` : ""}`,
+		`${m.flaky.total} flaky${m.flaky.total > 0 ? ` (${listed(m.flaky.byStep)})` : ""}`
 	].join("; ");
 };
 const runHistoryMetricsCommand = (refs, json, out) => gen(function* () {
@@ -11855,9 +11863,10 @@ const COMMAND_ROWS = [
 			"Report how the kept processes went: slices whose naive pass",
 			"landed or was rebuilt (the refactor-first rate), continuations",
 			"per phase, Gtd-Cost by model and phase with the double work of",
-			"a rebuild, and quality-lap findings per lens — per process and",
-			"in total. Each <ref> is read as by history show, but a branch",
-			"name means every process kept from it; none means every ref.",
+			"a rebuild, quality-lap findings per lens, and red checks that",
+			"passed on their re-check — per process and in total. Each <ref>",
+			"is read as by history show, but a branch name means every",
+			"process kept from it; none means every ref.",
 			"Reads commit subjects and trailers, never replays, so a",
 			"changed config is no refusal. --json prints { processes, total",
 			"} as one document; writes nothing"

package/dist/workflow-kit.mjs

@@ -17,10 +17,15 @@ const untilSettled = async (check, pending) => {
 };
 const STAMP = /\n<!-- gtd check [0-9a-f]+ -->\n?$/;
 const stripStamp = (text) => text.replace(STAMP, "\n");
+/** `true` when the re-check passed, else the red re-check's report — the one the escalation describes. */
+const recheckReport = async (health) => {
+	if (health.recheck === void 0) return void 0;
+	return await health.recheck() || stripStamp(read(health.report) ?? "");
+};
 /**
 * Loop until the suite is green: check, and on red run `fix` — escalating
 * first once `fixCap` fixes are spent, or `sameFailure` calls the failure
-* identical to the previous round's.
+* identical to the previous round's, unless `recheck` passes.
 */
 const healthy = async (fix, health) => {
 	let fixes = health.fixesSoFar ?? 0;
@@ -34,6 +39,12 @@ const healthy = async (fix, health) => {
 		const stuck = previous !== void 0 && await health.sameFailure(previous, current);
 		previous = current;
 		if (stuck || fixes >= health.fixCap) {
+			const rechecked = await recheckReport(health);
+			if (rechecked === true) {
+				health.escalations.rounds = 0;
+				return;
+			}
+			previous = rechecked ?? previous;
 			await escalation(health.escalations, health.escalation);
 			fixes = 0;
 		}

package/dist/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { Dt as registryEntry, Ot as requireFlag, S as coder, St as envDefaults, Tt as flagReferences, i as skills, n as summary, o as flagShipped, r as access, t as steering, xt as defaults } from "../chunks/reserved-C3PgP7XB.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-Bkxki2nK.mjs";
+import { Dt as registryEntry, Ot as requireFlag, S as coder, St as envDefaults, Tt as flagReferences, i as skills, n as summary, o as flagShipped, r as access, t as steering, xt as defaults } from "../chunks/reserved-B6tTYjeb.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-_CZTP7Hu.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,7 +1,7 @@
 import { agent, answered, applyScript, changes, changesSince, check, codeChanges, env, hasThreadFor, head, human, judge, judgeDiffShape, kept, mark, matches, numeric, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restoreScript, revertScript, run, scope, slice, start, vars, wrote } from "../flows.mjs";
 import { lensEntriesOf, review as review$1 } from "../workflow-kit.mjs";
-import { $ as naiveApplyFailure, A as agentWithSkills, B as coverageQuestion, C as fixCheck, Ct as testFileGlobs, D as reviewMissing, E as planner, F as buildReviewTriageMessage, G as designSystem, H as criterionLine, I as builderSystem, K as designTriagePrompt, L as clearCriteriaMessage, M as buildReviewAwaitAfterDeferMessage, N as buildReviewCollectingPrompt, P as buildReviewFixNitsPrompt, Q as implementFixPrompt, R as clearCriteriaQuestion, S as coder, St as envDefaults, T as fixRisks, U as deferNotesScript, V as coveringPrompt, W as designGateAnswerMessage, X as idleMessage, Z as implementBuildingPrompt, _ as REFACTOR_NOTE, _t as startGateBlockedMessage, a as flagModeOn, at as refactorDroppedRefusal, b as SLICES, bt as unwindFailure, ct as refactorRules, d as guarded, et as naivePassPrompt, f as healthy, ft as reviewNotesCapture, g as REFACTOR, gt as slicingPrompt, h as QUALITY, ht as seamSteerMessage, i as skills, it as refactorBuildingPrompt, j as buildReviewAnswerQuestionsPrompt, k as reviewing, lt as reviewEditNotesCapture, m as HANDOFF, mt as seamByHandMessage, n as summary, nt as oversizedMessage, ot as refactorFixPrompt, p as FEEDBACK, pt as reviewerSystem, r as access, rt as qualityUnresolvedMessage, s as shipped, st as refactorNotePrompt, t as steering, tt as normaliseCriteriaScript, u as gate, ut as reviewEditsCapture, v as REQUIREMENTS, vt as uncoveredMessage, x as awaitReview, xt as defaults, y as REVIEW, yt as unwindFailedMessage, z as coverageMessage } from "../chunks/reserved-C3PgP7XB.mjs";
-import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-Bkxki2nK.mjs";
+import { $ as naiveApplyFailure, A as agentWithSkills, B as coverageQuestion, C as fixCheck, Ct as testFileGlobs, D as reviewMissing, E as planner, F as buildReviewTriageMessage, G as designSystem, H as criterionLine, I as builderSystem, K as designTriagePrompt, L as clearCriteriaMessage, M as buildReviewAwaitAfterDeferMessage, N as buildReviewCollectingPrompt, P as buildReviewFixNitsPrompt, Q as implementFixPrompt, R as clearCriteriaQuestion, S as coder, St as envDefaults, T as fixRisks, U as deferNotesScript, V as coveringPrompt, W as designGateAnswerMessage, X as idleMessage, Z as implementBuildingPrompt, _ as REFACTOR_NOTE, _t as startGateBlockedMessage, a as flagModeOn, at as refactorDroppedRefusal, b as SLICES, bt as unwindFailure, ct as refactorRules, d as guarded, et as naivePassPrompt, f as healthy, ft as reviewNotesCapture, g as REFACTOR, gt as slicingPrompt, h as QUALITY, ht as seamSteerMessage, i as skills, it as refactorBuildingPrompt, j as buildReviewAnswerQuestionsPrompt, k as reviewing, lt as reviewEditNotesCapture, m as HANDOFF, mt as seamByHandMessage, n as summary, nt as oversizedMessage, ot as refactorFixPrompt, p as FEEDBACK, pt as reviewerSystem, r as access, rt as qualityUnresolvedMessage, s as shipped, st as refactorNotePrompt, t as steering, tt as normaliseCriteriaScript, u as gate, ut as reviewEditsCapture, v as REQUIREMENTS, vt as uncoveredMessage, x as awaitReview, xt as defaults, y as REVIEW, yt as unwindFailedMessage, z as coverageMessage } from "../chunks/reserved-B6tTYjeb.mjs";
+import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-_CZTP7Hu.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 { d as reviewNotes, f as reviewRisks } from "../chunks/steering-DVILanVf.mjs";
-import { A as agentWithSkills, J as fixReviewNotesPrompt, S as coder, St as envDefaults, c as baseline, i as skills, n as summary, q as finisherSystem, r as access, s as shipped, t as steering, xt as defaults, y as REVIEW } from "../chunks/reserved-C3PgP7XB.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-Bkxki2nK.mjs";
+import { A as agentWithSkills, J as fixReviewNotesPrompt, S as coder, St as envDefaults, c as baseline, i as skills, n as summary, q as finisherSystem, r as access, s as shipped, t as steering, xt as defaults, y as REVIEW } from "../chunks/reserved-B6tTYjeb.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-_CZTP7Hu.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,6 +1,6 @@
 import { start } from "../flows.mjs";
-import { St as envDefaults, dt as reviewGateBlockedMessage, i as skills, n as summary, r as access, s as shipped, t as steering, u as gate, xt as defaults } from "../chunks/reserved-C3PgP7XB.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-Bkxki2nK.mjs";
+import { St as envDefaults, dt as reviewGateBlockedMessage, i as skills, n as summary, r as access, s as shipped, t as steering, u as gate, xt as defaults } from "../chunks/reserved-B6tTYjeb.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-_CZTP7Hu.mjs";
 //#region src/workflows/review/review.ts
 /**
 * Pure review of everything since `reviewBase`: a green gate, the quality

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 { Et as flipProblems, Ot as requireFlag, S as coder, St as envDefaults, i as skills, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, wt as flagMentions, xt as defaults } from "../chunks/reserved-C3PgP7XB.mjs";
+import { Et as flipProblems, Ot as requireFlag, S as coder, St as envDefaults, i as skills, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, wt as flagMentions, xt as defaults } from "../chunks/reserved-B6tTYjeb.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.mjs

@@ -451,10 +451,15 @@ const escalation$1 = async (count, steps) => {
 };
 const STAMP = /\n<!-- gtd check [0-9a-f]+ -->\n?$/;
 const stripStamp = (text) => text.replace(STAMP, "\n");
+/** `true` when the re-check passed, else the red re-check's report — the one the escalation describes. */
+const recheckReport = async (health) => {
+	if (health.recheck === void 0) return void 0;
+	return await health.recheck() || stripStamp(read(health.report) ?? "");
+};
 /**
 * Loop until the suite is green: check, and on red run `fix` — escalating
 * first once `fixCap` fixes are spent, or `sameFailure` calls the failure
-* identical to the previous round's.
+* identical to the previous round's, unless `recheck` passes.
 */
 const healthy$1 = async (fix, health) => {
 	let fixes = health.fixesSoFar ?? 0;
@@ -468,6 +473,12 @@ const healthy$1 = async (fix, health) => {
 		const stuck = previous !== void 0 && await health.sameFailure(previous, current);
 		previous = current;
 		if (stuck || fixes >= health.fixCap) {
+			const rechecked = await recheckReport(health);
+			if (rechecked === true) {
+				health.escalations.rounds = 0;
+				return;
+			}
+			previous = rechecked ?? previous;
 			await escalation$1(health.escalations, health.escalation);
 			fixes = 0;
 		}
@@ -18385,6 +18396,19 @@ const baseline = (name, label = "Checking the baseline") => check(name, env.test
 	report: FEEDBACK,
 	label
 });
+/**
+* Re-run a red check as step `name` before a person sees it. Green records
+* `Gtd-Mark: flaky=<red>` on the re-check's landing and resolves `true`.
+*/
+const recheck = async (name, red, options = {}) => {
+	const green = await check(name, env.testCommand ?? "", {
+		...options,
+		report: FEEDBACK,
+		label: "Re-running checks"
+	});
+	if (green) mark("flaky", red);
+	return green;
+};
 const escalationSteps = (rules) => ({
 	limit: 2,
 	describe: () => describeEscalation(rules),
@@ -18435,15 +18459,17 @@ const sameFailure = async (previous, current) => {
 	});
 	return comparable && truncated.length === 0 && answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity));
 };
+const healthSweep = (options) => [ESCALATION, ...options.sweepOnGreen ?? []];
 const runSuite = (options) => check("health.check", env.testCommand ?? "", {
 	report: FEEDBACK,
 	label: "Running checks",
-	sweepOnGreen: [ESCALATION, ...options.sweepOnGreen ?? []]
+	sweepOnGreen: healthSweep(options)
 });
 /**
 * Loop until the suite is green: check, and on red run `fix` — escalating
 * first once `FIX_CAP` fixes are spent, or a judge calls the failure
-* identical to the previous round's.
+* identical to the previous round's. An escalation re-runs the suite once
+* first; a green re-run ends the loop.
 */
 const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	check: () => runSuite(options),
@@ -18452,14 +18478,16 @@ const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	fixesSoFar: options.fixesSoFar ?? 0,
 	sameFailure,
 	escalations: options.escalations ?? { rounds: 0 },
+	recheck: () => recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),
 	escalation: guardedSteps(options.guard, options.describeGuard, options.guardRests, options.rules)
 });
 /**
-* Hold the process at `<name>.blocked` until the suite is green. `guard` runs
+* Hold the process at `<name>.blocked` until the suite is green, re-running a
+* red check once as `<name>.recheck` before resting. `guard` runs
 * after each `blocked` landing only — never after a check, whose refusal would
 * re-run the same script forever.
 */
-const gate = (name, message, guard) => gate$1(name, () => baseline("check"), guarded(() => human("blocked", {
+const gate = (name, message, guard) => gate$1(name, async () => await baseline("check") || recheck("recheck", `${name}.check`), guarded(() => human("blocked", {
 	message,
 	label: "Baseline is red",
 	file: FEEDBACK
@@ -39578,4 +39606,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, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, isTestFile, judgeSeam, lensEntriesOf, lensOf, lensesOf, naiveAcceptance, naivePass, ordinaryStart, planAndBuild, planner, qualityLap, reUnwind, refactorCollecting, refactorFirst, refactorNote, refactorStrays, requireAcceptance, requireAcceptanceKept, requireCriteria, requireCriteriaFrozen, requireCriteriaIfEdited, requireNoNewFlags, requireNoTestFiles, requireSlices, 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, unwind };
+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, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, gate, guarded, handOffReview, handOffTail, healthy, holdsCallSites, implement, 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, 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, unwind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "38.2.0",
+  "version": "39.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/cli/Cli.ts

@@ -838,9 +838,10 @@ const COMMAND_ROWS: readonly CommandRow[] = [
       "Report how the kept processes went: slices whose naive pass",
       "landed or was rebuilt (the refactor-first rate), continuations",
       "per phase, Gtd-Cost by model and phase with the double work of",
-      "a rebuild, and quality-lap findings per lens — per process and",
-      "in total. Each <ref> is read as by history show, but a branch",
-      "name means every process kept from it; none means every ref.",
+      "a rebuild, quality-lap findings per lens, and red checks that",
+      "passed on their re-check — per process and in total. Each <ref>",
+      "is read as by history show, but a branch name means every",
+      "process kept from it; none means every ref.",
       "Reads commit subjects and trailers, never replays, so a",
       "changed config is no refusal. --json prints { processes, total",
       "} as one document; writes nothing",

package/src/cli/Metrics.test.ts

@@ -163,6 +163,37 @@ describe("processMetrics", () => {
   })
 })
 
+describe("flaky re-checks", () => {
+  it("counts each flaky re-check under its own full step name", () => {
+    const m = processMetrics([
+      {
+        message:
+          "gtd(check): start-gate.recheck → design.triage\n\nGtd-Mark: flaky=start-gate.check",
+        findings: 0,
+      },
+      {
+        message: "gtd(check): build.health.recheck → idle\n\nGtd-Mark: flaky=health.check",
+        findings: 0,
+      },
+      {
+        message:
+          "gtd(check): implement.health.recheck → implement.closing\n\nGtd-Mark: flaky=health.check",
+        findings: 0,
+      },
+      { message: "gtd(agent): seam.naive → seam.check\n\nGtd-Mark: covers=AC-1", findings: 0 },
+      { message: "fix: hand-made\n\nGtd-Mark: flaky=x.check", findings: 0 },
+    ])
+    expect(m.flaky).toEqual({
+      total: 3,
+      byStep: { "start-gate.recheck": 1, "build.health.recheck": 1, "implement.health.recheck": 1 },
+    })
+    expect(totalMetrics([m, m]).flaky).toEqual({
+      total: 6,
+      byStep: { "start-gate.recheck": 2, "build.health.recheck": 2, "implement.health.recheck": 2 },
+    })
+  })
+})
+
 describe("totalMetrics", () => {
   it("adds processes and recomputes the rate over every decision", () => {
     const a = processMetrics([

package/src/cli/Metrics.ts

@@ -45,6 +45,8 @@ export interface Metrics {
     }
   }
   readonly findings: { readonly total: number; readonly byLens: Readonly<Record<string, number>> }
+  /** Keyed by the re-check's full step name, from its subject: the mark's value is scope-relative. */
+  readonly flaky: { readonly total: number; readonly byStep: Readonly<Record<string, number>> }
 }
 
 type Phase = keyof Metrics["cost"]["byPhase"]
@@ -87,6 +89,7 @@ interface Tally {
   readonly byPhase: Record<Phase, number>
   readonly doubleWork: { naive: number; rebuild: number }
   readonly byLens: Record<string, number>
+  readonly flaky: Record<string, number>
 }
 
 const emptyTally = (): Tally => ({
@@ -96,6 +99,7 @@ const emptyTally = (): Tally => ({
   byPhase: { naive: 0, refactor: 0, implement: 0, other: 0 },
   doubleWork: { naive: 0, rebuild: 0 },
   byLens: record(),
+  flaky: record(),
 })
 
 const sum = (record: Readonly<Record<string, number>>): number =>
@@ -116,6 +120,7 @@ const finish = (t: Tally): Metrics => ({
     },
   },
   findings: { total: sum(t.byLens), byLens: t.byLens },
+  flaky: { total: sum(t.flaky), byStep: t.flaky },
 })
 
 /** The open slice: its naive cost so far, and whether its implement turns rebuild it. */
@@ -186,6 +191,7 @@ export const processMetrics = (commits: readonly MetricCommit[]): Metrics => {
       add(t.continuations, at.replace(CONTINUE, "$1"), 1)
     const lens = LENS.exec(at)?.[1]
     if (lens !== undefined && commit.findings > 0) add(t.byLens, lens, commit.findings)
+    if (message.marks.some((m) => m.name === "flaky")) add(t.flaky, at, 1)
     tallyDecision(t, open, at, subject.to)
   }
   return finish(t)
@@ -202,6 +208,7 @@ export const totalMetrics = (all: readonly Metrics[]): Metrics & { readonly proc
     t.doubleWork.naive += m.cost.doubleWork.naive
     t.doubleWork.rebuild += m.cost.doubleWork.rebuild
     for (const [k, v] of Object.entries(m.findings.byLens)) add(t.byLens, k, v)
+    for (const [k, v] of Object.entries(m.flaky.byStep)) add(t.flaky, k, v)
   }
   return { processes: all.length, ...finish(t) }
 }
@@ -257,6 +264,7 @@ const line = (label: string, m: Metrics): string => {
     `${continued} continuations${continued > 0 ? ` (${listed(m.continuations)})` : ""}`,
     `cost ${cost.total} (${listed(cost.byPhase)}; by model ${listed(cost.byModel) || "-"}), double work ${cost.doubleWork.total}`,
     `${m.findings.total} findings${m.findings.total > 0 ? ` (${listed(m.findings.byLens)})` : ""}`,
+    `${m.flaky.total} flaky${m.flaky.total > 0 ? ` (${listed(m.flaky.byStep)})` : ""}`,
   ].join("; ")
 }
 

package/src/workflow-kit/health.ts

@@ -44,16 +44,24 @@ export interface Health {
   /** Shared with other callers in the same run of red checks. */
   readonly escalations: EscalationCount
   readonly escalation: EscalationSteps
+  /** Runs the suite once more before a person is asked; `true` ends the loop as if `check` had passed. */
+  readonly recheck?: () => Promise<boolean>
 }
 
 // check() stamps the report with the commit it ran at, so equal failures differ there.
 const STAMP = /\n<!-- gtd check [0-9a-f]+ -->\n?$/
 const stripStamp = (text: string): string => text.replace(STAMP, "\n")
 
+/** `true` when the re-check passed, else the red re-check's report — the one the escalation describes. */
+const recheckReport = async (health: Health): Promise<true | string | undefined> => {
+  if (health.recheck === undefined) return undefined
+  return (await health.recheck()) || stripStamp(read(health.report) ?? "")
+}
+
 /**
  * Loop until the suite is green: check, and on red run `fix` — escalating
  * first once `fixCap` fixes are spent, or `sameFailure` calls the failure
- * identical to the previous round's.
+ * identical to the previous round's, unless `recheck` passes.
  */
 export const healthy = async (fix: () => Promise<void>, health: Health): Promise<void> => {
   let fixes = health.fixesSoFar ?? 0
@@ -67,6 +75,12 @@ export const healthy = async (fix: () => Promise<void>, health: Health): Promise
     const stuck = previous !== undefined && (await health.sameFailure(previous, current))
     previous = current
     if (stuck || fixes >= health.fixCap) {
+      const rechecked = await recheckReport(health)
+      if (rechecked === true) {
+        health.escalations.rounds = 0
+        return
+      }
+      previous = rechecked ?? previous
       await escalation(health.escalations, health.escalation)
       fixes = 0
     }

package/src/workflows/cleanup/cleanup.test.ts

@@ -160,6 +160,7 @@ describe("the cleanup guard over every later agent turn", () => {
         "build.health.check": (_, r) => {
           if (!stopped) r.write(FEEDBACK, `failing ${runs++}\n`)
         },
+        "build.health.recheck": (_, r) => r.write(FEEDBACK, `failing ${runs++}\n`),
         "build.health.describe": () => undefined,
         "build.health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
         "build.fix": (_, r) => r.write("src/other.ts", `export const n = ${runs}\n`),
@@ -176,6 +177,7 @@ describe("the cleanup guard over every later agent turn", () => {
     await expect(
       driven(guarded("", NO_ACCESS), {
         "build.health.check": (_, r) => r.write(FEEDBACK, `failing ${runs++}\n`),
+        "build.health.recheck": (_, r) => r.write(FEEDBACK, `failing ${runs++}\n`),
         "build.health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
         "build.fix": (_, r) => r.write("src/other.ts", `export const n = ${runs}\n`),
         "build.health.describe": (_, r) => r.write("src/b.ts", NAMED),

package/src/workflows/feature/refactor.test.ts

@@ -436,6 +436,8 @@ const drive = async (
           checks++
           phase = "check"
         }
+        // Re-runs the red check it follows, so it reads red as well.
+        if (request.kind === "run" && name === "health.recheck") phase = "check"
         return Promise.resolve(
           request.kind === "judge" ? { answers: {}, truncated: [] } : undefined,
         )
@@ -806,6 +808,8 @@ const driveReviewed = async (
     // Red checks apply to the tail's own runs, never the refactor lap's.
     checking = request.name === "health.check" && stack.includes("build")
     if (checking && reds > 0) reds--
+    // Re-runs the red check it follows, so it reads red as well.
+    if (request.name === "health.recheck" && stack.includes("build")) checking = true
   }
   const lensEffects = ["correctness", "ponytail-review", "conventions"].map(
     (lens): [string, () => void] => [

package/src/workflows/rollout/rollout.feature

@@ -157,6 +157,10 @@ Feature: rollout turns one release flag default-on and touches nothing else
       """
       1 test failing
       """
+    And step "rollout.suite.recheck" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test still failing
+      """
     When gtd starts workflow "rollout" with "--var flag=alpha"
     And the process is driven
     Then the process rests at "rollout.suite.blocked"
@@ -176,6 +180,10 @@ Feature: rollout turns one release flag default-on and touches nothing else
       """
       1 test failing
       """
+    And step "rollout.suite.recheck" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test still failing
+      """
     When gtd starts workflow "rollout" with "--var flag=alpha"
     And the process is driven
     Then the process rests at "rollout.suite.blocked"
@@ -200,6 +208,10 @@ Feature: rollout turns one release flag default-on and touches nothing else
       """
       1 test failing
       """
+    And step "rollout.suite.recheck" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test still failing
+      """
     When gtd starts workflow "rollout" with "--var flag=alpha"
     And the process is driven
     Then the process rests at "rollout.suite.blocked"
@@ -229,6 +241,10 @@ Feature: rollout turns one release flag default-on and touches nothing else
       """
       1 test failing
       """
+    And step "rollout.suite.recheck" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test still failing
+      """
     When gtd starts workflow "rollout" with "--var flag=alpha"
     And the process is driven
     Then the process rests at "rollout.suite.blocked"

package/src/workflows/rollout/rollout.test.ts

@@ -114,6 +114,7 @@ describe("the rollout workflow", () => {
     const rest = await repo.drive({
       "rollout.flipping": (_, r) => r.write("src/flags/index.ts", FLIPPED),
       "rollout.suite.check": (_, r) => r.write(".gtd/FEEDBACK.md", "1 failing\n"),
+      "rollout.suite.recheck": (_, r) => r.write(".gtd/FEEDBACK.md", "still 1 failing\n"),
     })
     expect(rest).toMatchObject({ state: "rollout.suite.blocked", actor: "human" })
   })
@@ -125,6 +126,7 @@ describe("the rollout workflow", () => {
       await repo.drive({
         "rollout.flipping": (_, r) => r.write("src/flags/index.ts", FLIPPED),
         "rollout.suite.check": (_, r) => r.write(".gtd/FEEDBACK.md", "1 failing\n"),
+        "rollout.suite.recheck": (_, r) => r.write(".gtd/FEEDBACK.md", "still 1 failing\n"),
       })
       return repo
     }

package/src/workflows/shared/health.test.ts

@@ -27,6 +27,7 @@ describe("gate guard", () => {
   const red = {
     first: (_: unknown, r: W) => r.write("f", "1\n"),
     "suite.check": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", "red\n"),
+    "suite.recheck": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", "red again\n"),
   }
 
   it("runs the guard after a blocked landing and lets its refusal stop it", async () => {
@@ -66,6 +67,7 @@ describe("healthy describeGuard", () => {
   let runs = 0
   const handlers = (extra: Record<string, unknown>) => ({
     "health.check": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", `red ${runs++}\n`),
+    "health.recheck": (_: unknown, r: W) => r.write(".gtd/FEEDBACK.md", `red ${runs++}\n`),
     "health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
     fix: (_: unknown, r: W) => r.write("f", `${runs}\n`),
     first: (_: unknown, r: W) => r.write("start", "1\n"),

package/src/workflows/shared/health.ts

@@ -4,8 +4,10 @@ import {
   env,
   human,
   judge,
+  mark,
   numeric,
   vars,
+  type CheckOptions,
   type JudgeQuestion,
 } from "../../flows/index.js"
 import * as kit from "../../workflow-kit/index.js"
@@ -19,6 +21,24 @@ export const FIX_CAP = 3
 export const baseline = (name: string, label = "Checking the baseline"): Promise<boolean> =>
   check(name, env.testCommand ?? "", { report: FEEDBACK, label })
 
+/**
+ * Re-run a red check as step `name` before a person sees it. Green records
+ * `Gtd-Mark: flaky=<red>` on the re-check's landing and resolves `true`.
+ */
+export const recheck = async (
+  name: string,
+  red: string,
+  options: Pick<CheckOptions, "sweepOnGreen"> = {},
+): Promise<boolean> => {
+  const green = await check(name, env.testCommand ?? "", {
+    ...options,
+    report: FEEDBACK,
+    label: "Re-running checks",
+  })
+  if (green) mark("flaky", red)
+  return green
+}
+
 export type { EscalationCount } from "../../workflow-kit/index.js"
 
 const escalationSteps = (rules?: string): kit.EscalationSteps => ({
@@ -117,18 +137,24 @@ export interface HealthOptions {
   readonly rules?: string | undefined
 }
 
+// Swept only on green: an unresolved analysis survives every retry.
+const healthSweep = (options: HealthOptions): string[] => [
+  ESCALATION,
+  ...(options.sweepOnGreen ?? []),
+]
+
 const runSuite = (options: HealthOptions): Promise<boolean> =>
   check("health.check", env.testCommand ?? "", {
     report: FEEDBACK,
     label: "Running checks",
-    // Swept only on green: an unresolved analysis survives every retry.
-    sweepOnGreen: [ESCALATION, ...(options.sweepOnGreen ?? [])],
+    sweepOnGreen: healthSweep(options),
   })
 
 /**
  * Loop until the suite is green: check, and on red run `fix` — escalating
  * first once `FIX_CAP` fixes are spent, or a judge calls the failure
- * identical to the previous round's.
+ * identical to the previous round's. An escalation re-runs the suite once
+ * first; a green re-run ends the loop.
  */
 export const healthy = (fix: () => Promise<void>, options: HealthOptions = {}): Promise<void> =>
   kit.healthy(guarded(fix, options.guard), {
@@ -138,6 +164,8 @@ export const healthy = (fix: () => Promise<void>, options: HealthOptions = {}):
     fixesSoFar: options.fixesSoFar ?? 0,
     sameFailure,
     escalations: options.escalations ?? { rounds: 0 },
+    recheck: () =>
+      recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),
     escalation: guardedSteps(
       options.guard,
       options.describeGuard,
@@ -147,13 +175,14 @@ export const healthy = (fix: () => Promise<void>, options: HealthOptions = {}):
   })
 
 /**
- * Hold the process at `<name>.blocked` until the suite is green. `guard` runs
+ * Hold the process at `<name>.blocked` until the suite is green, re-running a
+ * red check once as `<name>.recheck` before resting. `guard` runs
  * after each `blocked` landing only — never after a check, whose refusal would
  * re-run the same script forever.
  */
 export const gate = (name: string, message: string, guard?: Guard): Promise<void> =>
   kit.gate(
     name,
-    () => baseline("check"),
+    async () => (await baseline("check")) || recheck("recheck", `${name}.check`),
     guarded(() => human("blocked", { message, label: "Baseline is red", file: FEEDBACK }), guard),
   )

package/src/workflows/shared/recheck.feature

@@ -0,0 +1,60 @@
+@inmem
+Feature: a red check is re-run once before it reaches a person
+
+  Before the fix loop escalates, `healthy` re-runs the suite as
+  `health.recheck`. Green there ends the loop as if the check had passed, and
+  the re-check's landing records `Gtd-Mark: flaky=health.check`. Red again
+  escalates as before.
+
+  Background:
+    Given a gtd config with:
+      """
+      import { healthy } from "@pmelab/gtd/workflows"
+      import { agent, human } from "@pmelab/gtd/flows"
+
+      export const held = async () => {
+        await agent("first", "go")
+        await healthy(() => agent("fix", "go"))
+        await human("done")
+      }
+      export default held
+      """
+    And step "first" writes "src/a.ts" with:
+      """
+      export const a = 1
+      """
+    And step "health.check" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test failing
+      """
+    And step "fix" deletes ".gtd/FEEDBACK.md"
+    And judge step "health.judge" answers:
+      """
+      [{"id":"verdict","answer":"progress","p":0.9}]
+      """
+
+  Scenario: a re-check that passes ends the loop without a person, recorded as flaky
+    Given step "health.recheck" deletes ".gtd/FEEDBACK.md"
+    When gtd starts workflow "held"
+    And the process is driven
+    Then the process rests at "done"
+    And the commit subjects end with:
+      """
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → health.recheck
+      gtd(check): health.recheck → done
+      """
+    And the last commit body contains "Gtd-Mark: flaky=health.check"
+    And ".gtd/FEEDBACK.md" does not exist
+
+  Scenario: a re-check that stays red escalates, with nothing recorded as flaky
+    Given step "health.recheck" writes ".gtd/FEEDBACK.md" with:
+      """
+      1 test still failing
+      """
+    When gtd starts workflow "held"
+    And the process is driven
+    Then the process rests at "health.describe"
+    And the last commit subject is "gtd(check): health.recheck → health.describe"
+    And no commit body contains "Gtd-Mark: flaky="